From 3e29615db9ac072029557b031ee814f820e49791 Mon Sep 17 00:00:00 2001 From: _cry64 Date: Mon, 9 Mar 2026 02:46:41 +1000 Subject: [PATCH 1/8] example refactor snowflake module system --- nix/snow/default.nix | 173 +--------- nix/snow/flake/default.nix | 38 +++ nix/snow/flake/lib.nix.bak | 318 ++++++++++++++++++ nix/snow/{ => flake}/module.nix | 0 nix/snow/flake/modules/apps.nix | 61 ++++ nix/snow/flake/modules/checks.nix | 21 ++ nix/snow/flake/modules/debug.nix | 78 +++++ nix/snow/flake/modules/devShells.nix | 30 ++ nix/snow/flake/modules/flake.nix | 47 +++ nix/snow/flake/modules/formatter.nix | 52 +++ nix/snow/flake/modules/legacyPackages.nix | 21 ++ nix/snow/flake/modules/moduleWithSystem.nix | 32 ++ .../flake/modules/nixosConfigurations.nix | 36 ++ nix/snow/flake/modules/nixosModules.nix | 26 ++ nix/snow/flake/modules/nixpkgs.nix | 26 ++ nix/snow/flake/modules/overlays.nix | 32 ++ nix/snow/flake/modules/packages.nix | 23 ++ nix/snow/flake/modules/perSystem.nix | 159 +++++++++ nix/snow/flake/modules/transposition.nix | 132 ++++++++ nix/snow/flake/modules/withSystem.nix | 37 ++ nix/snow/{ => flake}/nodes/default.nix | 0 nix/snow/{ => flake}/nodes/shared.nix | 0 nix/snow/{ => flake}/nodes/submodule.nix | 0 nix/snow/flake/outputs/checks.nix | 5 + nix/snow/flake/outputs/deploy.nix | 57 ++++ .../flake/outputs/nixosConfigurations.nix | 67 ++++ 26 files changed, 1306 insertions(+), 165 deletions(-) create mode 100644 nix/snow/flake/default.nix create mode 100644 nix/snow/flake/lib.nix.bak rename nix/snow/{ => flake}/module.nix (100%) create mode 100644 nix/snow/flake/modules/apps.nix create mode 100644 nix/snow/flake/modules/checks.nix create mode 100644 nix/snow/flake/modules/debug.nix create mode 100644 nix/snow/flake/modules/devShells.nix create mode 100644 nix/snow/flake/modules/flake.nix create mode 100644 nix/snow/flake/modules/formatter.nix create mode 100644 nix/snow/flake/modules/legacyPackages.nix create mode 100644 nix/snow/flake/modules/moduleWithSystem.nix create mode 100644 nix/snow/flake/modules/nixosConfigurations.nix create mode 100644 nix/snow/flake/modules/nixosModules.nix create mode 100644 nix/snow/flake/modules/nixpkgs.nix create mode 100644 nix/snow/flake/modules/overlays.nix create mode 100644 nix/snow/flake/modules/packages.nix create mode 100644 nix/snow/flake/modules/perSystem.nix create mode 100644 nix/snow/flake/modules/transposition.nix create mode 100644 nix/snow/flake/modules/withSystem.nix rename nix/snow/{ => flake}/nodes/default.nix (100%) rename nix/snow/{ => flake}/nodes/shared.nix (100%) rename nix/snow/{ => flake}/nodes/submodule.nix (100%) create mode 100644 nix/snow/flake/outputs/checks.nix create mode 100644 nix/snow/flake/outputs/deploy.nix create mode 100644 nix/snow/flake/outputs/nixosConfigurations.nix diff --git a/nix/snow/default.nix b/nix/snow/default.nix index 6993ff1..15c67da 100644 --- a/nix/snow/default.nix +++ b/nix/snow/default.nix @@ -12,180 +12,23 @@ # See the License for the specific language governing permissions and # limitations under the License. { - this, - self, - inputs, - systems, nt, mix, ... } @ args: let - inherit - (builtins) - all - attrNames - elem - mapAttrs - warn - ; - - inherit (inputs.nixpkgs) lib; - inherit (nt) findImport; in mix.newMixture args (mixture: let inherit (mixture) mapNodes; in { - includes.private = [ - ./lib/nodes.nix - ]; + includes = { + private = [ + ./lib/nodes.nix + ]; + public = [ + ./flake + ]; + }; inherit findImport; - - # snow.flake - flake = flakeInputs: root: let - module = lib.evalModules { - class = "snowflake"; - # TODO: abort if inputs contains reserved names - specialArgs = - (flakeInputs - // { - inherit systems root; - inherit (this) snow; - inputs = flakeInputs; - }) - |> (x: builtins.removeAttrs x ["self" "nodes"]); - - modules = [ - ./module.nix - ({config, ...}: { - _module.args = { - self = config; - nodes = config.nodes.nodes; - }; - }) - ]; - }; - - nodes = module.config.nodes; - in rec { - nixosConfigurations = mapNodes nodes ( - { - base, - lib, - name, - node, - groupModules, - ... - }: let - homeManager = - if node.homeManager != null - then node.homeManager - else if nodes.homeManager != null - then nodes.homeManager - else - warn '' - [snowflake] Neither `nodes.homeManager` nor `nodes.nodes.${name}.homeManager` were specified! - [snowflake] home-manager will NOT be used! User configuration will be ignored! - '' - null; - - userArgs = nodes.args // node.args; - ceruleanArgs = { - inherit systems root base nodes node; - inherit (node) system; - inherit (this) snow; - hostname = name; - - _cerulean = { - inherit inputs userArgs ceruleanArgs homeManager; - specialArgs = userArgs // ceruleanArgs; - }; - }; - specialArgs = assert (userArgs - |> attrNames - |> all (argName: - ! ceruleanArgs ? argName - || abort '' - `specialArgs` are like super important to Cerulean my love... rollback; - magicRollback = magicRollback -> rollback; - activationTimeout = activationTimeout; - confirmTimeout = confirmTimeout; - - remoteBuild = remoteBuild; - sshUser = ssh.user; - sshOpts = - ssh.opts - ++ ( - if elem "-p" ssh.opts - then [] - else ["-p" (toString ssh.port)] - ) - ++ ( - if elem "-A" ssh.opts - then [] - else ["-A"] - ); - }; - }); - - checks = - inputs.deploy-rs.lib - |> mapAttrs (system: deployLib: - deployLib.deployChecks deploy); - }; }) diff --git a/nix/snow/flake/default.nix b/nix/snow/flake/default.nix new file mode 100644 index 0000000..fad3c6d --- /dev/null +++ b/nix/snow/flake/default.nix @@ -0,0 +1,38 @@ +{ + this, + inputs, + systems, + ... +}: let + inherit (inputs.nixpkgs) lib; +in { + # snow.flake + flake = flakeInputs: root: let + snowflake = lib.evalModules { + class = "snowflake"; + # XXX: TODO: abort if inputs contains reserved names + specialArgs = + (flakeInputs + // { + inherit (this) snow; + inherit systems root; + inputs = flakeInputs; + }) + # XXX: TODO: + # |> (x: builtins.removeAttrs x ["self" "nodes"]); + |> (x: builtins.removeAttrs x ["self"]); + + modules = [ + ./module.nix + ({config, ...}: { + _module.args = { + self = config; + # XXX: TODO: + # nodes = config.nodes.nodes; + }; + }) + ]; + }; + in + snowflake.config.outputs; +} diff --git a/nix/snow/flake/lib.nix.bak b/nix/snow/flake/lib.nix.bak new file mode 100644 index 0000000..c8ea2ba --- /dev/null +++ b/nix/snow/flake/lib.nix.bak @@ -0,0 +1,318 @@ +{ lib + # Optionally a string with extra version info to be included in the error message + # in case is lib is out of date. Empty or starts with space. +, revInfo ? "" +}: +let + inherit (lib) + mkOption + mkOptionType + defaultFunctor + isAttrs + isFunction + showOption + throwIf + types + warnIf + getAttrFromPath + setAttrByPath + attrByPath + optionalAttrs + ; + inherit (lib.modules) + mkAliasAndWrapDefsWithPriority; + inherit (lib.types) + path + submoduleWith + ; + + # Polyfill isFlake until Nix with https://github.com/NixOS/nix/pull/7207 is common + isFlake = maybeFlake: + if maybeFlake ? _type + then maybeFlake._type == "flake" + else maybeFlake ? inputs && maybeFlake ? outputs && maybeFlake ? sourceInfo; + + /** + Deprecated for any use except type-merging into `perSystem`. + Use `lib.types.deferredModuleWith` instead, and add `apply = m: [ m ];` if needed. + + The deferredModule type was pioneered in flake-parts for the `perSystem` option. + The Nixpkgs version has an improved merge function that returns a single module, + whereas this version returns a list. The flake-parts version was not updated to + match this improvement in Nixpkgs. + + # History + + This predates `lib.types.deferredModuleWith`, added in Nixpkgs 22.11 + (https://github.com/NixOS/nixpkgs/pull/163617). + Documented as deprecated in flake-parts in January 2026. + */ + deferredModuleWith = + attrs@{ staticModules ? [ ] }: mkOptionType { + name = "deferredModule"; + description = "module"; + check = x: isAttrs x || isFunction x || path.check x; + merge = loc: defs: staticModules ++ map (def: lib.setDefaultModuleLocation "${def.file}, via option ${showOption loc}" def.value) defs; + inherit (submoduleWith { modules = staticModules; }) + getSubOptions + getSubModules; + substSubModules = m: deferredModuleWith (attrs // { + staticModules = m; + }); + functor = defaultFunctor "deferredModuleWith" // { + type = deferredModuleWith; + payload = { + inherit staticModules; + }; + binOp = lhs: rhs: { + staticModules = lhs.staticModules ++ rhs.staticModules; + }; + }; + }; + + # Internal: preserves legacy list-merge behavior for perSystem type-merging. + mkLegacyDeferredModuleType = + module: + deferredModuleWith { + staticModules = [ module ]; + }; + + errorExample = '' + For example: + + outputs = inputs@{ flake-parts, ... }: + flake-parts.lib.mkFlake { inherit inputs; } { /* module */ }; + + To avoid an infinite recursion, *DO NOT* pass `self.inputs` and + *DO NOT* pass `inherit (self) inputs`, but pass the output function + arguments as `inputs` like above. + ''; + + flake-parts-lib = rec { + evalFlakeModule = + args@ + { inputs ? self.inputs + , specialArgs ? { } + + # legacy + , self ? inputs.self or (throw '' + When invoking flake-parts, you must pass all the flake output arguments, + and not just `self.inputs`. + + ${errorExample} + '') + , moduleLocation ? "${self.outPath}/flake.nix" + }: + let + inputsPos = builtins.unsafeGetAttrPos "inputs" args; + errorLocation = + # Best case: user makes it explicit + args.moduleLocation or ( + # Slightly worse: Nix does not technically commit to unsafeGetAttrPos semantics + if inputsPos != null + then inputsPos.file + # Slightly worse: self may not be valid when an error occurs + else if args?inputs.self.outPath + then args.inputs.self.outPath + "/flake.nix" + # Fallback + else "" + ); + in + throwIf + (!args?self && !args?inputs) '' + When invoking flake-parts, you must pass in the flake output arguments. + + ${errorExample} + '' + warnIf + (!args?inputs) '' + When invoking flake-parts, it is recommended to pass all the flake output + arguments in the `inputs` parameter. If you only pass `self`, it's not + possible to use the `inputs` module argument in the module `imports`. + + Please pass the output function arguments. ${errorExample} + '' + + (module: + lib.evalModules { + specialArgs = { + inherit self flake-parts-lib moduleLocation; + inputs = args.inputs or /* legacy, warned above */ self.inputs; + } // specialArgs; + modules = [ ./all-modules.nix (lib.setDefaultModuleLocation errorLocation module) ]; + class = "flake"; + } + ); + + # Function to extract the default flakeModule from + # what may be a flake, returning the argument unmodified + # if it's not a flake. + # + # Useful to map over an 'imports' list to make it less + # verbose in the common case. + defaultModule = maybeFlake: + if isFlake maybeFlake + then maybeFlake.flakeModules.default or maybeFlake + else maybeFlake; + + mkFlake = args: module: + let + eval = flake-parts-lib.evalFlakeModule args module; + in + eval.config.flake; + + /** + Deprecated. Declare options directly, e.g. `options.foo.bar = mkOption { ... }`, + provided that `foo` is already declared as a submodule option. + + In flake-parts, `flake` is declared as a submodule option by the core modules, + so `options.flake.` declarations work directly. + + This function wraps option declarations in a submodule, allowing them to + be merged into an existing submodule option. For example, if `foo` is + already declared as a submodule option, using + `options.foo = mkSubmoduleOptions { bar = mkOption {...}; }` would add + `bar` to the `foo` submodule. + + # History + + This was a workaround for https://github.com/NixOS/nixpkgs/issues/146882, + fixed in Nixpkgs 22.05 by https://github.com/NixOS/nixpkgs/pull/156533. + With the fix, declaring `options.foo.bar` directly works when `foo` is + already a submodule option. Documented as deprecated in flake-parts in January 2026. + */ + mkSubmoduleOptions = + options: + mkOption { + type = types.submoduleWith { + modules = [{ inherit options; }]; + }; + }; + + /** + Deprecated. Use mkPerSystemType/mkPerSystemOption for `perSystem` type-merging, or + use Nixpkgs `types.deferredModule` directly, noting the lack of list wrapping; + see `deferredModuleWith` docs. + */ + mkDeferredModuleType = mkLegacyDeferredModuleType; + + /** + Given a module, construct an option type suitable for type-merging into `perSystem`'s type. + */ + mkPerSystemType = mkLegacyDeferredModuleType; + + /** + Deprecated. Use mkPerSystemOption for `perSystem` type-merging, or + use `mkOption` and Nixpkgs `types.deferredModule` directly, noting the + lack of list wrapping; see `deferredModuleWith` docs. + */ + mkDeferredModuleOption = + module: + mkOption { + type = flake-parts-lib.mkPerSystemType module; + }; + + /** + Given a module, construct an option declaration suitable for merging into the core `perSystem` module. + */ + mkPerSystemOption = mkDeferredModuleOption; + + # Polyfill https://github.com/NixOS/nixpkgs/pull/344216 + # Nixpkgs master 2024-12-09, Nixpkgs 25.05 + attrsWith = types.attrsWith or ({ elemType, lazy ? false, placeholder ? "name" }: + if lazy then types.attrsOf elemType else types.lazyAttrsOf elemType); + + # Helper function for defining a per-system option that + # gets transposed by the usual flake system logic to a + # top-level flake attribute. + mkTransposedPerSystemModule = { name, option, file }: { + _file = file; + + options = { + flake.${name} = mkOption { + type = attrsWith { + elemType = option.type; + lazy = true; + placeholder = "system"; + }; + default = { }; + description = '' + See {option}`perSystem.${name}` for description and examples. + ''; + }; + + perSystem = flake-parts-lib.mkPerSystemOption { + _file = file; + + options.${name} = option; + }; + }; + + config = { + transposition.${name} = { }; + }; + }; + + # Needed pending https://github.com/NixOS/nixpkgs/pull/198450 + mkAliasOptionModule = from: to: { config, options, ... }: + let + fromOpt = getAttrFromPath from options; + toOf = attrByPath to + (abort "Renaming error: option `${showOption to}' does not exist."); + toType = let opt = attrByPath to { } options; in opt.type or (types.submodule { }); + in + { + options = setAttrByPath from (mkOption + { + visible = true; + description = "Alias of {option}`${showOption to}`."; + apply = x: (toOf config); + } // optionalAttrs (toType != null) { + type = toType; + }); + config = mkAliasAndWrapDefsWithPriority (setAttrByPath to) fromOpt; + }; + + # Helper function for importing while preserving module location. To be added + # in nixpkgs: https://github.com/NixOS/nixpkgs/pull/230588 + # I expect these functions to remain identical. This one will stick around + # for a while to support older nixpkgs-lib. + importApply = + modulePath: staticArgs: + lib.setDefaultModuleLocation modulePath (import modulePath staticArgs); + + inherit (import ./lib/memoize/memoize.nix { + inherit lib; + }) memoizeStr; + + /** + `importAndPublish name module` returns a module that both imports the `module`, and exposes it as flake attribute `modules.flake.${name}`. + + This also imports the optional [`modules`](https://flake.parts/options/flake-parts-modules.html) module to support that. + */ + importAndPublish = name: module: { lib, ... }: { + _class = "flake"; + imports = [ + module + ./extras/modules.nix + ]; + flake.modules.flake.${name} = module; + }; + }; + + # A best effort, lenient estimate. Please use a recent nixpkgs lib if you + # override it at all. + minVersion = "23.05pre-git"; + +in + +if builtins.compareVersions lib.version minVersion < 0 +then + abort '' + The nixpkgs-lib dependency of flake-parts was overridden but is too old. + The minimum supported version of nixpkgs-lib is ${minVersion}, + but the actual version is ${lib.version}${revInfo}. + '' +else + + flake-parts-lib diff --git a/nix/snow/module.nix b/nix/snow/flake/module.nix similarity index 100% rename from nix/snow/module.nix rename to nix/snow/flake/module.nix diff --git a/nix/snow/flake/modules/apps.nix b/nix/snow/flake/modules/apps.nix new file mode 100644 index 0000000..3030d32 --- /dev/null +++ b/nix/snow/flake/modules/apps.nix @@ -0,0 +1,61 @@ +{ lib, flake-parts-lib, ... }: +let + inherit (lib) + mkOption + types + ; + inherit (flake-parts-lib) + mkTransposedPerSystemModule + ; + + programType = lib.types.coercedTo derivationType lib.getExe lib.types.str; + + derivationType = lib.types.package // { + check = lib.isDerivation; + }; + + appType = lib.types.submodule { + options = { + type = mkOption { + type = lib.types.enum [ "app" ]; + default = "app"; + description = '' + A type tag for `apps` consumers. + ''; + }; + program = mkOption { + type = programType; + description = '' + A path to an executable or a derivation with `meta.mainProgram`. + ''; + }; + meta = mkOption { + type = types.lazyAttrsOf lib.types.raw; + default = { }; + # TODO refer to Nix manual 2.25 + description = '' + Metadata information about the app. + Standardized in Nix at . + + Note: `nix flake check` is only aware of the `description` attribute in `meta`. + ''; + }; + }; + }; +in +mkTransposedPerSystemModule { + name = "apps"; + option = mkOption { + type = types.lazyAttrsOf appType; + default = { }; + description = '' + Programs runnable with nix run ``. + ''; + example = lib.literalExpression '' + { + default.program = "''${config.packages.hello}/bin/hello"; + } + ''; + }; + file = ./apps.nix; +} diff --git a/nix/snow/flake/modules/checks.nix b/nix/snow/flake/modules/checks.nix new file mode 100644 index 0000000..9e7ceae --- /dev/null +++ b/nix/snow/flake/modules/checks.nix @@ -0,0 +1,21 @@ +{ lib, flake-parts-lib, ... }: +let + inherit (lib) + mkOption + types + ; + inherit (flake-parts-lib) + mkTransposedPerSystemModule + ; +in +mkTransposedPerSystemModule { + name = "checks"; + option = mkOption { + type = types.lazyAttrsOf types.package; + default = { }; + description = '' + Derivations to be built by [`nix flake check`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-flake-check.html). + ''; + }; + file = ./checks.nix; +} diff --git a/nix/snow/flake/modules/debug.nix b/nix/snow/flake/modules/debug.nix new file mode 100644 index 0000000..995f13b --- /dev/null +++ b/nix/snow/flake/modules/debug.nix @@ -0,0 +1,78 @@ +{ config, flake-parts-lib, lib, options, getSystem, extendModules, ... }: +let + inherit (lib) + mapAttrs + mkIf + mkOption + optionalAttrs + types + ; + inherit (flake-parts-lib) + mkPerSystemOption + ; + + mkDebugConfig = { config, options, extendModules }: config // { + inherit config; + inherit (config) _module; + inherit options; + inherit extendModules; + }; +in +{ + options = { + debug = mkOption { + type = types.bool; + default = false; + description = '' + Whether to add the attributes `debug`, `allSystems` and `currentSystem` + to the flake output. When `true`, this allows inspection of options via + `nix repl`. + + ``` + $ nix repl + nix-repl> :lf . + nix-repl> currentSystem._module.args.pkgs.hello + «derivation /nix/store/7vf0d0j7majv1ch1xymdylyql80cn5fp-hello-2.12.1.drv» + ``` + + Each of `debug`, `allSystems.` and `currentSystem` is an + attribute set consisting of the `config` attributes, plus the extra + attributes `_module`, `config`, `options`, `extendModules`. So note that + these are not part of the `config` parameter, but are merged in for + debugging convenience. + + - `debug`: The top-level options + - `allSystems`: The `perSystem` submodule applied to the configured `systems`. + - `currentSystem`: Shortcut into `allSystems`. Only available in impure mode. + Works for arbitrary system values. + + See [Expore and debug option values](../debug.html) for more examples. + ''; + }; + perSystem = mkPerSystemOption + ({ options, config, extendModules, ... }: { + _file = ./formatter.nix; + options = { + debug = mkOption { + description = '' + Values to return in e.g. `allSystems.` when + [`debug = true`](#opt-debug). + ''; + type = types.lazyAttrsOf types.raw; + }; + }; + config = { + debug = mkDebugConfig { inherit config options extendModules; }; + }; + }); + }; + + config = mkIf config.debug { + flake = { + debug = mkDebugConfig { inherit config options extendModules; }; + allSystems = mapAttrs (_s: c: c.debug) config.allSystems; + } // optionalAttrs (builtins?currentSystem) { + currentSystem = (getSystem builtins.currentSystem).debug; + }; + }; +} diff --git a/nix/snow/flake/modules/devShells.nix b/nix/snow/flake/modules/devShells.nix new file mode 100644 index 0000000..c0cc6c5 --- /dev/null +++ b/nix/snow/flake/modules/devShells.nix @@ -0,0 +1,30 @@ +{ lib, flake-parts-lib, ... }: +let + inherit (lib) + mkOption + types + literalExpression + ; + inherit (flake-parts-lib) + mkTransposedPerSystemModule + ; +in +mkTransposedPerSystemModule { + name = "devShells"; + option = mkOption { + type = types.lazyAttrsOf types.package; + default = { }; + description = '' + An attribute set of packages to be used as shells. + [`nix develop .#`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-develop.html) will run `devShells.`. + ''; + example = literalExpression '' + { + default = pkgs.mkShell { + nativeBuildInputs = with pkgs; [ wget bat cargo ]; + }; + } + ''; + }; + file = ./devShells.nix; +} diff --git a/nix/snow/flake/modules/flake.nix b/nix/snow/flake/modules/flake.nix new file mode 100644 index 0000000..871f04d --- /dev/null +++ b/nix/snow/flake/modules/flake.nix @@ -0,0 +1,47 @@ +{ + lib, + config, + ... +}: let + inherit + (lib) + mkOption + types + ; + + flake = mkOption { + type = types.submoduleWith { + modules = [ + { + freeformType = + types.lazyAttrsOf + (types.unique + { + message = '' + No option has been declared for this flake output attribute, so its definitions can't be merged automatically. + Possible solutions: + - Load a module that defines this flake output attribute + Many modules are listed at https://flake.parts + - Declare an option for this flake output attribute + - Make sure the output attribute is spelled correctly + - Define the value only once, with a single definition in a single module + ''; + } + types.raw); + } + ]; + }; + description = '' + Raw flake output attributes. Any attribute can be set here, but some + attributes are represented by options, to provide appropriate + configuration merging. + ''; + }; +in { + options = { + inherit flake; + output = {inherit flake;}; + }; + + config = {inherit (config) flake;}; +} diff --git a/nix/snow/flake/modules/formatter.nix b/nix/snow/flake/modules/formatter.nix new file mode 100644 index 0000000..e2959ed --- /dev/null +++ b/nix/snow/flake/modules/formatter.nix @@ -0,0 +1,52 @@ +{ config, lib, flake-parts-lib, ... }: +let + inherit (lib) + filterAttrs + mapAttrs + mkOption + optionalAttrs + types + ; + inherit (flake-parts-lib) + mkPerSystemOption + ; +in +{ + options = { + flake.formatter = mkOption { + type = types.lazyAttrsOf types.package; + default = { }; + description = '' + An attribute set of per system a package used by [`nix fmt`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-fmt.html). + ''; + }; + + perSystem = mkPerSystemOption { + _file = ./formatter.nix; + options = { + formatter = mkOption { + type = types.nullOr types.package; + default = null; + description = '' + A package used by [`nix fmt`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-fmt.html). + ''; + }; + }; + }; + }; + config = { + flake.formatter = + mapAttrs + (k: v: v.formatter) + (filterAttrs + (k: v: v.formatter != null) + config.allSystems + ); + + perInput = system: flake: + optionalAttrs (flake?formatter.${system}) { + formatter = flake.formatter.${system}; + }; + + }; +} diff --git a/nix/snow/flake/modules/legacyPackages.nix b/nix/snow/flake/modules/legacyPackages.nix new file mode 100644 index 0000000..fb17e14 --- /dev/null +++ b/nix/snow/flake/modules/legacyPackages.nix @@ -0,0 +1,21 @@ +{ lib, flake-parts-lib, ... }: +let + inherit (lib) + mkOption + types + ; + inherit (flake-parts-lib) + mkTransposedPerSystemModule + ; +in +mkTransposedPerSystemModule { + name = "legacyPackages"; + option = mkOption { + type = types.lazyAttrsOf types.raw; + default = { }; + description = '' + An attribute set of unmergeable values. This is also used by [`nix build .#`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-build.html). + ''; + }; + file = ./legacyPackages.nix; +} diff --git a/nix/snow/flake/modules/moduleWithSystem.nix b/nix/snow/flake/modules/moduleWithSystem.nix new file mode 100644 index 0000000..e5c7008 --- /dev/null +++ b/nix/snow/flake/modules/moduleWithSystem.nix @@ -0,0 +1,32 @@ +{ withSystem, ... }: +{ + config = { + _module.args = { + moduleWithSystem = + module: + + { config, ... }: + let + system = + config._module.args.system or + config._module.args.pkgs.stdenv.hostPlatform.system or + (throw "moduleWithSystem: Could not determine the configuration's system parameter for this module system application."); + + allArgs = withSystem system (args: args); + + lazyArgsPerParameter = f: builtins.mapAttrs + (k: v: allArgs.${k} or (throw "moduleWithSystem: module argument `${k}` does not exist.")) + (builtins.functionArgs f); + + # Use reflection to make the call lazy in the argument. + # Restricts args to the ones declared. + callLazily = f: a: f (lazyArgsPerParameter f); + in + { + imports = [ + (callLazily module allArgs) + ]; + }; + }; + }; +} diff --git a/nix/snow/flake/modules/nixosConfigurations.nix b/nix/snow/flake/modules/nixosConfigurations.nix new file mode 100644 index 0000000..597132d --- /dev/null +++ b/nix/snow/flake/modules/nixosConfigurations.nix @@ -0,0 +1,36 @@ +{ lib, ... }: +let + inherit (lib) + mkOption + types + literalExpression + ; +in +{ + options = { + flake.nixosConfigurations = mkOption { + type = types.lazyAttrsOf types.raw; + default = { }; + description = '' + Instantiated NixOS configurations. Used by `nixos-rebuild`. + + `nixosConfigurations` is for specific machines. If you want to expose + reusable configurations, add them to [`nixosModules`](#opt-flake.nixosModules) + in the form of modules (no `lib.nixosSystem`), so that you can reference + them in this or another flake's `nixosConfigurations`. + ''; + example = literalExpression '' + { + my-machine = inputs.nixpkgs.lib.nixosSystem { + # system is not needed with freshly generated hardware-configuration.nix + # system = "x86_64-linux"; # or set nixpkgs.hostPlatform in a module. + modules = [ + ./my-machine/nixos-configuration.nix + config.nixosModules.my-module + ]; + }; + } + ''; + }; + }; +} diff --git a/nix/snow/flake/modules/nixosModules.nix b/nix/snow/flake/modules/nixosModules.nix new file mode 100644 index 0000000..86ee9cc --- /dev/null +++ b/nix/snow/flake/modules/nixosModules.nix @@ -0,0 +1,26 @@ +{ self, lib, moduleLocation, ... }: +let + inherit (lib) + mapAttrs + mkOption + types + ; +in +{ + options = { + flake.nixosModules = mkOption { + type = types.lazyAttrsOf types.deferredModule; + default = { }; + apply = mapAttrs (k: v: { + _class = "nixos"; + _file = "${toString moduleLocation}#nixosModules.${k}"; + imports = [ v ]; + }); + description = '' + NixOS modules. + + You may use this for reusable pieces of configuration, service modules, etc. + ''; + }; + }; +} diff --git a/nix/snow/flake/modules/nixpkgs.nix b/nix/snow/flake/modules/nixpkgs.nix new file mode 100644 index 0000000..44df915 --- /dev/null +++ b/nix/snow/flake/modules/nixpkgs.nix @@ -0,0 +1,26 @@ +# +# Nixpkgs module. The only exception to the rule. +# +# Provides a `pkgs` argument in `perSystem`. +# +# Arguably, this shouldn't be in flake-parts, but in nixpkgs. +# Nixpkgs could define its own module that does this, which would be +# a more consistent UX, but for now this will do. +# +# The existence of this module does not mean that other flakes' logic +# will be accepted into flake-parts, because it's against the +# spirit of Flakes. +# +{ + config = { + perSystem = { inputs', lib, ... }: { + config = { + _module.args.pkgs = lib.mkOptionDefault ( + builtins.seq + (inputs'.nixpkgs or (throw "flake-parts: The flake does not have a `nixpkgs` input. Please add it, or set `perSystem._module.args.pkgs` yourself.")) + inputs'.nixpkgs.legacyPackages + ); + }; + }; + }; +} diff --git a/nix/snow/flake/modules/overlays.nix b/nix/snow/flake/modules/overlays.nix new file mode 100644 index 0000000..172336c --- /dev/null +++ b/nix/snow/flake/modules/overlays.nix @@ -0,0 +1,32 @@ +{ lib, ... }: +let + inherit (lib) + mkOption + types + ; +in +{ + options = { + flake.overlays = mkOption { + # uniq -> ordered: https://github.com/NixOS/nixpkgs/issues/147052 + # also update description when done + type = types.lazyAttrsOf (types.uniq (types.functionTo (types.functionTo (types.lazyAttrsOf types.unspecified)))); + # This eta expansion exists for the sole purpose of making nix flake check happy. + apply = lib.mapAttrs (_k: f: final: prev: f final prev); + default = { }; + example = lib.literalExpression '' + { + default = final: prev: {}; + } + ''; + description = '' + An attribute set of [overlays](https://nixos.org/manual/nixpkgs/stable/#chap-overlays). + + Note that the overlays themselves are not mergeable. While overlays + can be composed, the order of composition is significant, but the + module system does not guarantee sufficiently deterministic + definition ordering, across versions and when changing `imports`. + ''; + }; + }; +} diff --git a/nix/snow/flake/modules/packages.nix b/nix/snow/flake/modules/packages.nix new file mode 100644 index 0000000..20f0071 --- /dev/null +++ b/nix/snow/flake/modules/packages.nix @@ -0,0 +1,23 @@ +{ lib, flake-parts-lib, ... }: +let + inherit (lib) + mkOption + types + ; + inherit (flake-parts-lib) + mkTransposedPerSystemModule + ; +in +mkTransposedPerSystemModule { + name = "packages"; + option = mkOption { + type = types.lazyAttrsOf types.package; + default = { }; + description = '' + An attribute set of packages to be built by [`nix build`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-build.html). + + `nix build .#` will build `packages.`. + ''; + }; + file = ./packages.nix; +} diff --git a/nix/snow/flake/modules/perSystem.nix b/nix/snow/flake/modules/perSystem.nix new file mode 100644 index 0000000..d4890ef --- /dev/null +++ b/nix/snow/flake/modules/perSystem.nix @@ -0,0 +1,159 @@ +{ config, lib, flake-parts-lib, self, ... }: +let + inherit (lib) + genAttrs + mapAttrs + mkOption + types + ; + inherit (lib.strings) + escapeNixIdentifier + ; + inherit (flake-parts-lib) + mkPerSystemType + ; + + rootConfig = config; + + # Stubs for self and inputs. While it'd be possible to define aliases + # inside perSystem, that is not a general solution, and it would make + # top.config harder to discover, stretching the learning curve rather + # than flattening it. + + throwAliasError' = param: + throw '' + `${param}` (without `'`) is not a `perSystem` module argument, but a + module argument of the top level config. + + The following is an example usage of `${param}`. Note that its binding + is in the `top` parameter list, which is declared by the top level module + rather than the `perSystem` module. + + top@{ config, lib, ${param}, ... }: { + perSystem = { config, ${param}', ... }: { + # in scope here: + # - ${param} + # - ${param}' + # - config (of perSystem) + # - top.config (note the `top@` pattern) + }; + } + ''; + + throwAliasError = param: + throw '' + `${param}` is not a `perSystem` module argument, but a module argument of + the top level config. + + The following is an example usage of `${param}`. Note that its binding + is in the `top` parameter list, which is declared by the top level module + rather than the `perSystem` module. + + top@{ config, lib, ${param}, ... }: { + perSystem = { config, ... }: { + # in scope here: + # - ${param} + # - config (of perSystem) + # - top.config (note the `top@` pattern) + }; + } + ''; + + /** + We primarily use `systems` to help memoize the per system context, but that + doesn't extend to arbitrary `system`s. + For that, we use the slightly less efficient, but perfectly acceptable + `memoizeStr` function. + */ + otherMemoizedSystems = flake-parts-lib.memoizeStr config.perSystem; + +in +{ + options = { + systems = mkOption { + description = '' + All the system types to enumerate in the flake output subattributes. + + In other words, all valid values for `system` in e.g. `packages..foo`. + ''; + type = types.listOf types.str; + }; + + perInput = mkOption { + description = '' + A function that pre-processes flake inputs. + + It is called for users of `perSystem` such that `inputs'.''${name} = config.perInput system inputs.''${name}`. + + This is used for [`inputs'`](../module-arguments.html#inputs) and [`self'`](../module-arguments.html#self). + + The attributes returned by the `perInput` function definitions are merged into a single namespace (per input), + so each module should return an attribute set with usually only one or two predictable attribute names. Otherwise, + the `inputs'` namespace gets polluted. + ''; + type = types.functionTo (types.functionTo (types.lazyAttrsOf types.unspecified)); + }; + + perSystem = mkOption { + description = '' + A function from system to flake-like attributes omitting the `` attribute. + + Modules defined here have access to the suboptions and [some convenient module arguments](../module-arguments.html). + ''; + type = mkPerSystemType ({ config, system, ... }: { + _file = ./perSystem.nix; + config = { + _module.args.inputs' = + mapAttrs + (inputName: input: + builtins.addErrorContext "while retrieving system-dependent attributes for input ${escapeNixIdentifier inputName}" ( + if input._type or null == "flake" + then rootConfig.perInput system input + else + throw "Trying to retrieve system-dependent attributes for input ${escapeNixIdentifier inputName}, but this input is not a flake. Perhaps flake = false was added to the input declarations by mistake, or you meant to use a different input, or you meant to use plain old inputs, not inputs'." + ) + ) + self.inputs; + _module.args.self' = + builtins.addErrorContext "while retrieving system-dependent attributes for a flake's own outputs" ( + rootConfig.perInput system self + ); + + # Custom error messages + _module.args.self = throwAliasError' "self"; + _module.args.inputs = throwAliasError' "inputs"; + _module.args.getSystem = throwAliasError "getSystem"; + _module.args.withSystem = throwAliasError "withSystem"; + _module.args.moduleWithSystem = throwAliasError "moduleWithSystem"; + }; + }); + apply = modules: system: + (lib.evalModules { + inherit modules; + prefix = [ "perSystem" system ]; + specialArgs = { + inherit system; + }; + class = "perSystem"; + }).config; + }; + + allSystems = mkOption { + type = types.lazyAttrsOf types.unspecified; + description = "The system-specific config for each of systems."; + internal = true; + }; + }; + + config = { + allSystems = genAttrs config.systems config.perSystem; + _module.args.getSystem = system: config.allSystems.${system} or (otherMemoizedSystems system); + + # The warning is there for a reason. Only use this in situations where the + # performance cost has already been incurred, such as in `flakeModules.easyOverlay`, + # where we run in the context of an overlay, and the performance cost of the + # extra `pkgs` makes the cost of running `perSystem` probably negligible. + _module.args.getSystemIgnoreWarning = system: config.allSystems.${system} or (config.perSystem system); + }; + +} diff --git a/nix/snow/flake/modules/transposition.nix b/nix/snow/flake/modules/transposition.nix new file mode 100644 index 0000000..d532e76 --- /dev/null +++ b/nix/snow/flake/modules/transposition.nix @@ -0,0 +1,132 @@ +{ config, lib, flake-parts-lib, ... }: + +let + inherit (lib) + filterAttrs + mapAttrs + mkOption + types + ; + inherit (lib.strings) + escapeNixIdentifier + ; + + transpositionModule = { + options = { + adHoc = mkOption { + type = types.bool; + default = false; + description = '' + Whether to provide a stub option declaration for {option}`perSystem.`. + + The stub option declaration does not support merging and lacks + documentation, so you are recommended to declare the {option}`perSystem.` + option yourself and avoid {option}`adHoc`. + ''; + }; + }; + }; + + perInputAttributeError = { flake, attrName, system, attrConfig }: + # This uses flake.outPath for lack of a better identifier. + # Consider adding a perInput variation that has a normally-redundant argument for the input name. + # Tested manually with + # perSystem = { inputs', ... }: { + # packages.extra = inputs'.nixpkgs.extra; + # packages.default = inputs'.nixpkgs.packages.default; + # packages.veryWrong = (top.config.perInput "x86_64-linux" inputs'.nixpkgs.legacyPackages.hello).packages.default; + # }; + # transposition.extra = {}; + let + attrPath = "${escapeNixIdentifier attrName}.${escapeNixIdentifier system}"; + flakeIdentifier = + if flake._type or null != "flake" + then + throw "An attempt was made to access attribute ${attrPath} on a value that's supposed to be a flake, but may not be a proper flake." + else + builtins.addErrorContext "while trying to find out how to describe what is supposedly a flake, whose attribute ${attrPath} was accessed but does not exist" ( + toString flake.outPath + ); + # This ought to be generalized by extending attrConfig, but this is the only known and common mistake for now. + alternateAttrNameHint = + if attrName == "packages" && flake?legacyPackages + then # Unfortunately we can't just switch them out, because that will put packages *sets* where single packages are expected in user code, resulting in potentially much worse and more confusing errors down the line. + "\nIt does define legacyPackages; try that instead?" + else ""; + in + if flake?${attrName} + then + throw '' + Attempt to access ${attrPath} of flake ${flakeIdentifier}, but it does not have it. + It does have attribute ${escapeNixIdentifier attrName}, so it appears that it does not support system type ${escapeNixIdentifier system}. + '' + else + throw '' + Attempt to access ${attrPath} of flake ${flakeIdentifier}, but it does not have attribute ${escapeNixIdentifier attrName}.${alternateAttrNameHint} + ''; + + +in +{ + options = { + transposition = lib.mkOption { + description = '' + A helper that defines transposed attributes in the flake outputs. + + When you define `transposition.foo = { };`, definitions are added to the effect of (pseudo-code): + + ```nix + flake.foo.''${system} = (perSystem system).foo; + perInput = system: inputFlake: inputFlake.foo.''${system}; + ``` + + Transposition is the operation that swaps the indices of a data structure. + Here it refers specifically to the transposition between + + ```plain + perSystem: .''${system}.''${attribute} + outputs: .''${attribute}.''${system} + ``` + + It also defines the reverse operation in [{option}`perInput`](#opt-perInput). + ''; + type = + types.lazyAttrsOf + (types.submoduleWith { modules = [ transpositionModule ]; }); + }; + }; + + config = { + flake = + lib.mapAttrs + (attrName: attrConfig: + mapAttrs + (system: v: v.${attrName} or ( + abort '' + Could not find option ${attrName} in the perSystem module. It is required to declare such an option whenever transposition. is defined (and in this instance is ${attrName}). + '')) + config.allSystems + ) + config.transposition; + + perInput = + system: flake: + mapAttrs + (attrName: attrConfig: + flake.${attrName}.${system} or ( + throw (perInputAttributeError { inherit system flake attrName attrConfig; }) + ) + ) + config.transposition; + + perSystem = { + options = + mapAttrs + (k: v: lib.mkOption { }) + (filterAttrs + (k: v: v.adHoc) + config.transposition + ); + }; + }; +} diff --git a/nix/snow/flake/modules/withSystem.nix b/nix/snow/flake/modules/withSystem.nix new file mode 100644 index 0000000..161eece --- /dev/null +++ b/nix/snow/flake/modules/withSystem.nix @@ -0,0 +1,37 @@ +{ lib, flake-parts-lib, getSystem, ... }: +let + inherit (lib) + mkOption + types + ; + inherit (flake-parts-lib) + mkPerSystemOption + ; +in +{ + options = { + perSystem = mkPerSystemOption ({ config, options, specialArgs, ... }: { + _file = ./perSystem.nix; + options = { + allModuleArgs = mkOption { + type = types.lazyAttrsOf (types.raw or types.unspecified); + internal = true; + readOnly = true; + description = "Internal option that exposes _module.args, for use by withSystem."; + }; + }; + config = { + allModuleArgs = config._module.args // specialArgs // { inherit config options; }; + }; + }); + }; + + config = { + _module.args = { + withSystem = + system: f: + f + (getSystem system).allModuleArgs; + }; + }; +} diff --git a/nix/snow/nodes/default.nix b/nix/snow/flake/nodes/default.nix similarity index 100% rename from nix/snow/nodes/default.nix rename to nix/snow/flake/nodes/default.nix diff --git a/nix/snow/nodes/shared.nix b/nix/snow/flake/nodes/shared.nix similarity index 100% rename from nix/snow/nodes/shared.nix rename to nix/snow/flake/nodes/shared.nix diff --git a/nix/snow/nodes/submodule.nix b/nix/snow/flake/nodes/submodule.nix similarity index 100% rename from nix/snow/nodes/submodule.nix rename to nix/snow/flake/nodes/submodule.nix diff --git a/nix/snow/flake/outputs/checks.nix b/nix/snow/flake/outputs/checks.nix new file mode 100644 index 0000000..21fd677 --- /dev/null +++ b/nix/snow/flake/outputs/checks.nix @@ -0,0 +1,5 @@ + checks = + inputs.deploy-rs.lib + |> mapAttrs (system: deployLib: + deployLib.deployChecks deploy); + diff --git a/nix/snow/flake/outputs/deploy.nix b/nix/snow/flake/outputs/deploy.nix new file mode 100644 index 0000000..08caa8f --- /dev/null +++ b/nix/snow/flake/outputs/deploy.nix @@ -0,0 +1,57 @@ + deploy.nodes = mapNodes nodes ({ + name, + node, + ... + }: let + inherit + (node.deploy) + ssh + user + interactiveSudo + remoteBuild + rollback + autoRollback + magicRollback + activationTimeout + confirmTimeout + ; + + nixosFor = system: inputs.deploy-rs.lib.${system}.activate.nixos; + in { + hostname = + if ssh.host != null + then ssh.host + else ""; + + profilesOrder = ["default"]; # profiles priority + profiles.default = { + path = nixosFor node.system nixosConfigurations.${name}; + + user = user; + sudo = "sudo -u"; + interactiveSudo = interactiveSudo; + + fastConnection = false; + + autoRollback = autoRollback -> rollback; + magicRollback = magicRollback -> rollback; + activationTimeout = activationTimeout; + confirmTimeout = confirmTimeout; + + remoteBuild = remoteBuild; + sshUser = ssh.user; + sshOpts = + ssh.opts + ++ ( + if elem "-p" ssh.opts + then [] + else ["-p" (toString ssh.port)] + ) + ++ ( + if elem "-A" ssh.opts + then [] + else ["-A"] + ); + }; + }); + diff --git a/nix/snow/flake/outputs/nixosConfigurations.nix b/nix/snow/flake/outputs/nixosConfigurations.nix new file mode 100644 index 0000000..799758d --- /dev/null +++ b/nix/snow/flake/outputs/nixosConfigurations.nix @@ -0,0 +1,67 @@ +# { +# _module = { ... }; +# _type = "configuration"; +# class = null; +# config = { ... }; +# extendModules = «lambda extendModules @ /nix/store/9hfp0agnm43kz72l5lpfn9var5p0x2fa-source/lib/modules.nix:340:9»; +# graph = [ ... ]; +# options = { ... }; +# type = { ... }; +# } + nixosConfigurations = mapNodes nodes ( + { + base, + lib, + name, + node, + groupModules, + ... + }: let + homeManager = + if node.homeManager != null + then node.homeManager + else if nodes.homeManager != null + then nodes.homeManager + else + warn '' + [snowflake] Neither `nodes.homeManager` nor `nodes.nodes.${name}.homeManager` were specified! + [snowflake] home-manager will NOT be used! User configuration will be ignored! + '' + null; + + userArgs = nodes.args // node.args; + ceruleanArgs = { + inherit systems root base nodes node; + inherit (node) system; + inherit (this) snow; + hostname = name; + + _cerulean = { + inherit inputs userArgs ceruleanArgs homeManager; + specialArgs = userArgs // ceruleanArgs; + }; + }; + specialArgs = assert (userArgs + |> attrNames + |> all (argName: + ! ceruleanArgs ? argName + || abort '' + `specialArgs` are like super important to Cerulean my love... Date: Sat, 14 Mar 2026 21:01:02 +1000 Subject: [PATCH 2/8] warn if reserved inputs provided --- nix/snow/flake/default.nix | 54 ++++++++++++++++++++++++++++++-------- 1 file changed, 43 insertions(+), 11 deletions(-) diff --git a/nix/snow/flake/default.nix b/nix/snow/flake/default.nix index fad3c6d..b90126b 100644 --- a/nix/snow/flake/default.nix +++ b/nix/snow/flake/default.nix @@ -4,23 +4,55 @@ systems, ... }: let + inherit + (builtins) + attrNames + concatStringsSep + filter + length + removeAttrs + warn + ; + inherit (inputs.nixpkgs) lib; in { # snow.flake flake = flakeInputs: root: let snowflake = lib.evalModules { class = "snowflake"; - # XXX: TODO: abort if inputs contains reserved names - specialArgs = - (flakeInputs - // { - inherit (this) snow; - inherit systems root; - inputs = flakeInputs; - }) - # XXX: TODO: - # |> (x: builtins.removeAttrs x ["self" "nodes"]); - |> (x: builtins.removeAttrs x ["self"]); + specialArgs = let + reservedInputs = { + inherit (this) snow; + inherit systems root; + inputs = flakeInputs; + }; + + warnIfReserved = let + getReservedNames = names: + reservedInputs + |> attrNames + |> filter (name: names?${name}); + + reservedNames = + flakeInputs + |> attrNames + |> getReservedNames; + in + (length reservedNames == 0) + || warn '' + [snow] Your `flake.nix` declares inputs using reserved names! + [snow] These will be accessible only via `inputs.''${NAME}` + [snow] Please rename the following: + [snow] ${concatStringsSep reservedNames ", "} + '' + true; + in + assert warnIfReserved; + flakeInputs + // reservedInputs + # XXX: TODO: + # |> (x: builtins.removeAttrs x ["self" "nodes"]); + |> (x: removeAttrs x ["self"]); modules = [ ./module.nix From d891a92357a3c49a751c526e6a390559415c697e Mon Sep 17 00:00:00 2001 From: _cry64 Date: Sat, 14 Mar 2026 22:18:28 +1000 Subject: [PATCH 3/8] redesign module hierarchy --- nix/snow/flake/default.nix | 20 +- nix/snow/flake/lib.nix | 49 +++ nix/snow/flake/lib.nix.bak | 318 ------------------ nix/snow/flake/module.nix | 1 + nix/snow/flake/modules/README.md | 3 + nix/snow/flake/modules/apps.nix | 62 ++-- nix/snow/flake/modules/checks.nix | 37 +- nix/snow/flake/modules/debug.nix | 78 ----- nix/snow/flake/modules/default.nix | 15 + nix/snow/flake/modules/devShells.nix | 53 +-- nix/snow/flake/modules/formatter.nix | 62 +--- nix/snow/flake/modules/legacyPackages.nix | 37 +- nix/snow/flake/modules/moduleWithSystem.nix | 32 -- .../flake/modules/nixosConfigurations.nix | 13 +- nix/snow/flake/modules/nixosModules.nix | 19 +- nix/snow/flake/modules/nixpkgs.nix | 26 -- .../flake/modules/{flake.nix => outputs.nix} | 5 +- nix/snow/flake/modules/overlays.nix | 13 +- nix/snow/flake/modules/packages.nix | 40 ++- nix/snow/flake/modules/perSystem.nix | 159 --------- nix/snow/flake/modules/transposition.nix | 132 -------- nix/snow/flake/modules/withSystem.nix | 37 -- 22 files changed, 244 insertions(+), 967 deletions(-) create mode 100644 nix/snow/flake/lib.nix delete mode 100644 nix/snow/flake/lib.nix.bak create mode 100644 nix/snow/flake/modules/README.md delete mode 100644 nix/snow/flake/modules/debug.nix create mode 100644 nix/snow/flake/modules/default.nix delete mode 100644 nix/snow/flake/modules/moduleWithSystem.nix delete mode 100644 nix/snow/flake/modules/nixpkgs.nix rename nix/snow/flake/modules/{flake.nix => outputs.nix} (94%) delete mode 100644 nix/snow/flake/modules/perSystem.nix delete mode 100644 nix/snow/flake/modules/transposition.nix delete mode 100644 nix/snow/flake/modules/withSystem.nix diff --git a/nix/snow/flake/default.nix b/nix/snow/flake/default.nix index b90126b..9c5d1f5 100644 --- a/nix/snow/flake/default.nix +++ b/nix/snow/flake/default.nix @@ -10,7 +10,6 @@ concatStringsSep filter length - removeAttrs warn ; @@ -21,7 +20,7 @@ in { snowflake = lib.evalModules { class = "snowflake"; specialArgs = let - reservedInputs = { + reservedSpecialArgs = { inherit (this) snow; inherit systems root; inputs = flakeInputs; @@ -29,7 +28,7 @@ in { warnIfReserved = let getReservedNames = names: - reservedInputs + reservedSpecialArgs |> attrNames |> filter (name: names?${name}); @@ -40,7 +39,7 @@ in { in (length reservedNames == 0) || warn '' - [snow] Your `flake.nix` declares inputs using reserved names! + [snow] Your `flake.nix` declares inputs with reserved names! [snow] These will be accessible only via `inputs.''${NAME}` [snow] Please rename the following: [snow] ${concatStringsSep reservedNames ", "} @@ -48,21 +47,10 @@ in { true; in assert warnIfReserved; - flakeInputs - // reservedInputs - # XXX: TODO: - # |> (x: builtins.removeAttrs x ["self" "nodes"]); - |> (x: removeAttrs x ["self"]); + flakeInputs // reservedSpecialArgs; modules = [ ./module.nix - ({config, ...}: { - _module.args = { - self = config; - # XXX: TODO: - # nodes = config.nodes.nodes; - }; - }) ]; }; in diff --git a/nix/snow/flake/lib.nix b/nix/snow/flake/lib.nix new file mode 100644 index 0000000..43326c9 --- /dev/null +++ b/nix/snow/flake/lib.nix @@ -0,0 +1,49 @@ +{ + lib, + revInfo ? "", +}: let + inherit + (lib) + mkOption + types + ; + + # A best effort, lenient estimate. Please use a recent nixpkgs lib if you + # override it at all. + minVersion = "23.05pre-git"; + + isNixpkgsValidVersion = + (builtins.compareVersions lib.version minVersion < 0) + # XXX: TODO: make this message snow specific + || abort '' + The nixpkgs-lib dependency of flake-parts was overridden but is too old. + The minimum supported version of nixpkgs-lib is ${minVersion}, + but the actual version is ${lib.version}${revInfo}. + ''; +in + assert isNixpkgsValidVersion; { + # Helper function for defining a per-system option that + # gets transposed by the usual flake system logic to a + # top-level outputs attribute. + mkPerSystemFlakeOutput = { + name, + option, + file, + }: { + _file = file; + + options = { + outputs.${name} = mkOption { + type = types.attrsWith { + elemType = option.type; + lazy = true; + placeholder = "system"; + }; + default = {}; + description = '' + See {option}`perSystem.${name}` for description and examples. + ''; + }; + }; + }; + } diff --git a/nix/snow/flake/lib.nix.bak b/nix/snow/flake/lib.nix.bak deleted file mode 100644 index c8ea2ba..0000000 --- a/nix/snow/flake/lib.nix.bak +++ /dev/null @@ -1,318 +0,0 @@ -{ lib - # Optionally a string with extra version info to be included in the error message - # in case is lib is out of date. Empty or starts with space. -, revInfo ? "" -}: -let - inherit (lib) - mkOption - mkOptionType - defaultFunctor - isAttrs - isFunction - showOption - throwIf - types - warnIf - getAttrFromPath - setAttrByPath - attrByPath - optionalAttrs - ; - inherit (lib.modules) - mkAliasAndWrapDefsWithPriority; - inherit (lib.types) - path - submoduleWith - ; - - # Polyfill isFlake until Nix with https://github.com/NixOS/nix/pull/7207 is common - isFlake = maybeFlake: - if maybeFlake ? _type - then maybeFlake._type == "flake" - else maybeFlake ? inputs && maybeFlake ? outputs && maybeFlake ? sourceInfo; - - /** - Deprecated for any use except type-merging into `perSystem`. - Use `lib.types.deferredModuleWith` instead, and add `apply = m: [ m ];` if needed. - - The deferredModule type was pioneered in flake-parts for the `perSystem` option. - The Nixpkgs version has an improved merge function that returns a single module, - whereas this version returns a list. The flake-parts version was not updated to - match this improvement in Nixpkgs. - - # History - - This predates `lib.types.deferredModuleWith`, added in Nixpkgs 22.11 - (https://github.com/NixOS/nixpkgs/pull/163617). - Documented as deprecated in flake-parts in January 2026. - */ - deferredModuleWith = - attrs@{ staticModules ? [ ] }: mkOptionType { - name = "deferredModule"; - description = "module"; - check = x: isAttrs x || isFunction x || path.check x; - merge = loc: defs: staticModules ++ map (def: lib.setDefaultModuleLocation "${def.file}, via option ${showOption loc}" def.value) defs; - inherit (submoduleWith { modules = staticModules; }) - getSubOptions - getSubModules; - substSubModules = m: deferredModuleWith (attrs // { - staticModules = m; - }); - functor = defaultFunctor "deferredModuleWith" // { - type = deferredModuleWith; - payload = { - inherit staticModules; - }; - binOp = lhs: rhs: { - staticModules = lhs.staticModules ++ rhs.staticModules; - }; - }; - }; - - # Internal: preserves legacy list-merge behavior for perSystem type-merging. - mkLegacyDeferredModuleType = - module: - deferredModuleWith { - staticModules = [ module ]; - }; - - errorExample = '' - For example: - - outputs = inputs@{ flake-parts, ... }: - flake-parts.lib.mkFlake { inherit inputs; } { /* module */ }; - - To avoid an infinite recursion, *DO NOT* pass `self.inputs` and - *DO NOT* pass `inherit (self) inputs`, but pass the output function - arguments as `inputs` like above. - ''; - - flake-parts-lib = rec { - evalFlakeModule = - args@ - { inputs ? self.inputs - , specialArgs ? { } - - # legacy - , self ? inputs.self or (throw '' - When invoking flake-parts, you must pass all the flake output arguments, - and not just `self.inputs`. - - ${errorExample} - '') - , moduleLocation ? "${self.outPath}/flake.nix" - }: - let - inputsPos = builtins.unsafeGetAttrPos "inputs" args; - errorLocation = - # Best case: user makes it explicit - args.moduleLocation or ( - # Slightly worse: Nix does not technically commit to unsafeGetAttrPos semantics - if inputsPos != null - then inputsPos.file - # Slightly worse: self may not be valid when an error occurs - else if args?inputs.self.outPath - then args.inputs.self.outPath + "/flake.nix" - # Fallback - else "" - ); - in - throwIf - (!args?self && !args?inputs) '' - When invoking flake-parts, you must pass in the flake output arguments. - - ${errorExample} - '' - warnIf - (!args?inputs) '' - When invoking flake-parts, it is recommended to pass all the flake output - arguments in the `inputs` parameter. If you only pass `self`, it's not - possible to use the `inputs` module argument in the module `imports`. - - Please pass the output function arguments. ${errorExample} - '' - - (module: - lib.evalModules { - specialArgs = { - inherit self flake-parts-lib moduleLocation; - inputs = args.inputs or /* legacy, warned above */ self.inputs; - } // specialArgs; - modules = [ ./all-modules.nix (lib.setDefaultModuleLocation errorLocation module) ]; - class = "flake"; - } - ); - - # Function to extract the default flakeModule from - # what may be a flake, returning the argument unmodified - # if it's not a flake. - # - # Useful to map over an 'imports' list to make it less - # verbose in the common case. - defaultModule = maybeFlake: - if isFlake maybeFlake - then maybeFlake.flakeModules.default or maybeFlake - else maybeFlake; - - mkFlake = args: module: - let - eval = flake-parts-lib.evalFlakeModule args module; - in - eval.config.flake; - - /** - Deprecated. Declare options directly, e.g. `options.foo.bar = mkOption { ... }`, - provided that `foo` is already declared as a submodule option. - - In flake-parts, `flake` is declared as a submodule option by the core modules, - so `options.flake.` declarations work directly. - - This function wraps option declarations in a submodule, allowing them to - be merged into an existing submodule option. For example, if `foo` is - already declared as a submodule option, using - `options.foo = mkSubmoduleOptions { bar = mkOption {...}; }` would add - `bar` to the `foo` submodule. - - # History - - This was a workaround for https://github.com/NixOS/nixpkgs/issues/146882, - fixed in Nixpkgs 22.05 by https://github.com/NixOS/nixpkgs/pull/156533. - With the fix, declaring `options.foo.bar` directly works when `foo` is - already a submodule option. Documented as deprecated in flake-parts in January 2026. - */ - mkSubmoduleOptions = - options: - mkOption { - type = types.submoduleWith { - modules = [{ inherit options; }]; - }; - }; - - /** - Deprecated. Use mkPerSystemType/mkPerSystemOption for `perSystem` type-merging, or - use Nixpkgs `types.deferredModule` directly, noting the lack of list wrapping; - see `deferredModuleWith` docs. - */ - mkDeferredModuleType = mkLegacyDeferredModuleType; - - /** - Given a module, construct an option type suitable for type-merging into `perSystem`'s type. - */ - mkPerSystemType = mkLegacyDeferredModuleType; - - /** - Deprecated. Use mkPerSystemOption for `perSystem` type-merging, or - use `mkOption` and Nixpkgs `types.deferredModule` directly, noting the - lack of list wrapping; see `deferredModuleWith` docs. - */ - mkDeferredModuleOption = - module: - mkOption { - type = flake-parts-lib.mkPerSystemType module; - }; - - /** - Given a module, construct an option declaration suitable for merging into the core `perSystem` module. - */ - mkPerSystemOption = mkDeferredModuleOption; - - # Polyfill https://github.com/NixOS/nixpkgs/pull/344216 - # Nixpkgs master 2024-12-09, Nixpkgs 25.05 - attrsWith = types.attrsWith or ({ elemType, lazy ? false, placeholder ? "name" }: - if lazy then types.attrsOf elemType else types.lazyAttrsOf elemType); - - # Helper function for defining a per-system option that - # gets transposed by the usual flake system logic to a - # top-level flake attribute. - mkTransposedPerSystemModule = { name, option, file }: { - _file = file; - - options = { - flake.${name} = mkOption { - type = attrsWith { - elemType = option.type; - lazy = true; - placeholder = "system"; - }; - default = { }; - description = '' - See {option}`perSystem.${name}` for description and examples. - ''; - }; - - perSystem = flake-parts-lib.mkPerSystemOption { - _file = file; - - options.${name} = option; - }; - }; - - config = { - transposition.${name} = { }; - }; - }; - - # Needed pending https://github.com/NixOS/nixpkgs/pull/198450 - mkAliasOptionModule = from: to: { config, options, ... }: - let - fromOpt = getAttrFromPath from options; - toOf = attrByPath to - (abort "Renaming error: option `${showOption to}' does not exist."); - toType = let opt = attrByPath to { } options; in opt.type or (types.submodule { }); - in - { - options = setAttrByPath from (mkOption - { - visible = true; - description = "Alias of {option}`${showOption to}`."; - apply = x: (toOf config); - } // optionalAttrs (toType != null) { - type = toType; - }); - config = mkAliasAndWrapDefsWithPriority (setAttrByPath to) fromOpt; - }; - - # Helper function for importing while preserving module location. To be added - # in nixpkgs: https://github.com/NixOS/nixpkgs/pull/230588 - # I expect these functions to remain identical. This one will stick around - # for a while to support older nixpkgs-lib. - importApply = - modulePath: staticArgs: - lib.setDefaultModuleLocation modulePath (import modulePath staticArgs); - - inherit (import ./lib/memoize/memoize.nix { - inherit lib; - }) memoizeStr; - - /** - `importAndPublish name module` returns a module that both imports the `module`, and exposes it as flake attribute `modules.flake.${name}`. - - This also imports the optional [`modules`](https://flake.parts/options/flake-parts-modules.html) module to support that. - */ - importAndPublish = name: module: { lib, ... }: { - _class = "flake"; - imports = [ - module - ./extras/modules.nix - ]; - flake.modules.flake.${name} = module; - }; - }; - - # A best effort, lenient estimate. Please use a recent nixpkgs lib if you - # override it at all. - minVersion = "23.05pre-git"; - -in - -if builtins.compareVersions lib.version minVersion < 0 -then - abort '' - The nixpkgs-lib dependency of flake-parts was overridden but is too old. - The minimum supported version of nixpkgs-lib is ${minVersion}, - but the actual version is ${lib.version}${revInfo}. - '' -else - - flake-parts-lib diff --git a/nix/snow/flake/module.nix b/nix/snow/flake/module.nix index 79b8804..1aacd0b 100644 --- a/nix/snow/flake/module.nix +++ b/nix/snow/flake/module.nix @@ -18,6 +18,7 @@ }: { imports = [ ./nodes + ./modules (snow.findImport /${root}/snow) ]; } diff --git a/nix/snow/flake/modules/README.md b/nix/snow/flake/modules/README.md new file mode 100644 index 0000000..d19dbc1 --- /dev/null +++ b/nix/snow/flake/modules/README.md @@ -0,0 +1,3 @@ +# Snow Module Backend +This source code was tedious so it's just a modified version of the module backend of +[github:hercules-ci/flake-parts](https://github.com/hercules-ci/flake-parts/tree/main/modules). diff --git a/nix/snow/flake/modules/apps.nix b/nix/snow/flake/modules/apps.nix index 3030d32..75cc4be 100644 --- a/nix/snow/flake/modules/apps.nix +++ b/nix/snow/flake/modules/apps.nix @@ -1,23 +1,31 @@ -{ lib, flake-parts-lib, ... }: -let - inherit (lib) +{ + lib, + snow, + ... +}: let + inherit + (lib) mkOption types ; - inherit (flake-parts-lib) - mkTransposedPerSystemModule + + inherit + (snow) + mkPerSystemFlakeOutput ; - programType = lib.types.coercedTo derivationType lib.getExe lib.types.str; + derivationType = + lib.types.package + // { + check = lib.isDerivation; + }; - derivationType = lib.types.package // { - check = lib.isDerivation; - }; + programType = lib.types.coercedTo derivationType lib.getExe lib.types.str; appType = lib.types.submodule { options = { type = mkOption { - type = lib.types.enum [ "app" ]; + type = lib.types.enum ["app"]; default = "app"; description = '' A type tag for `apps` consumers. @@ -31,7 +39,7 @@ let }; meta = mkOption { type = types.lazyAttrsOf lib.types.raw; - default = { }; + default = {}; # TODO refer to Nix manual 2.25 description = '' Metadata information about the app. @@ -43,19 +51,19 @@ let }; }; in -mkTransposedPerSystemModule { - name = "apps"; - option = mkOption { - type = types.lazyAttrsOf appType; - default = { }; - description = '' - Programs runnable with nix run ``. - ''; - example = lib.literalExpression '' - { - default.program = "''${config.packages.hello}/bin/hello"; - } - ''; - }; - file = ./apps.nix; -} + mkPerSystemFlakeOutput { + name = "apps"; + option = mkOption { + type = types.lazyAttrsOf appType; + default = {}; + description = '' + Programs runnable with nix run ``. + ''; + example = lib.literalExpression '' + { + default.program = "''${config.packages.hello}/bin/hello"; + } + ''; + }; + file = ./apps.nix; + } diff --git a/nix/snow/flake/modules/checks.nix b/nix/snow/flake/modules/checks.nix index 9e7ceae..a8a7280 100644 --- a/nix/snow/flake/modules/checks.nix +++ b/nix/snow/flake/modules/checks.nix @@ -1,21 +1,26 @@ -{ lib, flake-parts-lib, ... }: -let - inherit (lib) +{ + lib, + snow, + ... +}: let + inherit + (lib) mkOption types ; - inherit (flake-parts-lib) - mkTransposedPerSystemModule + inherit + (snow) + mkPerSystemFlakeOutput ; in -mkTransposedPerSystemModule { - name = "checks"; - option = mkOption { - type = types.lazyAttrsOf types.package; - default = { }; - description = '' - Derivations to be built by [`nix flake check`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-flake-check.html). - ''; - }; - file = ./checks.nix; -} + mkPerSystemFlakeOutput { + name = "checks"; + option = mkOption { + type = types.lazyAttrsOf types.package; + default = {}; + description = '' + Derivations to be built by [`nix flake check`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-flake-check.html). + ''; + }; + file = ./checks.nix; + } diff --git a/nix/snow/flake/modules/debug.nix b/nix/snow/flake/modules/debug.nix deleted file mode 100644 index 995f13b..0000000 --- a/nix/snow/flake/modules/debug.nix +++ /dev/null @@ -1,78 +0,0 @@ -{ config, flake-parts-lib, lib, options, getSystem, extendModules, ... }: -let - inherit (lib) - mapAttrs - mkIf - mkOption - optionalAttrs - types - ; - inherit (flake-parts-lib) - mkPerSystemOption - ; - - mkDebugConfig = { config, options, extendModules }: config // { - inherit config; - inherit (config) _module; - inherit options; - inherit extendModules; - }; -in -{ - options = { - debug = mkOption { - type = types.bool; - default = false; - description = '' - Whether to add the attributes `debug`, `allSystems` and `currentSystem` - to the flake output. When `true`, this allows inspection of options via - `nix repl`. - - ``` - $ nix repl - nix-repl> :lf . - nix-repl> currentSystem._module.args.pkgs.hello - «derivation /nix/store/7vf0d0j7majv1ch1xymdylyql80cn5fp-hello-2.12.1.drv» - ``` - - Each of `debug`, `allSystems.` and `currentSystem` is an - attribute set consisting of the `config` attributes, plus the extra - attributes `_module`, `config`, `options`, `extendModules`. So note that - these are not part of the `config` parameter, but are merged in for - debugging convenience. - - - `debug`: The top-level options - - `allSystems`: The `perSystem` submodule applied to the configured `systems`. - - `currentSystem`: Shortcut into `allSystems`. Only available in impure mode. - Works for arbitrary system values. - - See [Expore and debug option values](../debug.html) for more examples. - ''; - }; - perSystem = mkPerSystemOption - ({ options, config, extendModules, ... }: { - _file = ./formatter.nix; - options = { - debug = mkOption { - description = '' - Values to return in e.g. `allSystems.` when - [`debug = true`](#opt-debug). - ''; - type = types.lazyAttrsOf types.raw; - }; - }; - config = { - debug = mkDebugConfig { inherit config options extendModules; }; - }; - }); - }; - - config = mkIf config.debug { - flake = { - debug = mkDebugConfig { inherit config options extendModules; }; - allSystems = mapAttrs (_s: c: c.debug) config.allSystems; - } // optionalAttrs (builtins?currentSystem) { - currentSystem = (getSystem builtins.currentSystem).debug; - }; - }; -} diff --git a/nix/snow/flake/modules/default.nix b/nix/snow/flake/modules/default.nix new file mode 100644 index 0000000..e6914a0 --- /dev/null +++ b/nix/snow/flake/modules/default.nix @@ -0,0 +1,15 @@ +{...}: { + imports = [ + ./outputs.nix + + ./apps.nix + ./checks.nix + ./devShells.nix + ./formatter.nix + ./legacyPackages.nix + ./nixosConfigurations.nix + ./nixosModules.nix + ./overlays.nix + ./packages.nix + ]; +} diff --git a/nix/snow/flake/modules/devShells.nix b/nix/snow/flake/modules/devShells.nix index c0cc6c5..7116e6b 100644 --- a/nix/snow/flake/modules/devShells.nix +++ b/nix/snow/flake/modules/devShells.nix @@ -1,30 +1,35 @@ -{ lib, flake-parts-lib, ... }: -let - inherit (lib) +{ + lib, + snow, + ... +}: let + inherit + (lib) mkOption types literalExpression ; - inherit (flake-parts-lib) - mkTransposedPerSystemModule + inherit + (snow) + mkPerSystemFlakeOutput ; in -mkTransposedPerSystemModule { - name = "devShells"; - option = mkOption { - type = types.lazyAttrsOf types.package; - default = { }; - description = '' - An attribute set of packages to be used as shells. - [`nix develop .#`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-develop.html) will run `devShells.`. - ''; - example = literalExpression '' - { - default = pkgs.mkShell { - nativeBuildInputs = with pkgs; [ wget bat cargo ]; - }; - } - ''; - }; - file = ./devShells.nix; -} + mkPerSystemFlakeOutput { + name = "devShells"; + option = mkOption { + type = types.lazyAttrsOf types.package; + default = {}; + description = '' + An attribute set of packages to be used as shells. + [`nix develop .#`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-develop.html) will run `devShells.`. + ''; + example = literalExpression '' + { + default = pkgs.mkShell { + nativeBuildInputs = with pkgs; [ wget bat cargo ]; + }; + } + ''; + }; + file = ./devShells.nix; + } diff --git a/nix/snow/flake/modules/formatter.nix b/nix/snow/flake/modules/formatter.nix index e2959ed..44e07c2 100644 --- a/nix/snow/flake/modules/formatter.nix +++ b/nix/snow/flake/modules/formatter.nix @@ -1,52 +1,26 @@ -{ config, lib, flake-parts-lib, ... }: -let - inherit (lib) - filterAttrs - mapAttrs +{ + lib, + snow, + ... +}: let + inherit + (lib) mkOption - optionalAttrs types ; - inherit (flake-parts-lib) - mkPerSystemOption + inherit + (snow) + mkPerSystemFlakeOutput ; in -{ - options = { - flake.formatter = mkOption { - type = types.lazyAttrsOf types.package; - default = { }; + mkPerSystemFlakeOutput { + name = "formatter"; + option = mkOption { + type = types.nullOr types.package; + default = null; description = '' - An attribute set of per system a package used by [`nix fmt`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-fmt.html). + A package used by [`nix fmt`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-fmt.html). ''; }; - - perSystem = mkPerSystemOption { - _file = ./formatter.nix; - options = { - formatter = mkOption { - type = types.nullOr types.package; - default = null; - description = '' - A package used by [`nix fmt`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-fmt.html). - ''; - }; - }; - }; - }; - config = { - flake.formatter = - mapAttrs - (k: v: v.formatter) - (filterAttrs - (k: v: v.formatter != null) - config.allSystems - ); - - perInput = system: flake: - optionalAttrs (flake?formatter.${system}) { - formatter = flake.formatter.${system}; - }; - - }; -} + file = ./apps.nix; + } diff --git a/nix/snow/flake/modules/legacyPackages.nix b/nix/snow/flake/modules/legacyPackages.nix index fb17e14..f167c93 100644 --- a/nix/snow/flake/modules/legacyPackages.nix +++ b/nix/snow/flake/modules/legacyPackages.nix @@ -1,21 +1,26 @@ -{ lib, flake-parts-lib, ... }: -let - inherit (lib) +{ + lib, + snow, + ... +}: let + inherit + (lib) mkOption types ; - inherit (flake-parts-lib) - mkTransposedPerSystemModule + inherit + (snow) + mkPerSystemFlakeOutput ; in -mkTransposedPerSystemModule { - name = "legacyPackages"; - option = mkOption { - type = types.lazyAttrsOf types.raw; - default = { }; - description = '' - An attribute set of unmergeable values. This is also used by [`nix build .#`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-build.html). - ''; - }; - file = ./legacyPackages.nix; -} + mkPerSystemFlakeOutput { + name = "legacyPackages"; + option = mkOption { + type = types.lazyAttrsOf types.raw; + default = {}; + description = '' + Used for nixpkgs packages, also accessible via `nix build .#` [`nix build .#`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-build.html). + ''; + }; + file = ./legacyPackages.nix; + } diff --git a/nix/snow/flake/modules/moduleWithSystem.nix b/nix/snow/flake/modules/moduleWithSystem.nix deleted file mode 100644 index e5c7008..0000000 --- a/nix/snow/flake/modules/moduleWithSystem.nix +++ /dev/null @@ -1,32 +0,0 @@ -{ withSystem, ... }: -{ - config = { - _module.args = { - moduleWithSystem = - module: - - { config, ... }: - let - system = - config._module.args.system or - config._module.args.pkgs.stdenv.hostPlatform.system or - (throw "moduleWithSystem: Could not determine the configuration's system parameter for this module system application."); - - allArgs = withSystem system (args: args); - - lazyArgsPerParameter = f: builtins.mapAttrs - (k: v: allArgs.${k} or (throw "moduleWithSystem: module argument `${k}` does not exist.")) - (builtins.functionArgs f); - - # Use reflection to make the call lazy in the argument. - # Restricts args to the ones declared. - callLazily = f: a: f (lazyArgsPerParameter f); - in - { - imports = [ - (callLazily module allArgs) - ]; - }; - }; - }; -} diff --git a/nix/snow/flake/modules/nixosConfigurations.nix b/nix/snow/flake/modules/nixosConfigurations.nix index 597132d..7db8077 100644 --- a/nix/snow/flake/modules/nixosConfigurations.nix +++ b/nix/snow/flake/modules/nixosConfigurations.nix @@ -1,16 +1,15 @@ -{ lib, ... }: -let - inherit (lib) +{lib, ...}: let + inherit + (lib) mkOption types literalExpression ; -in -{ +in { options = { - flake.nixosConfigurations = mkOption { + outputs.nixosConfigurations = mkOption { type = types.lazyAttrsOf types.raw; - default = { }; + default = {}; description = '' Instantiated NixOS configurations. Used by `nixos-rebuild`. diff --git a/nix/snow/flake/modules/nixosModules.nix b/nix/snow/flake/modules/nixosModules.nix index 86ee9cc..6819570 100644 --- a/nix/snow/flake/modules/nixosModules.nix +++ b/nix/snow/flake/modules/nixosModules.nix @@ -1,20 +1,23 @@ -{ self, lib, moduleLocation, ... }: -let - inherit (lib) +{ + lib, + moduleLocation, + ... +}: let + inherit + (lib) mapAttrs mkOption types ; -in -{ +in { options = { - flake.nixosModules = mkOption { + outputs.nixosModules = mkOption { type = types.lazyAttrsOf types.deferredModule; - default = { }; + default = {}; apply = mapAttrs (k: v: { _class = "nixos"; _file = "${toString moduleLocation}#nixosModules.${k}"; - imports = [ v ]; + imports = [v]; }); description = '' NixOS modules. diff --git a/nix/snow/flake/modules/nixpkgs.nix b/nix/snow/flake/modules/nixpkgs.nix deleted file mode 100644 index 44df915..0000000 --- a/nix/snow/flake/modules/nixpkgs.nix +++ /dev/null @@ -1,26 +0,0 @@ -# -# Nixpkgs module. The only exception to the rule. -# -# Provides a `pkgs` argument in `perSystem`. -# -# Arguably, this shouldn't be in flake-parts, but in nixpkgs. -# Nixpkgs could define its own module that does this, which would be -# a more consistent UX, but for now this will do. -# -# The existence of this module does not mean that other flakes' logic -# will be accepted into flake-parts, because it's against the -# spirit of Flakes. -# -{ - config = { - perSystem = { inputs', lib, ... }: { - config = { - _module.args.pkgs = lib.mkOptionDefault ( - builtins.seq - (inputs'.nixpkgs or (throw "flake-parts: The flake does not have a `nixpkgs` input. Please add it, or set `perSystem._module.args.pkgs` yourself.")) - inputs'.nixpkgs.legacyPackages - ); - }; - }; - }; -} diff --git a/nix/snow/flake/modules/flake.nix b/nix/snow/flake/modules/outputs.nix similarity index 94% rename from nix/snow/flake/modules/flake.nix rename to nix/snow/flake/modules/outputs.nix index 871f04d..3539f5c 100644 --- a/nix/snow/flake/modules/flake.nix +++ b/nix/snow/flake/modules/outputs.nix @@ -9,7 +9,7 @@ types ; - flake = mkOption { + outputs = mkOption { type = types.submoduleWith { modules = [ { @@ -39,8 +39,7 @@ }; in { options = { - inherit flake; - output = {inherit flake;}; + inherit outputs; }; config = {inherit (config) flake;}; diff --git a/nix/snow/flake/modules/overlays.nix b/nix/snow/flake/modules/overlays.nix index 172336c..55423c2 100644 --- a/nix/snow/flake/modules/overlays.nix +++ b/nix/snow/flake/modules/overlays.nix @@ -1,19 +1,18 @@ -{ lib, ... }: -let - inherit (lib) +{lib, ...}: let + inherit + (lib) mkOption types ; -in -{ +in { options = { - flake.overlays = mkOption { + outputs.overlays = mkOption { # uniq -> ordered: https://github.com/NixOS/nixpkgs/issues/147052 # also update description when done type = types.lazyAttrsOf (types.uniq (types.functionTo (types.functionTo (types.lazyAttrsOf types.unspecified)))); # This eta expansion exists for the sole purpose of making nix flake check happy. apply = lib.mapAttrs (_k: f: final: prev: f final prev); - default = { }; + default = {}; example = lib.literalExpression '' { default = final: prev: {}; diff --git a/nix/snow/flake/modules/packages.nix b/nix/snow/flake/modules/packages.nix index 20f0071..517c758 100644 --- a/nix/snow/flake/modules/packages.nix +++ b/nix/snow/flake/modules/packages.nix @@ -1,23 +1,29 @@ -{ lib, flake-parts-lib, ... }: -let - inherit (lib) +{ + lib, + snow, + ... +}: let + inherit + (lib) mkOption types ; - inherit (flake-parts-lib) - mkTransposedPerSystemModule + + inherit + (snow) + mkPerSystemFlakeOutput ; in -mkTransposedPerSystemModule { - name = "packages"; - option = mkOption { - type = types.lazyAttrsOf types.package; - default = { }; - description = '' - An attribute set of packages to be built by [`nix build`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-build.html). + mkPerSystemFlakeOutput { + name = "packages"; + option = mkOption { + type = types.lazyAttrsOf types.package; + default = {}; + description = '' + An attribute set of packages to be built by [`nix build`](https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-build.html). - `nix build .#` will build `packages.`. - ''; - }; - file = ./packages.nix; -} + `nix build .#` will build `packages.`. + ''; + }; + file = ./packages.nix; + } diff --git a/nix/snow/flake/modules/perSystem.nix b/nix/snow/flake/modules/perSystem.nix deleted file mode 100644 index d4890ef..0000000 --- a/nix/snow/flake/modules/perSystem.nix +++ /dev/null @@ -1,159 +0,0 @@ -{ config, lib, flake-parts-lib, self, ... }: -let - inherit (lib) - genAttrs - mapAttrs - mkOption - types - ; - inherit (lib.strings) - escapeNixIdentifier - ; - inherit (flake-parts-lib) - mkPerSystemType - ; - - rootConfig = config; - - # Stubs for self and inputs. While it'd be possible to define aliases - # inside perSystem, that is not a general solution, and it would make - # top.config harder to discover, stretching the learning curve rather - # than flattening it. - - throwAliasError' = param: - throw '' - `${param}` (without `'`) is not a `perSystem` module argument, but a - module argument of the top level config. - - The following is an example usage of `${param}`. Note that its binding - is in the `top` parameter list, which is declared by the top level module - rather than the `perSystem` module. - - top@{ config, lib, ${param}, ... }: { - perSystem = { config, ${param}', ... }: { - # in scope here: - # - ${param} - # - ${param}' - # - config (of perSystem) - # - top.config (note the `top@` pattern) - }; - } - ''; - - throwAliasError = param: - throw '' - `${param}` is not a `perSystem` module argument, but a module argument of - the top level config. - - The following is an example usage of `${param}`. Note that its binding - is in the `top` parameter list, which is declared by the top level module - rather than the `perSystem` module. - - top@{ config, lib, ${param}, ... }: { - perSystem = { config, ... }: { - # in scope here: - # - ${param} - # - config (of perSystem) - # - top.config (note the `top@` pattern) - }; - } - ''; - - /** - We primarily use `systems` to help memoize the per system context, but that - doesn't extend to arbitrary `system`s. - For that, we use the slightly less efficient, but perfectly acceptable - `memoizeStr` function. - */ - otherMemoizedSystems = flake-parts-lib.memoizeStr config.perSystem; - -in -{ - options = { - systems = mkOption { - description = '' - All the system types to enumerate in the flake output subattributes. - - In other words, all valid values for `system` in e.g. `packages..foo`. - ''; - type = types.listOf types.str; - }; - - perInput = mkOption { - description = '' - A function that pre-processes flake inputs. - - It is called for users of `perSystem` such that `inputs'.''${name} = config.perInput system inputs.''${name}`. - - This is used for [`inputs'`](../module-arguments.html#inputs) and [`self'`](../module-arguments.html#self). - - The attributes returned by the `perInput` function definitions are merged into a single namespace (per input), - so each module should return an attribute set with usually only one or two predictable attribute names. Otherwise, - the `inputs'` namespace gets polluted. - ''; - type = types.functionTo (types.functionTo (types.lazyAttrsOf types.unspecified)); - }; - - perSystem = mkOption { - description = '' - A function from system to flake-like attributes omitting the `` attribute. - - Modules defined here have access to the suboptions and [some convenient module arguments](../module-arguments.html). - ''; - type = mkPerSystemType ({ config, system, ... }: { - _file = ./perSystem.nix; - config = { - _module.args.inputs' = - mapAttrs - (inputName: input: - builtins.addErrorContext "while retrieving system-dependent attributes for input ${escapeNixIdentifier inputName}" ( - if input._type or null == "flake" - then rootConfig.perInput system input - else - throw "Trying to retrieve system-dependent attributes for input ${escapeNixIdentifier inputName}, but this input is not a flake. Perhaps flake = false was added to the input declarations by mistake, or you meant to use a different input, or you meant to use plain old inputs, not inputs'." - ) - ) - self.inputs; - _module.args.self' = - builtins.addErrorContext "while retrieving system-dependent attributes for a flake's own outputs" ( - rootConfig.perInput system self - ); - - # Custom error messages - _module.args.self = throwAliasError' "self"; - _module.args.inputs = throwAliasError' "inputs"; - _module.args.getSystem = throwAliasError "getSystem"; - _module.args.withSystem = throwAliasError "withSystem"; - _module.args.moduleWithSystem = throwAliasError "moduleWithSystem"; - }; - }); - apply = modules: system: - (lib.evalModules { - inherit modules; - prefix = [ "perSystem" system ]; - specialArgs = { - inherit system; - }; - class = "perSystem"; - }).config; - }; - - allSystems = mkOption { - type = types.lazyAttrsOf types.unspecified; - description = "The system-specific config for each of systems."; - internal = true; - }; - }; - - config = { - allSystems = genAttrs config.systems config.perSystem; - _module.args.getSystem = system: config.allSystems.${system} or (otherMemoizedSystems system); - - # The warning is there for a reason. Only use this in situations where the - # performance cost has already been incurred, such as in `flakeModules.easyOverlay`, - # where we run in the context of an overlay, and the performance cost of the - # extra `pkgs` makes the cost of running `perSystem` probably negligible. - _module.args.getSystemIgnoreWarning = system: config.allSystems.${system} or (config.perSystem system); - }; - -} diff --git a/nix/snow/flake/modules/transposition.nix b/nix/snow/flake/modules/transposition.nix deleted file mode 100644 index d532e76..0000000 --- a/nix/snow/flake/modules/transposition.nix +++ /dev/null @@ -1,132 +0,0 @@ -{ config, lib, flake-parts-lib, ... }: - -let - inherit (lib) - filterAttrs - mapAttrs - mkOption - types - ; - inherit (lib.strings) - escapeNixIdentifier - ; - - transpositionModule = { - options = { - adHoc = mkOption { - type = types.bool; - default = false; - description = '' - Whether to provide a stub option declaration for {option}`perSystem.`. - - The stub option declaration does not support merging and lacks - documentation, so you are recommended to declare the {option}`perSystem.` - option yourself and avoid {option}`adHoc`. - ''; - }; - }; - }; - - perInputAttributeError = { flake, attrName, system, attrConfig }: - # This uses flake.outPath for lack of a better identifier. - # Consider adding a perInput variation that has a normally-redundant argument for the input name. - # Tested manually with - # perSystem = { inputs', ... }: { - # packages.extra = inputs'.nixpkgs.extra; - # packages.default = inputs'.nixpkgs.packages.default; - # packages.veryWrong = (top.config.perInput "x86_64-linux" inputs'.nixpkgs.legacyPackages.hello).packages.default; - # }; - # transposition.extra = {}; - let - attrPath = "${escapeNixIdentifier attrName}.${escapeNixIdentifier system}"; - flakeIdentifier = - if flake._type or null != "flake" - then - throw "An attempt was made to access attribute ${attrPath} on a value that's supposed to be a flake, but may not be a proper flake." - else - builtins.addErrorContext "while trying to find out how to describe what is supposedly a flake, whose attribute ${attrPath} was accessed but does not exist" ( - toString flake.outPath - ); - # This ought to be generalized by extending attrConfig, but this is the only known and common mistake for now. - alternateAttrNameHint = - if attrName == "packages" && flake?legacyPackages - then # Unfortunately we can't just switch them out, because that will put packages *sets* where single packages are expected in user code, resulting in potentially much worse and more confusing errors down the line. - "\nIt does define legacyPackages; try that instead?" - else ""; - in - if flake?${attrName} - then - throw '' - Attempt to access ${attrPath} of flake ${flakeIdentifier}, but it does not have it. - It does have attribute ${escapeNixIdentifier attrName}, so it appears that it does not support system type ${escapeNixIdentifier system}. - '' - else - throw '' - Attempt to access ${attrPath} of flake ${flakeIdentifier}, but it does not have attribute ${escapeNixIdentifier attrName}.${alternateAttrNameHint} - ''; - - -in -{ - options = { - transposition = lib.mkOption { - description = '' - A helper that defines transposed attributes in the flake outputs. - - When you define `transposition.foo = { };`, definitions are added to the effect of (pseudo-code): - - ```nix - flake.foo.''${system} = (perSystem system).foo; - perInput = system: inputFlake: inputFlake.foo.''${system}; - ``` - - Transposition is the operation that swaps the indices of a data structure. - Here it refers specifically to the transposition between - - ```plain - perSystem: .''${system}.''${attribute} - outputs: .''${attribute}.''${system} - ``` - - It also defines the reverse operation in [{option}`perInput`](#opt-perInput). - ''; - type = - types.lazyAttrsOf - (types.submoduleWith { modules = [ transpositionModule ]; }); - }; - }; - - config = { - flake = - lib.mapAttrs - (attrName: attrConfig: - mapAttrs - (system: v: v.${attrName} or ( - abort '' - Could not find option ${attrName} in the perSystem module. It is required to declare such an option whenever transposition. is defined (and in this instance is ${attrName}). - '')) - config.allSystems - ) - config.transposition; - - perInput = - system: flake: - mapAttrs - (attrName: attrConfig: - flake.${attrName}.${system} or ( - throw (perInputAttributeError { inherit system flake attrName attrConfig; }) - ) - ) - config.transposition; - - perSystem = { - options = - mapAttrs - (k: v: lib.mkOption { }) - (filterAttrs - (k: v: v.adHoc) - config.transposition - ); - }; - }; -} diff --git a/nix/snow/flake/modules/withSystem.nix b/nix/snow/flake/modules/withSystem.nix deleted file mode 100644 index 161eece..0000000 --- a/nix/snow/flake/modules/withSystem.nix +++ /dev/null @@ -1,37 +0,0 @@ -{ lib, flake-parts-lib, getSystem, ... }: -let - inherit (lib) - mkOption - types - ; - inherit (flake-parts-lib) - mkPerSystemOption - ; -in -{ - options = { - perSystem = mkPerSystemOption ({ config, options, specialArgs, ... }: { - _file = ./perSystem.nix; - options = { - allModuleArgs = mkOption { - type = types.lazyAttrsOf (types.raw or types.unspecified); - internal = true; - readOnly = true; - description = "Internal option that exposes _module.args, for use by withSystem."; - }; - }; - config = { - allModuleArgs = config._module.args // specialArgs // { inherit config options; }; - }; - }); - }; - - config = { - _module.args = { - withSystem = - system: f: - f - (getSystem system).allModuleArgs; - }; - }; -} From f819933c8d9e1ff4fb85d52aca075b36bed6ad45 Mon Sep 17 00:00:00 2001 From: _cry64 Date: Sun, 15 Mar 2026 01:10:36 +1000 Subject: [PATCH 4/8] node inheritance + group parsing --- nix/snow/default.nix | 5 +- nix/snow/flake/modules/outputs.nix | 1 - nix/snow/flake/nodes/default.nix | 35 ++--- nix/snow/flake/nodes/groups.nix | 73 ++++++++++ .../flake/nodes/{submodule.nix => node.nix} | 103 +++++++++++++- .../flake/nodes/{shared.nix => nodes.nix} | 51 +++++-- nix/snow/flake/outputs/checks.nix | 15 +- nix/snow/flake/outputs/deploy.nix | 133 +++++++++++------- .../flake/outputs/nixosConfigurations.nix | 126 ++++++++++------- nix/snow/lib/default.nix | 27 ++++ nix/snow/{flake/lib.nix => lib/nixpkgs.nix} | 10 +- nix/snow/lib/nodes.nix | 96 ------------- 12 files changed, 422 insertions(+), 253 deletions(-) create mode 100644 nix/snow/flake/nodes/groups.nix rename nix/snow/flake/nodes/{submodule.nix => node.nix} (62%) rename nix/snow/flake/nodes/{shared.nix => nodes.nix} (81%) create mode 100644 nix/snow/lib/default.nix rename nix/snow/{flake/lib.nix => lib/nixpkgs.nix} (83%) delete mode 100644 nix/snow/lib/nodes.nix diff --git a/nix/snow/default.nix b/nix/snow/default.nix index 15c67da..c90685e 100644 --- a/nix/snow/default.nix +++ b/nix/snow/default.nix @@ -18,15 +18,14 @@ } @ args: let inherit (nt) findImport; in - mix.newMixture args (mixture: let - inherit (mixture) mapNodes; - in { + mix.newMixture args (mixture: { includes = { private = [ ./lib/nodes.nix ]; public = [ ./flake + ./lib.nix ]; }; diff --git a/nix/snow/flake/modules/outputs.nix b/nix/snow/flake/modules/outputs.nix index 3539f5c..551186a 100644 --- a/nix/snow/flake/modules/outputs.nix +++ b/nix/snow/flake/modules/outputs.nix @@ -21,7 +21,6 @@ No option has been declared for this flake output attribute, so its definitions can't be merged automatically. Possible solutions: - Load a module that defines this flake output attribute - Many modules are listed at https://flake.parts - Declare an option for this flake output attribute - Make sure the output attribute is spelled correctly - Define the value only once, with a single definition in a single module diff --git a/nix/snow/flake/nodes/default.nix b/nix/snow/flake/nodes/default.nix index d3bc9b7..d7b6a82 100644 --- a/nix/snow/flake/nodes/default.nix +++ b/nix/snow/flake/nodes/default.nix @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. { + _snow, lib, specialArgs, ... @@ -25,38 +26,20 @@ in mkOption { description = '' - Cerulean node declarations. + Snowflake node declarations. ''; type = types.submoduleWith { inherit specialArgs; modules = [ - { - imports = [./shared.nix]; - - options = { - groups = mkOption { - type = types.attrs; - default = {}; - example = lib.literalExpression "{ servers = { staging = {}; production = {}; }; }"; - description = '' - Hierarchical groups that nodes can be a member of. - ''; - }; - - nodes = mkOption { - type = types.attrsOf (types.submoduleWith { - inherit specialArgs; - modules = [(import ./submodule.nix)]; - }); - # example = { ... }; # TODO - description = '' - Node (host systems) declarations. - ''; - }; - }; - } + ./nodes.nix ]; }; }; + + config = { + nodes = { + base = _snow.inputs.nixpkgs; + }; + }; } diff --git a/nix/snow/flake/nodes/groups.nix b/nix/snow/flake/nodes/groups.nix new file mode 100644 index 0000000..b22cac0 --- /dev/null +++ b/nix/snow/flake/nodes/groups.nix @@ -0,0 +1,73 @@ +# # Copyright 2025-2026 _cry64 (Emile Clark-Boman) +# # +# # Licensed under the Apache License, Version 2.0 (the "License"); +# # you may not use this file except in compliance with the License. +# # You may obtain a copy of the License at +# # +# # http://www.apache.org/licenses/LICENSE-2.0 +# # +# # Unless required by applicable law or agreed to in writing, software +# # distributed under the License is distributed on an "AS IS" BASIS, +# # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# # See the License for the specific language governing permissions and +# # limitations under the License. +{nt, ...}: let + inherit + (builtins) + concatLists + elem + filter + isAttrs + mapAttrs + pathExists + typeOf + ; + + rootGroupName = "all"; +in { + parseGroupsDecl = groups: let + validGroup = g: + isAttrs g + || throw '' + Snow node groups must be provided as attribute sets, got "${typeOf g}" instead! + Ensure all the group definitions are attribute sets under your call to `snow.flake`. + NOTE: Groups can be accessed via `self.groups.PATH.TO.YOUR.GROUP` + ''; + delegate = parent: gName: g: let + result = + (g + // { + _name = gName; + _parent = parent; + }) + |> mapAttrs (name: value: + if elem name ["_name" "_parent"] + # ignore metadata fields + then value + else assert validGroup value; (delegate result name value)); + in + result; + in + assert validGroup groups; + delegate null rootGroupName groups; + + getGroupModules = root: groups: + # ensure root group is always added + groups + # add all inherited groups via _parent + |> map (let + delegate = g: + if g._parent == null + then [g] + else [g] ++ delegate (g._parent); + in + delegate) + # flatten recursion result + |> concatLists + # find import location + |> map (group: nt.findImport /${root}/groups/${group._name}) + # filter by uniqueness + |> nt.prim.unique + # ignore missing groups + |> filter pathExists; +} diff --git a/nix/snow/flake/nodes/submodule.nix b/nix/snow/flake/nodes/node.nix similarity index 62% rename from nix/snow/flake/nodes/submodule.nix rename to nix/snow/flake/nodes/node.nix index 6b4ae05..a368d24 100644 --- a/nix/snow/flake/nodes/submodule.nix +++ b/nix/snow/flake/nodes/node.nix @@ -14,16 +14,18 @@ { lib, systems, + config, + nodesConfig, ... }: { - imports = [./shared.nix]; - options = let inherit (lib) mkOption types ; + + flakeRef = types.either types.str types.path; in { enabled = lib.mkOption { type = types.bool; @@ -43,6 +45,65 @@ ''; }; + base = lib.mkOption { + # In newer Nix versions, particularly with lazy trees, outPath of + # flakes becomes a Nix-language path object. We deliberately allow this + # to gracefully come through the interface in discussion with @roberth. + # + # See: https://github.com/NixOS/nixpkgs/pull/278522#discussion_r1460292639 + type = types.nullOr flakeRef; + + default = nodesConfig.base; + defaultText = "nodes.base"; + + example = lib.literalExpression "inputs.nixpkgs"; + + description = '' + The path to the nixpkgs source used to build a system. A `base` package set + is required to be set, and can be specified via either: + 1. `options.nodes.base` (default `base` used for all systems) + 2. `options.nodes.nodes..base` (takes prescedence over `options.nodes.base`) + + This can also be optionally set if the NixOS system is not built with a flake but still uses + pinned sources: set this to the store path for the nixpkgs sources used to build the system, + as may be obtained by `fetchTarball`, for example. + + Note: the name of the store path must be "source" due to + . + ''; + }; + + homeManager = mkOption { + type = types.nullOr flakeRef; + default = nodesConfig.homeManager; + defaultText = "nodes.homeManager"; + example = lib.literalExpression "inputs.home-manager"; + description = '' + The path to the home-manager source. A `homeManager` flake reference + is required to be set for `homes/` to be evaluated, and can be specified via either: + 1. `options.nodes.homeManager` (default `homManager` used for all systems) + 2. `options.nodes.nodes..homeManager` (takes prescedence over `options.nodes.homeManager`) + ''; + }; + + modules = mkOption { + type = types.listOf types.raw; + default = []; + example = lib.literalExpression "[ { environment.systemPackages = [ pkgs.git ]; } ]"; + description = '' + Shared modules to import; equivalent to the NixOS module system's `extraModules`. + ''; + }; + + args = mkOption { + type = types.attrs; + default = {}; + example = lib.literalExpression "{ inherit inputs; }"; + description = '' + Shared args to provided for each node; equivalent to the NixOS module system's `specialArgs`. + ''; + }; + groups = mkOption { # TODO: write a custom group type that validates better than types.attrs lol type = types.functionTo (types.listOf types.attrs); @@ -51,6 +112,9 @@ description = '' A function from the `groups` hierarchy to a list of groups this node inherits from. ''; + + apply = groupsFn: + groupsFn nodesConfig.groups; }; deploy = { @@ -91,7 +155,7 @@ example = false; description = '' Whether to enable interactive sudo (password based sudo). - NOT RECOMMENDED. Use one of Cerulean's recommended auth methods instead. + NOT RECOMMENDED. Use one of Snowflake's recommended auth methods instead. ''; }; @@ -164,7 +228,7 @@ user = mkOption { type = types.str; - default = "cerubld"; + default = "snowbld"; example = "custom-user"; description = '' The user to connect to over ssh during deployment. @@ -183,7 +247,7 @@ publicKeys = mkOption { type = types.listOf types.str; default = []; - example = ["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIeyZuUUmyUYrYaEJwEMvcXqZFYm1NaZab8klOyK6Imr me@puter"]; + example = ["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIeyZuUUmyUYrYaEJwEMvcXqZFYm1NaZab8klOyK6Imr me@myputer"]; description = '' SSH public keys that will be authorized to the deployment user. This key is intended solely for deployment, allowing for fine-grained permission control. @@ -201,4 +265,33 @@ }; }; }; + + config = let + throwGotNull = name: + throw '' + [snow] `nodes..${name}` must be set for all nodes! (got: ) + ''; + givenSystem = + (config.system != null) + || throwGotNull "system"; + + givenBase = + (config.base != null) + || throwGotNull "base"; + + givenHomeManager = + (config.homeManager != null) + || throwGotNull "homeManager"; + + givenDeployHost = + (config.deploy.ssh.host != null) + || throwGotNull "deploy.ssh.host"; + in + assert givenSystem + && givenBase + && givenHomeManager + && givenDeployHost; { + # extend these from the nodes configuration + inherit (nodesConfig) modules args; + }; } diff --git a/nix/snow/flake/nodes/shared.nix b/nix/snow/flake/nodes/nodes.nix similarity index 81% rename from nix/snow/flake/nodes/shared.nix rename to nix/snow/flake/nodes/nodes.nix index c840d22..58a9e1a 100644 --- a/nix/snow/flake/nodes/shared.nix +++ b/nix/snow/flake/nodes/nodes.nix @@ -11,7 +11,13 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -{lib, ...}: let +{ + _snow, + lib, + config, + specialArgs, + ... +}: let inherit (lib) mkOption @@ -19,6 +25,8 @@ ; flakeRef = types.either types.str types.path; + + groupLibs = import ./groups.nix {inherit (_snow.inputs) nt;}; in { options = { base = lib.mkOption { @@ -49,6 +57,18 @@ in { ''; }; + homeManager = mkOption { + type = types.nullOr flakeRef; + default = null; + example = lib.literalExpression "inputs.home-manager"; + description = '' + The path to the home-manager source. A `homeManager` flake reference + is required to be set for `homes/` to be evaluated, and can be specified via either: + 1. `options.nodes.homeManager` (default `homManager` used for all systems) + 2. `options.nodes.nodes..homeManager` (takes prescedence over `options.nodes.homeManager`) + ''; + }; + modules = mkOption { type = types.listOf types.raw; default = []; @@ -67,15 +87,28 @@ in { ''; }; - homeManager = mkOption { - type = types.nullOr flakeRef; - default = null; - example = lib.literalExpression "inputs.home-manager"; + groups = mkOption { + type = types.attrs; + default = {}; + example = lib.literalExpression "{ servers = { staging = {}; production = {}; }; }"; description = '' - The path to the home-manager source. A `homeManager` flake reference - is required to be set for `homes/` to be evaluated, and can be specified via either: - 1. `options.nodes.homeManager` (default `homManager` used for all systems) - 2. `options.nodes.nodes..homeManager` (takes prescedence over `options.nodes.homeManager`) + Hierarchical groups that nodes can be a member of. + ''; + + apply = groupLibs.parseGroupsDecl; + }; + + nodes = mkOption { + type = types.attrsOf (types.submoduleWith { + specialArgs = + specialArgs + // { + nodeConfig = config; + }; + modules = [./node.nix]; + }); + description = '' + Node (host systems) declarations. ''; }; }; diff --git a/nix/snow/flake/outputs/checks.nix b/nix/snow/flake/outputs/checks.nix index 21fd677..a25ba32 100644 --- a/nix/snow/flake/outputs/checks.nix +++ b/nix/snow/flake/outputs/checks.nix @@ -1,5 +1,10 @@ - checks = - inputs.deploy-rs.lib - |> mapAttrs (system: deployLib: - deployLib.deployChecks deploy); - +{ + config, + _snow, + ... +}: { + outputs.checks = + _snow.inputs.deploy-rs.lib + |> builtins.mapAttrs (system: deployLib: + deployLib.deployChecks config.outputs.deploy); +} diff --git a/nix/snow/flake/outputs/deploy.nix b/nix/snow/flake/outputs/deploy.nix index 08caa8f..c8d39a9 100644 --- a/nix/snow/flake/outputs/deploy.nix +++ b/nix/snow/flake/outputs/deploy.nix @@ -1,57 +1,90 @@ - deploy.nodes = mapNodes nodes ({ - name, - node, - ... - }: let - inherit - (node.deploy) - ssh - user - interactiveSudo - remoteBuild - rollback - autoRollback - magicRollback - activationTimeout - confirmTimeout - ; +{ + _snow, + config, + ... +}: let + inherit + (builtins) + mapAttrs + ; - nixosFor = system: inputs.deploy-rs.lib.${system}.activate.nixos; - in { - hostname = - if ssh.host != null - then ssh.host - else ""; + mapNodes = nodes: f: + nodes.nodes + |> mapAttrs (name: node: let + # use per-node base or default to nodes' base + base = + if node.base != null + then node.base + else if nodes.base != null + then nodes.base + else + abort '' + snow cannot construct nodes node "${name}" without a base package source. + Ensure `nodes.nodes.*.base` or `nodes.base` is a flake reference to the github:NixOS/nixpkgs repository. + ''; + in + f rec { + inherit name node base; + inherit (base) lib; - profilesOrder = ["default"]; # profiles priority - profiles.default = { - path = nixosFor node.system nixosConfigurations.${name}; + groups = node.groups (parseGroupsDecl nodes.groups); + groupModules = root: getGroupModules root groups; + }); +in { + outputs.deploy.nodes = mapNodes config.nodes ({ + name, + node, + ... + }: let + inherit + (node.deploy) + ssh + user + interactiveSudo + remoteBuild + rollback + autoRollback + magicRollback + activationTimeout + confirmTimeout + ; - user = user; - sudo = "sudo -u"; - interactiveSudo = interactiveSudo; + nixosFor = system: _snow.inputs.deploy-rs.lib.${system}.activate.nixos; + in { + hostname = + if ssh.host != null + then ssh.host + else ""; - fastConnection = false; + profilesOrder = ["default"]; # profiles priority + profiles.default = { + path = nixosFor node.system config.outputs.nixosConfigurations.${name}; - autoRollback = autoRollback -> rollback; - magicRollback = magicRollback -> rollback; - activationTimeout = activationTimeout; - confirmTimeout = confirmTimeout; + user = user; + sudo = "sudo -u"; + interactiveSudo = interactiveSudo; - remoteBuild = remoteBuild; - sshUser = ssh.user; - sshOpts = - ssh.opts - ++ ( - if elem "-p" ssh.opts - then [] - else ["-p" (toString ssh.port)] - ) - ++ ( - if elem "-A" ssh.opts - then [] - else ["-A"] - ); - }; - }); + fastConnection = false; + autoRollback = autoRollback -> rollback; + magicRollback = magicRollback -> rollback; + activationTimeout = activationTimeout; + confirmTimeout = confirmTimeout; + + remoteBuild = remoteBuild; + sshUser = ssh.user; + sshOpts = + ssh.opts + ++ ( + if builtins.elem "-p" ssh.opts + then [] + else ["-p" (toString ssh.port)] + ) + ++ ( + if builtins.elem "-A" ssh.opts + then [] + else ["-A"] + ); + }; + }); +} diff --git a/nix/snow/flake/outputs/nixosConfigurations.nix b/nix/snow/flake/outputs/nixosConfigurations.nix index 799758d..2ca88b6 100644 --- a/nix/snow/flake/outputs/nixosConfigurations.nix +++ b/nix/snow/flake/outputs/nixosConfigurations.nix @@ -8,60 +8,78 @@ # options = { ... }; # type = { ... }; # } - nixosConfigurations = mapNodes nodes ( - { - base, - lib, - name, - node, - groupModules, - ... - }: let - homeManager = - if node.homeManager != null - then node.homeManager - else if nodes.homeManager != null - then nodes.homeManager - else - warn '' - [snowflake] Neither `nodes.homeManager` nor `nodes.nodes.${name}.homeManager` were specified! - [snowflake] home-manager will NOT be used! User configuration will be ignored! - '' - null; +{ + snow, + config, + systems, + root, + ... +}: let + inherit + (builtins) + all + attrNames + warn + ; - userArgs = nodes.args // node.args; - ceruleanArgs = { - inherit systems root base nodes node; - inherit (node) system; - inherit (this) snow; - hostname = name; + inherit + (config) + nodes + ; +in { + outputs.nixosConfigurations = mapNodes nodes ( + { + base, + lib, + name, + node, + groupModules, + ... + }: let + homeManager = + if node.homeManager != null + then node.homeManager + else if nodes.homeManager != null + then nodes.homeManager + else + warn '' + [snowflake] Neither `nodes.homeManager` nor `nodes.nodes.${name}.homeManager` were specified! + [snowflake] home-manager will NOT be used! User configuration will be ignored! + '' + null; - _cerulean = { - inherit inputs userArgs ceruleanArgs homeManager; - specialArgs = userArgs // ceruleanArgs; - }; + userArgs = nodes.args // node.args; + snowArgs = { + inherit systems snow root base nodes node; + inherit (node) system; + hostname = name; + + _snow = { + inherit inputs userArgs snowArgs homeManager; + specialArgs = userArgs // snowArgs; }; - specialArgs = assert (userArgs - |> attrNames - |> all (argName: - ! ceruleanArgs ? argName - || abort '' - `specialArgs` are like super important to Cerulean my love... attrNames + |> all (argName: + ! snowArgs ? argName + || abort '' + `specialArgs` are like super important to Snow my love... mapAttrs (name: value: - if elem name ["_name" "_parent"] - # ignore metadata fields - then value - else assert validGroup value; (delegate result name value)); - in - result; - in - assert validGroup groups; - delegate null rootGroupName groups; - - getGroupModules = root: groups: - # ensure root group is always added - groups - # add all inherited groups via _parent - |> map (let - delegate = g: - if g._parent == null - then [g] - else [g] ++ delegate (g._parent); - in - delegate) - # flatten recursion result - |> concatLists - # find import location - |> map (group: nt.findImport /${root}/groups/${group._name}) - # filter by uniqueness - |> nt.prim.unique - # ignore missing groups - |> filter pathExists; -in { - mapNodes = nodes: f: - nodes.nodes - |> mapAttrs (name: node: let - # use per-node base or default to nodes' base - base = - if node.base != null - then node.base - else if nodes.base != null - then nodes.base - else - abort '' - Cerulean cannot construct nodes node "${name}" without a base package source. - Ensure `nodes.nodes.*.base` or `nodes.base` is a flake reference to the github:NixOS/nixpkgs repository. - ''; - in - f rec { - inherit name node base; - inherit (base) lib; - - groups = node.groups (parseGroupsDecl nodes.groups); - groupModules = root: getGroupModules root groups; - }); -} From 16cfbe4da15c6d965c07460f1b341805a20d8e41 Mon Sep 17 00:00:00 2001 From: _cry64 Date: Sun, 15 Mar 2026 01:13:21 +1000 Subject: [PATCH 5/8] fix cerulean->nix bad import --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index 80faf5c..83bb612 100644 --- a/flake.nix +++ b/flake.nix @@ -44,7 +44,7 @@ nt, ... } @ inputs: - import ./cerulean + import ./nix { inherit inputs self nt; inherit (nt) mix; From f4dca25c28135abd9284cfce5ecfdeda8f0018ae Mon Sep 17 00:00:00 2001 From: _cry64 Date: Sun, 15 Mar 2026 01:13:28 +1000 Subject: [PATCH 6/8] progress flake.lock --- flake.lock | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/flake.lock b/flake.lock index fc8e402..a8c1976 100644 --- a/flake.lock +++ b/flake.lock @@ -185,9 +185,30 @@ "microvm": "microvm", "nixpkgs": "nixpkgs", "nt": "nt", + "sops-nix": "sops-nix", "systems": "systems_3" } }, + "sops-nix": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1773096132, + "narHash": "sha256-M3zEnq9OElB7zqc+mjgPlByPm1O5t2fbUrH3t/Hm5Ag=", + "owner": "Mic92", + "repo": "sops-nix", + "rev": "d1ff3b1034d5bab5d7d8086a7803c5a5968cd784", + "type": "github" + }, + "original": { + "owner": "Mic92", + "repo": "sops-nix", + "type": "github" + } + }, "spectrum": { "flake": false, "locked": { From 855430ef16eb0340facb632075ff898831d3ae8d Mon Sep 17 00:00:00 2001 From: _cry64 Date: Sun, 15 Mar 2026 01:13:50 +1000 Subject: [PATCH 7/8] fix snow/default.nix not updated (use snow/lib) --- nix/snow/default.nix | 29 +++++++++-------------------- 1 file changed, 9 insertions(+), 20 deletions(-) diff --git a/nix/snow/default.nix b/nix/snow/default.nix index c90685e..5f95f46 100644 --- a/nix/snow/default.nix +++ b/nix/snow/default.nix @@ -11,23 +11,12 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -{ - nt, - mix, - ... -} @ args: let - inherit (nt) findImport; -in - mix.newMixture args (mixture: { - includes = { - private = [ - ./lib/nodes.nix - ]; - public = [ - ./flake - ./lib.nix - ]; - }; - - inherit findImport; - }) +{mix, ...} @ args: +mix.newMixture args (mixture: { + includes = { + public = [ + ./flake + ./lib + ]; + }; +}) From 6c1a0a5d3395c5416d39e67a47bcdf7c1762613e Mon Sep 17 00:00:00 2001 From: _cry64 Date: Tue, 17 Mar 2026 20:37:59 +1000 Subject: [PATCH 8/8] minimal working state --- flake.lock | 32 ++--- nix/default.nix | 38 +++--- nix/nixos/default.nix | 10 +- nix/nixos/home.nix | 6 +- nix/snow/default.nix | 21 +-- nix/snow/flake/default.nix | 14 +- nix/snow/flake/module.nix | 24 ---- nix/snow/flake/modules/apps.nix | 2 +- nix/snow/flake/modules/checks.nix | 2 +- nix/snow/flake/modules/devShells.nix | 2 +- nix/snow/flake/modules/formatter.nix | 2 +- nix/snow/flake/modules/legacyPackages.nix | 2 +- nix/snow/flake/modules/outputs.nix | 61 ++++----- nix/snow/flake/modules/packages.nix | 2 +- nix/snow/flake/nodes/default.nix | 4 +- nix/snow/flake/nodes/groups.nix | 73 ----------- nix/snow/flake/nodes/node.nix | 62 +++++---- nix/snow/flake/nodes/nodes.nix | 14 +- nix/snow/flake/outputs/checks.nix | 4 +- nix/snow/flake/outputs/default.nix | 7 + nix/snow/flake/outputs/deploy.nix | 37 +----- .../flake/outputs/nixosConfigurations.nix | 123 +++++++++--------- nix/snow/lib/default.nix | 18 ++- nix/snow/lib/nixpkgs.nix | 7 +- nix/snow/lib/nodes.nix | 87 +++++++++++++ nix/snow/lib/util.nix | 3 + 26 files changed, 331 insertions(+), 326 deletions(-) delete mode 100644 nix/snow/flake/module.nix delete mode 100644 nix/snow/flake/nodes/groups.nix create mode 100644 nix/snow/flake/outputs/default.nix create mode 100644 nix/snow/lib/nodes.nix create mode 100644 nix/snow/lib/util.nix diff --git a/flake.lock b/flake.lock index a8c1976..6f3fefe 100644 --- a/flake.lock +++ b/flake.lock @@ -9,11 +9,11 @@ "utils": "utils" }, "locked": { - "lastModified": 1766051518, - "narHash": "sha256-znKOwPXQnt3o7lDb3hdf19oDo0BLP4MfBOYiWkEHoik=", + "lastModified": 1770019181, + "narHash": "sha256-hwsYgDnby50JNVpTRYlF3UR/Rrpt01OrxVuryF40CFY=", "owner": "serokell", "repo": "deploy-rs", - "rev": "d5eff7f948535b9c723d60cd8239f8f11ddc90fa", + "rev": "77c906c0ba56aabdbc72041bf9111b565cdd6171", "type": "github" }, "original": { @@ -68,11 +68,11 @@ "spectrum": "spectrum" }, "locked": { - "lastModified": 1771365290, - "narHash": "sha256-1XJOslVyF7yzf6yd/yl1VjGLywsbtwmQh3X1LuJcLI4=", + "lastModified": 1773018425, + "narHash": "sha256-fpgZBmZpKoEXEowBK/6m8g9FcOLWQ4UxhXHqCw2CpSM=", "owner": "microvm-nix", "repo": "microvm.nix", - "rev": "789c90b164b55b4379e7a94af8b9c01489024c18", + "rev": "25ebda3c558e923720c965832dc9a04f559a055c", "type": "github" }, "original": { @@ -129,11 +129,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1768323494, - "narHash": "sha256-yBXJLE6WCtrGo7LKiB6NOt6nisBEEkguC/lq/rP3zRQ=", + "lastModified": 1773375660, + "narHash": "sha256-SEzUWw2Rf5Ki3bcM26nSKgbeoqi2uYy8IHVBqOKjX3w=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "2c3e5ec5df46d3aeee2a1da0bfedd74e21f4bf3a", + "rev": "3e20095fe3c6cbb1ddcef89b26969a69a1570776", "type": "github" }, "original": { @@ -166,11 +166,11 @@ "systems": "systems_2" }, "locked": { - "lastModified": 1770975056, - "narHash": "sha256-ZXTz/P3zUbbM6lNXzt91u8EwfNqhXpYMu8+wvFZqQHE=", + "lastModified": 1773738366, + "narHash": "sha256-oH22HyNHEdCoCQo734sQCHUr6C0jmGQJMZ13dsgEHkk=", "owner": "cry128", "repo": "nt", - "rev": "f42dcdd49a7921a7f433512e83d5f93696632412", + "rev": "f32c3a726a3d608d30aaaa1df2301c1eaf5ef8f4", "type": "github" }, "original": { @@ -212,11 +212,11 @@ "spectrum": { "flake": false, "locked": { - "lastModified": 1759482047, - "narHash": "sha256-H1wiXRQHxxPyMMlP39ce3ROKCwI5/tUn36P8x6dFiiQ=", + "lastModified": 1772189877, + "narHash": "sha256-i1p90Rgssb//aNiTDFq46ZG/fk3LmyRLChtp/9lddyA=", "ref": "refs/heads/main", - "rev": "c5d5786d3dc938af0b279c542d1e43bce381b4b9", - "revCount": 996, + "rev": "fe39e122d898f66e89ffa17d4f4209989ccb5358", + "revCount": 1255, "type": "git", "url": "https://spectrum-os.org/git/spectrum" }, diff --git a/nix/default.nix b/nix/default.nix index 6c488a1..6364a63 100644 --- a/nix/default.nix +++ b/nix/default.nix @@ -15,22 +15,28 @@ mix, inputs, ... -} @ args: -mix.newMixture args (mixture: { - submods.public = [ - ./snow - ]; +} @ args: let + mixArgs = + args + // { + inherit (inputs.nixpkgs) lib; + }; +in + mix.newMixture mixArgs (mixture: { + submods.public = [ + ./snow + ]; - version = "0.2.6-alpha"; + version = "0.2.6-alpha"; - overlays = [ - # build deploy-rs as a package not from the flake input, - # hence we can rely on a nixpkg binary cache. - inputs.deploy-rs.overlays.default - ]; + overlays = [ + # build deploy-rs as a package not from the flake input, + # hence we can rely on a nixpkg binary cache. + inputs.deploy-rs.overlays.default + ]; - nixosModules = rec { - default = cerulean; - cerulean = ./nixos; - }; -}) + nixosModules = rec { + default = cerulean; + cerulean = ./nixos; + }; + }) diff --git a/nix/nixos/default.nix b/nix/nixos/default.nix index a716c2f..a91df1a 100644 --- a/nix/nixos/default.nix +++ b/nix/nixos/default.nix @@ -18,13 +18,13 @@ node, pkgs, lib, - _cerulean, + _snow, ... } @ args: { imports = [ - _cerulean.inputs.sops-nix.nixosModules.sops - # _cerulean.inputs.microvm.nixosModules.microvm + _snow.inputs.sops-nix.nixosModules.sops + # _snow.inputs.microvm.nixosModules.microvm # add support for `options.legacyImports` # ./legacy-imports.nix @@ -36,7 +36,7 @@ (import /${root}/nixpkgs.nix) ] # homemanager options declarations - ++ (lib.optional (_cerulean.homeManager != null) ./home.nix) + ++ (lib.optional (_snow.homeManager != null) ./home.nix) # remote deployment configuration ++ (lib.optional (node.deploy.ssh.host != null) ./remote-deploy); @@ -46,7 +46,7 @@ (with pkgs; [ sops ]) - ++ (with _cerulean.inputs; [ + ++ (with _snow.inputs; [ deploy-rs.packages.${system}.default ]); } diff --git a/nix/nixos/home.nix b/nix/nixos/home.nix index 82117d8..cf24f74 100644 --- a/nix/nixos/home.nix +++ b/nix/nixos/home.nix @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. { - _cerulean, + _snow, config, root, lib, @@ -30,7 +30,7 @@ ; in { imports = [ - _cerulean.homeManager.nixosModules.default + _snow.homeManager.nixosModules.default ]; options = { @@ -69,7 +69,7 @@ in { _module.args.username = name; }); - extraSpecialArgs = _cerulean.specialArgs; + extraSpecialArgs = _snow.specialArgs; sharedModules = [ ../home diff --git a/nix/snow/default.nix b/nix/snow/default.nix index 5f95f46..89e1772 100644 --- a/nix/snow/default.nix +++ b/nix/snow/default.nix @@ -11,12 +11,17 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -{mix, ...} @ args: -mix.newMixture args (mixture: { - includes = { - public = [ - ./flake - ./lib - ]; - }; +{ + nt, + mix, + ... +} @ args: +mix.newMixture (removeAttrs args ["this"]) (mixture: { + submods.public = [ + ./lib + ]; + + includes.public = [ + ./flake + ]; }) diff --git a/nix/snow/flake/default.nix b/nix/snow/flake/default.nix index 9c5d1f5..828f59b 100644 --- a/nix/snow/flake/default.nix +++ b/nix/snow/flake/default.nix @@ -1,4 +1,5 @@ { + self, this, inputs, systems, @@ -16,14 +17,20 @@ inherit (inputs.nixpkgs) lib; in { # snow.flake + # XXX: TODO: stop taking in root as parameter (maybe take self instead?) flake = flakeInputs: root: let snowflake = lib.evalModules { class = "snowflake"; specialArgs = let reservedSpecialArgs = { - inherit (this) snow; + # inherit (this) snow; + snow = this; inherit systems root; inputs = flakeInputs; + + _snowFlake = { + inherit self inputs; + }; }; warnIfReserved = let @@ -50,7 +57,10 @@ in { flakeInputs // reservedSpecialArgs; modules = [ - ./module.nix + ./nodes + ./modules + ./outputs + (this.lib.findImport /${root}/snow) ]; }; in diff --git a/nix/snow/flake/module.nix b/nix/snow/flake/module.nix deleted file mode 100644 index 1aacd0b..0000000 --- a/nix/snow/flake/module.nix +++ /dev/null @@ -1,24 +0,0 @@ -# Copyright 2025-2026 _cry64 (Emile Clark-Boman) -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -{ - root, - snow, - ... -}: { - imports = [ - ./nodes - ./modules - (snow.findImport /${root}/snow) - ]; -} diff --git a/nix/snow/flake/modules/apps.nix b/nix/snow/flake/modules/apps.nix index 75cc4be..cbe12f0 100644 --- a/nix/snow/flake/modules/apps.nix +++ b/nix/snow/flake/modules/apps.nix @@ -10,7 +10,7 @@ ; inherit - (snow) + (snow.lib) mkPerSystemFlakeOutput ; diff --git a/nix/snow/flake/modules/checks.nix b/nix/snow/flake/modules/checks.nix index a8a7280..d10d6d5 100644 --- a/nix/snow/flake/modules/checks.nix +++ b/nix/snow/flake/modules/checks.nix @@ -9,7 +9,7 @@ types ; inherit - (snow) + (snow.lib) mkPerSystemFlakeOutput ; in diff --git a/nix/snow/flake/modules/devShells.nix b/nix/snow/flake/modules/devShells.nix index 7116e6b..04ace01 100644 --- a/nix/snow/flake/modules/devShells.nix +++ b/nix/snow/flake/modules/devShells.nix @@ -10,7 +10,7 @@ literalExpression ; inherit - (snow) + (snow.lib) mkPerSystemFlakeOutput ; in diff --git a/nix/snow/flake/modules/formatter.nix b/nix/snow/flake/modules/formatter.nix index 44e07c2..5cce36b 100644 --- a/nix/snow/flake/modules/formatter.nix +++ b/nix/snow/flake/modules/formatter.nix @@ -9,7 +9,7 @@ types ; inherit - (snow) + (snow.lib) mkPerSystemFlakeOutput ; in diff --git a/nix/snow/flake/modules/legacyPackages.nix b/nix/snow/flake/modules/legacyPackages.nix index f167c93..9adc91d 100644 --- a/nix/snow/flake/modules/legacyPackages.nix +++ b/nix/snow/flake/modules/legacyPackages.nix @@ -9,7 +9,7 @@ types ; inherit - (snow) + (snow.lib) mkPerSystemFlakeOutput ; in diff --git a/nix/snow/flake/modules/outputs.nix b/nix/snow/flake/modules/outputs.nix index 551186a..bf7d9f5 100644 --- a/nix/snow/flake/modules/outputs.nix +++ b/nix/snow/flake/modules/outputs.nix @@ -8,38 +8,39 @@ mkOption types ; - - outputs = mkOption { - type = types.submoduleWith { - modules = [ - { - freeformType = - types.lazyAttrsOf - (types.unique - { - message = '' - No option has been declared for this flake output attribute, so its definitions can't be merged automatically. - Possible solutions: - - Load a module that defines this flake output attribute - - Declare an option for this flake output attribute - - Make sure the output attribute is spelled correctly - - Define the value only once, with a single definition in a single module - ''; - } - types.raw); - } - ]; - }; - description = '' - Raw flake output attributes. Any attribute can be set here, but some - attributes are represented by options, to provide appropriate - configuration merging. - ''; - }; in { options = { - inherit outputs; + outputs = mkOption { + type = types.submoduleWith { + modules = [ + { + freeformType = + types.lazyAttrsOf + (types.unique + { + message = '' + No option has been declared for this flake output attribute, so its definitions can't be merged automatically. + Possible solutions: + - Load a module that defines this flake output attribute + - Declare an option for this flake output attribute + - Make sure the output attribute is spelled correctly + - Define the value only once, with a single definition in a single module + ''; + } + types.raw); + } + ]; + }; + description = '' + Raw flake output attributes. Any attribute can be set here, but some + attributes are represented by options, to provide appropriate + configuration merging. + ''; + }; }; - config = {inherit (config) flake;}; + config = { + # ensure a minimal version is set + outputs = {}; + }; } diff --git a/nix/snow/flake/modules/packages.nix b/nix/snow/flake/modules/packages.nix index 517c758..ef970bc 100644 --- a/nix/snow/flake/modules/packages.nix +++ b/nix/snow/flake/modules/packages.nix @@ -10,7 +10,7 @@ ; inherit - (snow) + (snow.lib) mkPerSystemFlakeOutput ; in diff --git a/nix/snow/flake/nodes/default.nix b/nix/snow/flake/nodes/default.nix index d7b6a82..07ad153 100644 --- a/nix/snow/flake/nodes/default.nix +++ b/nix/snow/flake/nodes/default.nix @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. { - _snow, + _snowFlake, lib, specialArgs, ... @@ -39,7 +39,7 @@ config = { nodes = { - base = _snow.inputs.nixpkgs; + base = _snowFlake.inputs.nixpkgs; }; }; } diff --git a/nix/snow/flake/nodes/groups.nix b/nix/snow/flake/nodes/groups.nix deleted file mode 100644 index b22cac0..0000000 --- a/nix/snow/flake/nodes/groups.nix +++ /dev/null @@ -1,73 +0,0 @@ -# # Copyright 2025-2026 _cry64 (Emile Clark-Boman) -# # -# # Licensed under the Apache License, Version 2.0 (the "License"); -# # you may not use this file except in compliance with the License. -# # You may obtain a copy of the License at -# # -# # http://www.apache.org/licenses/LICENSE-2.0 -# # -# # Unless required by applicable law or agreed to in writing, software -# # distributed under the License is distributed on an "AS IS" BASIS, -# # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# # See the License for the specific language governing permissions and -# # limitations under the License. -{nt, ...}: let - inherit - (builtins) - concatLists - elem - filter - isAttrs - mapAttrs - pathExists - typeOf - ; - - rootGroupName = "all"; -in { - parseGroupsDecl = groups: let - validGroup = g: - isAttrs g - || throw '' - Snow node groups must be provided as attribute sets, got "${typeOf g}" instead! - Ensure all the group definitions are attribute sets under your call to `snow.flake`. - NOTE: Groups can be accessed via `self.groups.PATH.TO.YOUR.GROUP` - ''; - delegate = parent: gName: g: let - result = - (g - // { - _name = gName; - _parent = parent; - }) - |> mapAttrs (name: value: - if elem name ["_name" "_parent"] - # ignore metadata fields - then value - else assert validGroup value; (delegate result name value)); - in - result; - in - assert validGroup groups; - delegate null rootGroupName groups; - - getGroupModules = root: groups: - # ensure root group is always added - groups - # add all inherited groups via _parent - |> map (let - delegate = g: - if g._parent == null - then [g] - else [g] ++ delegate (g._parent); - in - delegate) - # flatten recursion result - |> concatLists - # find import location - |> map (group: nt.findImport /${root}/groups/${group._name}) - # filter by uniqueness - |> nt.prim.unique - # ignore missing groups - |> filter pathExists; -} diff --git a/nix/snow/flake/nodes/node.nix b/nix/snow/flake/nodes/node.nix index a368d24..11c2b98 100644 --- a/nix/snow/flake/nodes/node.nix +++ b/nix/snow/flake/nodes/node.nix @@ -14,8 +14,9 @@ { lib, systems, - config, nodesConfig, + groups, + groupLibs, ... }: { options = let @@ -25,6 +26,11 @@ types ; + inherit + (groupLibs) + resolveGroupsInheritance + ; + flakeRef = types.either types.str types.path; in { enabled = lib.mkOption { @@ -113,8 +119,8 @@ A function from the `groups` hierarchy to a list of groups this node inherits from. ''; - apply = groupsFn: - groupsFn nodesConfig.groups; + # apply = groupsFn: + # groupsFn nodesConfig.groups |> resolveGroupsInheritance; }; deploy = { @@ -266,32 +272,32 @@ }; }; - config = let - throwGotNull = name: - throw '' - [snow] `nodes..${name}` must be set for all nodes! (got: ) - ''; - givenSystem = - (config.system != null) - || throwGotNull "system"; + # config = let + # throwGotNull = name: + # throw '' + # [snow] `nodes..${name}` must be set for all nodes! (got: ) + # ''; + # givenSystem = + # (config.system != null) + # || throwGotNull "system"; - givenBase = - (config.base != null) - || throwGotNull "base"; + # givenBase = + # (config.base != null) + # || throwGotNull "base"; - givenHomeManager = - (config.homeManager != null) - || throwGotNull "homeManager"; + # givenHomeManager = + # (config.homeManager != null) + # || throwGotNull "homeManager"; - givenDeployHost = - (config.deploy.ssh.host != null) - || throwGotNull "deploy.ssh.host"; - in - assert givenSystem - && givenBase - && givenHomeManager - && givenDeployHost; { - # extend these from the nodes configuration - inherit (nodesConfig) modules args; - }; + # givenDeployHost = + # (config.deploy.ssh.host != null) + # || throwGotNull "deploy.ssh.host"; + # in + # assert givenSystem + # && givenBase + # && givenHomeManager + # && givenDeployHost; { + # # extend these from the nodes configuration + # inherit (nodesConfig) modules args; + # }; } diff --git a/nix/snow/flake/nodes/nodes.nix b/nix/snow/flake/nodes/nodes.nix index 58a9e1a..d5e5a59 100644 --- a/nix/snow/flake/nodes/nodes.nix +++ b/nix/snow/flake/nodes/nodes.nix @@ -12,7 +12,9 @@ # See the License for the specific language governing permissions and # limitations under the License. { - _snow, + _snowFlake, + snow, + root, lib, config, specialArgs, @@ -26,7 +28,10 @@ flakeRef = types.either types.str types.path; - groupLibs = import ./groups.nix {inherit (_snow.inputs) nt;}; + groupLibs = import ./groups.nix { + inherit snow root; + inherit (_snowFlake.inputs) nt; + }; in { options = { base = lib.mkOption { @@ -94,8 +99,6 @@ in { description = '' Hierarchical groups that nodes can be a member of. ''; - - apply = groupLibs.parseGroupsDecl; }; nodes = mkOption { @@ -103,7 +106,8 @@ in { specialArgs = specialArgs // { - nodeConfig = config; + nodesConfig = config; + inherit groupLibs; }; modules = [./node.nix]; }); diff --git a/nix/snow/flake/outputs/checks.nix b/nix/snow/flake/outputs/checks.nix index a25ba32..de6a9c0 100644 --- a/nix/snow/flake/outputs/checks.nix +++ b/nix/snow/flake/outputs/checks.nix @@ -1,10 +1,10 @@ { config, - _snow, + _snowFlake, ... }: { outputs.checks = - _snow.inputs.deploy-rs.lib + _snowFlake.inputs.deploy-rs.lib |> builtins.mapAttrs (system: deployLib: deployLib.deployChecks config.outputs.deploy); } diff --git a/nix/snow/flake/outputs/default.nix b/nix/snow/flake/outputs/default.nix new file mode 100644 index 0000000..2c0a9ca --- /dev/null +++ b/nix/snow/flake/outputs/default.nix @@ -0,0 +1,7 @@ +{...}: { + imports = [ + ./checks.nix + ./deploy.nix + ./nixosConfigurations.nix + ]; +} diff --git a/nix/snow/flake/outputs/deploy.nix b/nix/snow/flake/outputs/deploy.nix index c8d39a9..59bbb49 100644 --- a/nix/snow/flake/outputs/deploy.nix +++ b/nix/snow/flake/outputs/deploy.nix @@ -1,37 +1,10 @@ { - _snow, + _snowFlake, + snow, config, ... -}: let - inherit - (builtins) - mapAttrs - ; - - mapNodes = nodes: f: - nodes.nodes - |> mapAttrs (name: node: let - # use per-node base or default to nodes' base - base = - if node.base != null - then node.base - else if nodes.base != null - then nodes.base - else - abort '' - snow cannot construct nodes node "${name}" without a base package source. - Ensure `nodes.nodes.*.base` or `nodes.base` is a flake reference to the github:NixOS/nixpkgs repository. - ''; - in - f rec { - inherit name node base; - inherit (base) lib; - - groups = node.groups (parseGroupsDecl nodes.groups); - groupModules = root: getGroupModules root groups; - }); -in { - outputs.deploy.nodes = mapNodes config.nodes ({ +}: { + outputs.deploy.nodes = snow.lib.mapNodes config.nodes ({ name, node, ... @@ -49,7 +22,7 @@ in { confirmTimeout ; - nixosFor = system: _snow.inputs.deploy-rs.lib.${system}.activate.nixos; + nixosFor = system: _snowFlake.inputs.deploy-rs.lib.${system}.activate.nixos; in { hostname = if ssh.host != null diff --git a/nix/snow/flake/outputs/nixosConfigurations.nix b/nix/snow/flake/outputs/nixosConfigurations.nix index 2ca88b6..977fa22 100644 --- a/nix/snow/flake/outputs/nixosConfigurations.nix +++ b/nix/snow/flake/outputs/nixosConfigurations.nix @@ -1,14 +1,5 @@ -# { -# _module = { ... }; -# _type = "configuration"; -# class = null; -# config = { ... }; -# extendModules = «lambda extendModules @ /nix/store/9hfp0agnm43kz72l5lpfn9var5p0x2fa-source/lib/modules.nix:340:9»; -# graph = [ ... ]; -# options = { ... }; -# type = { ... }; -# } { + _snowFlake, snow, config, systems, @@ -27,59 +18,67 @@ nodes ; in { - outputs.nixosConfigurations = mapNodes nodes ( - { - base, - lib, - name, - node, - groupModules, - ... - }: let - homeManager = - if node.homeManager != null - then node.homeManager - else if nodes.homeManager != null - then nodes.homeManager - else - warn '' - [snowflake] Neither `nodes.homeManager` nor `nodes.nodes.${name}.homeManager` were specified! - [snowflake] home-manager will NOT be used! User configuration will be ignored! - '' - null; + outputs.nixosConfigurations = let + groups = snow.lib.parseGroupDecls root config.nodes.groups; + in + snow.lib.mapNodes nodes ( + { + base, + lib, + name, + node, + ... + }: let + nodeGroups = + (node.groups groups) + |> snow.lib.resolveGroupsInheritance + |> snow.lib.groupModules; - userArgs = nodes.args // node.args; - snowArgs = { - inherit systems snow root base nodes node; - inherit (node) system; - hostname = name; + homeManager = + if node.homeManager != null + then node.homeManager + else if nodes.homeManager != null + then nodes.homeManager + else + warn '' + [snowflake] Neither `nodes.homeManager` nor `nodes.nodes.${name}.homeManager` were specified! + [snowflake] home-manager will NOT be used! User configuration will be ignored! + '' + null; - _snow = { - inherit inputs userArgs snowArgs homeManager; - specialArgs = userArgs // snowArgs; + userArgs = nodes.args // node.args; + snowArgs = { + inherit systems snow root base nodes node; + inherit (node) system; + hostname = name; + + _snow = { + inherit (_snowFlake) inputs; + inherit userArgs snowArgs homeManager; + specialArgs = userArgs // snowArgs; + }; }; - }; - specialArgs = assert (userArgs - |> attrNames - |> all (argName: - ! snowArgs ? argName - || abort '' - `specialArgs` are like super important to Snow my love... attrNames + |> all (argName: + ! snowArgs ? argName + || abort '' + `specialArgs` are like super important to Snow my love... = 0) || abort '' The nixpkgs dependency of snow was overridden but is too old. The minimum supported version of nixpkgs-lib is ${minVersion}, diff --git a/nix/snow/lib/nodes.nix b/nix/snow/lib/nodes.nix new file mode 100644 index 0000000..6f799cf --- /dev/null +++ b/nix/snow/lib/nodes.nix @@ -0,0 +1,87 @@ +{ + this, + nt, + ... +}: let + inherit + (builtins) + concatLists + elem + filter + isAttrs + mapAttrs + pathExists + typeOf + ; + + inherit (nt.prim) uniq; + + rootGroupName = "all"; +in { + mapNodes = nodes: f: + nodes.nodes + |> mapAttrs (name: node: let + # use per-node base or default to nodes' base + base = + if node.base != null + then node.base + else if nodes.base != null + then nodes.base + else + abort '' + snow cannot construct nodes node "${name}" without a base package source. + Ensure `nodes.nodes.*.base` or `nodes.base` is a flake reference to the github:NixOS/nixpkgs repository. + ''; + in + f rec { + inherit name node base; + inherit (base) lib; + + inherit (node) groups; + }); + + groupModules = map (group: group._module); + + parseGroupDecls = root: groupDecls: let + validGroup = g: + isAttrs g + || throw '' + Snow node groups must be provided as attribute sets, got "${typeOf g}" instead! + Ensure all the group definitions are attribute sets under your call to `snow.flake`. + ''; + delegate = parent: gName: g: let + result = + (g + // { + _name = gName; + _parent = parent; + _module = this.lib.findImport /${root}/groups/${gName}; + }) + |> mapAttrs (name: value: + if elem name ["_name" "_parent" "_module"] + # ignore metadata fields + then value + else assert validGroup value; (delegate result name value)); + in + result; + in + assert validGroup groupDecls; + delegate null rootGroupName groupDecls; + + resolveGroupsInheritance = groups: + groups + # add all inherited groups via _parent + |> map (let + delegate = g: + if g._parent == null + then [g] + else [g] ++ delegate (g._parent); + in + delegate) + # flatten recursion result + |> concatLists + # ignore missing groups + |> filter (group: pathExists group._module) + # filter by uniqueness + |> uniq; +} diff --git a/nix/snow/lib/util.nix b/nix/snow/lib/util.nix new file mode 100644 index 0000000..6bfcd17 --- /dev/null +++ b/nix/snow/lib/util.nix @@ -0,0 +1,3 @@ +{nt, ...}: { + inherit (nt) findImport; +}