In reply to @crtified:crtified.me
Oh, if you need the proper name for that concept: It's a Closure - more obvious with the external module

In reply to @mib:kanp.ai
Nice idea! I hope you share it once you're done! :)

In reply to @janik0:matrix.org
I would try to avoid anything relying on a extra piece of infrastructure that is potentially a single point of failure so the whole proxy thing seems quite meh I find the approach https://github.com/snowfallorg/thaw is taking nice but I have to admit I didn't use it yet.

In reply to @antifuchs:asf.computer
Ooooh, that does look pretty excellent! I’m skeptical of the proxy approach too, and I even more dislike having transitive deps inject those into my system dependencies… so today I switched from Eza to lsd (:

    nixosConfigurations = {
      langhus = inputs.nixpkgs.lib.nixosSystem {
        inherit system;
        inherit pkgs;

        modules = [
          (import ./features/system/networking {
            options = {
              hostname = "langhus";
            };
          })
          ./features/system/bluetooth
          ./features/system/boot

{ lib, ... }:
{
  options = {
    hostname = lib.mkOption {
      type = lib.types.str;
      default = "langhus";
      description = "Hostname for the system";
    };
  };

  config = {
    networking.hostName = options.hostname;
    networking.networkmanager.enable = true;
  };
}

ah, well that's a simple issue. when you do import ./some/expr.nix { some = "options"; }, you first import ./some/expr.nix, which could be anything (in this case what you showed) and then you pass it the attribute set { some = "options"; }. If you really want to do what you're doing, you'd need

{ options }:
{ lib, ... }:
{
  networking.hostName = options.hostname;
  /* ... etc */
}

ah, well that's a simple issue. when you do import ./some/expr.nix { some = "options"; }, you first import ./some/expr.nix, which could be anything (in this case what you showed) and then you pass it the attribute set { some = "options"; }. If you really want to do what you're doing, you'd need

{ options }:
{ lib, ... }:
{
  networking.hostName = options.hostname;
  networking.networkmanager.enable = true;
}

my point is that you're misusing the modules system. ideally you could import like this instead import ./features/system/networking { hostname = "langhus"; } and then have your networking expression be

{ hostname, ... }:
{ lib, ... }: {
  networking = {
    networkmanager.enable = true;
    hostName = hostname;
  };
}

... but you might want to rethink your approach to configuring your hosts altogether. :)

{pkgs, options, ...}:
{
  imports = [];

  options = {
    hostname = pkgs.lib.mkOption {
      type = pkgs.lib.types.str;
      default = "langhus";
      description = "Hostname for the system";
    };
  };

  config = {
    networking.hostName = options.hostname;
    networking.networkmanager.enable = true;
  };
}

          (import ./features/system/networking {
            inherit system;
            inherit pkgs;
            options = {
              hostname = "langhus";
            };
          })

if you wanna go about it like this, you could e.g. have a bunch of modules (like you do), but define a top-level configuration option for all your stuff, i.e.

nixosConfigratuinon = {
  langhus = lib.nixosSystem {
    modules = [
      /* all your modules */
      # ...
      # and then a host-specific module
      ./hosts/langhus
    ];
  };
};

then ./hosts/langhus/default.nix:

{ ... }: {
  options.config = {
    hostname = "langhus"; /* although tbh you should just set `networking.hostName` and if you need to refer to it elsewhere use `config.networking.hostName` */
    /* etc */
  };
}

if you wanna go about it like this, you could e.g. have a bunch of modules (like you do), but define a top-level configuration option for all your stuff, i.e.

nixosConfigratuinon = {
  langhus = lib.nixosSystem {
    modules = [
      ./hosts/langhus
      /* the rest of your modules */
    ];
  };
};

then ./hosts/langhus/default.nix:

{ ... }: {
  options.config = {
    hostname = "langhus"; /* although tbh you should just set `networking.hostName` and if you need to refer to it elsewhere use `config.networking.hostName` */
    /* etc */
  };
}

if you wanna go about it like this, you could e.g. have a bunch of modules (like you do), but define a top-level configuration option for all your stuff, i.e.

nixosConfigratuinon = {
  langhus = lib.nixosSystem {
    modules = [
      ./hosts/langhus
      /* the rest of your modules */
    ];
  };
};

then ./hosts/langhus/default.nix:

{ ... }: {
  options.custom = {
    hostname = "langhus"; /* although tbh you should just set `networking.hostName` and if you need to refer to it elsewhere use `config.networking.hostName` */
    /* etc */
  };
}

then your networking is imported just like all the other ones, but defined as

{ config, ... }: {
  networking.networkmanager.enable = true;
  networking.hostName = config.custom.hostname;
}