flake-parts/setups: move default specialArgs and modules to own

flake-parts module

configs/flake-parts/default.nix

@@ -4,8 +4,13 @@
     ./packages.nix
     ./templates.nix
 
+    # Here's where the shared setup configurations for this entire cluster came
+    # from.
+    ./setups.nix
+
     # Environment configurations.
     ./disko.nix
+    ./flake-parts.nix
     ./home-manager.nix
     ./nixos.nix
     ./nixvim.nix

configs/flake-parts/flake-parts.nix

@@ -0,0 +1,13 @@
+# This is simply to make using my flake modules a bit easier for my private
+# configurations.
+{ config, lib, ... }:
+
+{
+  flake.flakeModules = {
+    default = ../../modules/flake-parts;
+
+    # A little module to make it convenient for setting up the baseline of all
+    # of the configurations.
+    baseSetupsConfig = ./setups.nix;
+  };
+}

configs/flake-parts/setups.nix

@@ -0,0 +1,53 @@
+# The baseline configuration for all of the setup type in this cluster. Take
+# note this is also exported as a flake-parts module to be easily used in
+# private configurations.
+{ lib, ... }:
+
+let
+  homeManagerModules = ../../modules/home-manager;
+  nixosModules = ../../modules/nixos;
+  nixvimModules = ../../modules/nixvim;
+  wrapperManagerModules = ../../modules/wrapper-manager;
+in {
+  setups.home-manager = {
+    sharedSpecialArgs = {
+      foodogsquaredModulesPath = builtins.toString homeManagerModules;
+    };
+    sharedModules = [
+      homeManagerModules
+      ../../modules/home-manager/_private
+    ];
+  };
+
+  setups.nixos = {
+    sharedSpecialArgs = {
+      foodogsquaredUtils =
+        import ../../lib/utils/nixos.nix { inherit lib; };
+        foodogsquaredModulesPath = builtins.toString nixosModules;
+    };
+    sharedModules = [
+      nixosModules
+      ../../modules/nixos/_private
+    ];
+  };
+
+  setups.nixvim = {
+    sharedSpecialArgs = {
+      foodogsquaredModulesPath = builtins.toString nixvimModules;
+    };
+    sharedModules = [
+      nixvimModules
+      ../../modules/nixvim/_private
+    ];
+  };
+
+  setups.wrapper-manager = {
+    sharedSpecialArgs = {
+      foodogsquaredModulesPath = builtins.toString wrapperManagerModules;
+    };
+    sharedModules = [
+      wrapperManagerModules
+      ../../modules/wrapper-manager/_private
+    ];
+  };
+}

modules/flake-parts/setups/home-manager.nix

@@ -6,17 +6,13 @@
 let
   cfg = config.setups.home-manager;
   partsConfig = config;
-  homeManagerModules = ../../home-manager;
 
   # A thin wrapper around the home-manager configuration function.
   mkHome = { pkgs, lib ? pkgs.lib, system, homeManagerBranch ? "home-manager"
     , extraModules ? [ ], specialArgs ? { } }:
     inputs.${homeManagerBranch}.lib.homeManagerConfiguration {
-      extraSpecialArgs = specialArgs // {
-        foodogsquaredModulesPath = builtins.toString homeManagerModules;
-      };
-
       inherit pkgs lib;
+      extraSpecialArgs = specialArgs;
       modules = extraModules;
     };
 
@@ -219,6 +215,8 @@ in {
               config = let
                 hmUserConfig = partsConfig.setups.home-manager.configs.${name};
               in {
+                # The rationale for this is we're making sure that it is
+                # synced with the NixOS user settings.
                 userConfig = {
                   isNormalUser = lib.mkDefault true;
                   createHome = lib.mkDefault true;
@@ -348,64 +346,60 @@ in {
       ]);
   };
 
-  config = lib.mkIf (cfg.configs != { }) {
+  config = lib.mkMerge [
-    setups.home-manager.sharedNixpkgsConfig = config.setups.sharedNixpkgsConfig;
+    {
+      setups.home-manager.sharedNixpkgsConfig = config.setups.sharedNixpkgsConfig;
+    }
 
-    # Import our own home-manager modules.
+    (lib.mkIf (cfg.configs != { }) {
-    setups.home-manager.sharedModules = [
+      flake = let
-      homeManagerModules
+        # A quick data structure we can pass through multiple build pipelines.
+        pureHomeManagerConfigs = let
+          generatePureConfigs = username: metadata:
+            lib.listToAttrs (builtins.map (system:
+              let
+                nixpkgs = inputs.${metadata.nixpkgs.branch};
 
-      # Import our private modules...
+                # We won't apply the overlays here since it is set
-      ../../home-manager/_private
+                # modularly.
-    ];
+                pkgs = import nixpkgs {
+                  inherit system;
+                  inherit (metadata.nixpkgs) config;
+                };
+              in lib.nameValuePair system (mkHome {
+                inherit pkgs system;
+                inherit (metadata) homeManagerBranch;
+                extraModules = cfg.sharedModules ++ cfg.standaloneConfigModules
+                  ++ metadata.modules;
+              })) metadata.systems);
+        in lib.mapAttrs generatePureConfigs cfg.configs;
+      in {
+        homeConfigurations = let
+          renameSystems = name: system: config:
+            lib.nameValuePair "${name}-${system}" config;
+        in lib.concatMapAttrs
+        (name: configs: lib.mapAttrs' (renameSystems name) configs)
+        pureHomeManagerConfigs;
 
-    flake = let
+        deploy.nodes = let
-      # A quick data structure we can pass through multiple build pipelines.
+          validConfigs =
-      pureHomeManagerConfigs = let
+            lib.filterAttrs (name: _: cfg.configs.${name}.deploy != null)
-        generatePureConfigs = username: metadata:
+            pureHomeManagerConfigs;
-          lib.listToAttrs (builtins.map (system:
-            let
-              nixpkgs = inputs.${metadata.nixpkgs.branch};
 
-              # We won't apply the overlays here since it is set
+          generateDeployNode = name: system: config:
-              # modularly.
+            lib.nameValuePair "home-manager-${name}-${system}" (let
-              pkgs = import nixpkgs {
+              deployConfig = cfg.configs.${name}.deploy;
-                inherit system;
+              deployConfig' =
-                inherit (metadata.nixpkgs) config;
+                lib.attrsets.removeAttrs deployConfig [ "profiles" ];
+            in deployConfig' // {
+              profiles = cfg.configs.${name}.deploy.profiles {
+                inherit name config system;
               };
-            in lib.nameValuePair system (mkHome {
+            });
-              inherit pkgs system;
+        in lib.concatMapAttrs
-              inherit (metadata) homeManagerBranch;
+        (name: configs: lib.mapAttrs' (generateDeployNode name) configs)
-              extraModules = cfg.sharedModules ++ cfg.standaloneConfigModules
+        validConfigs;
-                ++ metadata.modules;
+      };
-            })) metadata.systems);
+    })
-      in lib.mapAttrs generatePureConfigs cfg.configs;
+  ];
-    in {
-      homeConfigurations = let
-        renameSystems = name: system: config:
-          lib.nameValuePair "${name}-${system}" config;
-      in lib.concatMapAttrs
-      (name: configs: lib.mapAttrs' (renameSystems name) configs)
-      pureHomeManagerConfigs;
-
-      deploy.nodes = let
-        validConfigs =
-          lib.filterAttrs (name: _: cfg.configs.${name}.deploy != null)
-          pureHomeManagerConfigs;
-
-        generateDeployNode = name: system: config:
-          lib.nameValuePair "home-manager-${name}-${system}" (let
-            deployConfig = cfg.configs.${name}.deploy;
-            deployConfig' =
-              lib.attrsets.removeAttrs deployConfig [ "profiles" ];
-          in deployConfig' // {
-            profiles = cfg.configs.${name}.deploy.profiles {
-              inherit name config system;
-            };
-          });
-      in lib.concatMapAttrs
-      (name: configs: lib.mapAttrs' (generateDeployNode name) configs)
-      validConfigs;
-    };
-  };
 }

modules/flake-parts/setups/nixos.nix

@@ -7,7 +7,6 @@
 let
   cfg = config.setups.nixos;
   partsConfig = config;
-  nixosModules = ../../nixos;
 
   # A thin wrapper around the NixOS configuration function.
   mkHost =
@@ -17,12 +16,7 @@ let
       # on nixpkgs.lib.nixosSystem flake output.
       nixosSystem = args: import "${pkgs.path}/nixos/lib/eval-config.nix" args;
     in (lib.makeOverridable nixosSystem) {
-      inherit pkgs;
+      inherit pkgs specialArgs;
-      specialArgs = specialArgs // {
-        foodogsquaredUtils =
-          import ../../../lib/utils/nixos.nix { inherit lib; };
-        foodogsquaredModulesPath = builtins.toString nixosModules;
-      };
       modules = extraModules
         ++ [{ nixpkgs.hostPlatform = lib.mkForce system; }];
 
@@ -272,88 +266,85 @@ in {
     };
   };
 
-  config = lib.mkIf (cfg.configs != { }) {
+  config = lib.mkMerge [
-    setups.nixos.sharedNixpkgsConfig = config.setups.sharedNixpkgsConfig;
+    {
+      setups.nixos.sharedNixpkgsConfig = config.setups.sharedNixpkgsConfig;
+    }
 
-    setups.nixos.sharedModules = [
+    (lib.mkIf (cfg.configs != { }) {
-      # Import our own public NixOS modules.
-      nixosModules
 
-      # Import our private modules.
+      flake = let
-      ../../nixos/_private
+        # A quick data structure we can pass through multiple build pipelines.
-    ];
+        pureNixosConfigs = let
+          validConfigs =
+            lib.filterAttrs (_: v: v.shouldBePartOfNixOSConfigurations)
+            cfg.configs;
 
-    flake = let
+          generatePureConfigs = hostname: metadata:
-      # A quick data structure we can pass through multiple build pipelines.
+            lib.listToAttrs (builtins.map (system:
-      pureNixosConfigs = let
+              let
-        validConfigs =
+                nixpkgs = inputs.${metadata.nixpkgs.branch};
-          lib.filterAttrs (_: v: v.shouldBePartOfNixOSConfigurations)
-          cfg.configs;
 
-        generatePureConfigs = hostname: metadata:
+                # We won't apply the overlays here since it is set
-          lib.listToAttrs (builtins.map (system:
+                # modularly.
-            let
+                pkgs = import nixpkgs {
-              nixpkgs = inputs.${metadata.nixpkgs.branch};
-
-              # We won't apply the overlays here since it is set
-              # modularly.
-              pkgs = import nixpkgs {
-                inherit system;
-                inherit (metadata.nixpkgs) config;
-              };
-            in lib.nameValuePair system (mkHost {
-              inherit pkgs system;
-              inherit (metadata) specialArgs;
-              extraModules = cfg.sharedModules ++ metadata.modules;
-            })) metadata.systems);
-      in lib.mapAttrs generatePureConfigs validConfigs;
-    in {
-      nixosConfigurations = let
-        renameSystem = name: system: config:
-          lib.nameValuePair "${name}-${system}" config;
-      in lib.concatMapAttrs
-      (name: configs: lib.mapAttrs' (renameSystem name) configs)
-      pureNixosConfigs;
-
-      deploy.nodes = let
-        validConfigs =
-          lib.filterAttrs (name: _: cfg.configs.${name}.deploy != null)
-          pureNixosConfigs;
-
-        generateDeployNode = name: system: config:
-          lib.nameValuePair "nixos-${name}-${system}"
-          (let deployConfig = cfg.configs.${name}.deploy;
-          in deployConfig // {
-            profiles = cfg.configs.${name}.deploy.profiles {
-              inherit name config system;
-            };
-          });
-      in lib.concatMapAttrs
-      (name: configs: lib.mapAttrs' (generateDeployNode name) configs)
-      validConfigs;
-    };
-
-    perSystem = { system, lib, ... }: {
-      images = let
-        validImages = lib.filterAttrs (host: metadata:
-          metadata.formats != null && (lib.elem system metadata.systems))
-          cfg.configs;
-
-        generateImages = name: metadata:
-          let
-            buildImage = format:
-              lib.nameValuePair "${name}-${format}" (mkImage {
-                inherit format system;
-                pkgs = import inputs.${metadata.nixpkgs.branch} {
                   inherit system;
                   inherit (metadata.nixpkgs) config;
                 };
+              in lib.nameValuePair system (mkHost {
+                inherit pkgs system;
+                inherit (metadata) specialArgs;
                 extraModules = cfg.sharedModules ++ metadata.modules;
-              });
+              })) metadata.systems);
+        in lib.mapAttrs generatePureConfigs validConfigs;
+      in {
+        nixosConfigurations = let
+          renameSystem = name: system: config:
+            lib.nameValuePair "${name}-${system}" config;
+        in lib.concatMapAttrs
+        (name: configs: lib.mapAttrs' (renameSystem name) configs)
+        pureNixosConfigs;
 
-            images = builtins.map buildImage metadata.formats;
+        deploy.nodes = let
-          in lib.listToAttrs images;
+          validConfigs =
-      in lib.concatMapAttrs generateImages validImages;
+            lib.filterAttrs (name: _: cfg.configs.${name}.deploy != null)
-    };
+            pureNixosConfigs;
-  };
+
+          generateDeployNode = name: system: config:
+            lib.nameValuePair "nixos-${name}-${system}"
+            (let deployConfig = cfg.configs.${name}.deploy;
+            in deployConfig // {
+              profiles = cfg.configs.${name}.deploy.profiles {
+                inherit name config system;
+              };
+            });
+        in lib.concatMapAttrs
+        (name: configs: lib.mapAttrs' (generateDeployNode name) configs)
+        validConfigs;
+      };
+
+      perSystem = { system, lib, ... }: {
+        images = let
+          validImages = lib.filterAttrs (host: metadata:
+            metadata.formats != null && (lib.elem system metadata.systems))
+            cfg.configs;
+
+          generateImages = name: metadata:
+            let
+              buildImage = format:
+                lib.nameValuePair "${name}-${format}" (mkImage {
+                  inherit format system;
+                  pkgs = import inputs.${metadata.nixpkgs.branch} {
+                    inherit system;
+                    inherit (metadata.nixpkgs) config;
+                  };
+                  extraModules = cfg.sharedModules ++ metadata.modules;
+                });
+
+              images = builtins.map buildImage metadata.formats;
+            in lib.listToAttrs images;
+        in lib.concatMapAttrs generateImages validImages;
+      };
+    })
+];
 }

modules/flake-parts/setups/nixvim.nix

@@ -8,16 +8,13 @@
 let
   partsConfig = config;
   cfg = config.setups.nixvim;
-  nixvimModules = ../../nixvim;
 
   mkNixvimConfig = { system, pkgs, nixvimBranch ? "nixvim", modules ? [ ]
     , specialArgs ? { }, }:
     inputs.${nixvimBranch}.legacyPackages.${system}.makeNixvimWithModule {
       inherit pkgs;
       module = { imports = modules; };
-      extraSpecialArgs = specialArgs // {
+      extraSpecialArgs = specialArgs;
-        foodogsquaredModulesPath = builtins.toString nixvimModules;
-      };
     };
 
   modulesOption = lib.mkOption {
@@ -208,7 +205,7 @@ in {
       attrsOf (submodule [
         nixvimIntegrationModule
         ({ config, lib, ... }: {
-          config.modules =
+          config.modules = lib.optionals (config.nixvim.instance != null)
             [ inputs.${config.nixvim.branch}.nixosModules.nixvim ];
         })
       ]);
@@ -219,59 +216,56 @@ in {
       attrsOf (submodule [
         nixvimIntegrationModule
         ({ config, lib, ... }: {
-          config.modules =
+          config.modules = lib.optionals (config.nixvim.instance != null)
             [ inputs.${config.nixvim.branch}.homeManagerModules.nixvim ];
         })
       ]);
   };
 
-  config = lib.mkIf (cfg.configs != { }) {
+  config = lib.mkMerge [
-    setups.nixvim.sharedNixpkgsConfig = config.setups.sharedNixpkgsConfig;
+    {
+      setups.nixvim.sharedNixpkgsConfig = config.setups.sharedNixpkgsConfig;
+    }
 
-    setups.nixvim.sharedModules = [
+    (lib.mkIf (cfg.configs != { }) {
-      nixvimModules
+      perSystem = { system, config, lib, ... }:
+        (let
+          validConfigs =
+            lib.filterAttrs (_: metadata: lib.elem system metadata.systems)
+            cfg.configs;
 
-      # Import our private modules.
+          nixvimConfigurations = let
-      ../../nixvim/_private
+            generateNixvimConfigs = name: metadata:
-    ];
+              let
+                mkNixvimConfig' = component:
+                  let
+                    pkgs = import inputs.${component.nixpkgsBranch} {
+                      inherit (component.nixpkgs) config overlays;
+                      inherit system;
+                    };
+                    neovimPackage = component.neovimPackage pkgs;
+                  in lib.nameValuePair
+                  "${name}-${component.nixpkgsBranch}-${neovimPackage.pname}"
+                  (mkNixvimConfig {
+                    inherit system pkgs;
+                    inherit (component) nixvimBranch;
+                    modules = cfg.sharedModules ++ cfg.standaloneConfigModules
+                      ++ metadata.modules ++ [{ package = neovimPackage; }];
+                  });
+                nixvimConfigs = builtins.map mkNixvimConfig' metadata.components;
+              in lib.listToAttrs nixvimConfigs;
+          in lib.concatMapAttrs generateNixvimConfigs validConfigs;
+        in {
+          # We'll reuse these.
+          inherit nixvimConfigurations;
 
-    perSystem = { system, config, lib, ... }:
+          checks = lib.mapAttrs' (name: nvim:
-      (let
+            lib.nameValuePair "nixvim-check-${name}"
-        validConfigs =
+            (inputs.nixvim.lib.${system}.check.mkTestDerivationFromNvim {
-          lib.filterAttrs (_: metadata: lib.elem system metadata.systems)
+              inherit nvim;
-          cfg.configs;
+              name = "${name} configuration";
-
+            })) nixvimConfigurations;
-        nixvimConfigurations = let
+        });
-          generateNixvimConfigs = name: metadata:
+    })
-            let
+  ];
-              mkNixvimConfig' = component:
-                let
-                  pkgs = import inputs.${component.nixpkgsBranch} {
-                    inherit (component.nixpkgs) config overlays;
-                    inherit system;
-                  };
-                  neovimPackage = component.neovimPackage pkgs;
-                in lib.nameValuePair
-                "${name}-${component.nixpkgsBranch}-${neovimPackage.pname}"
-                (mkNixvimConfig {
-                  inherit system pkgs;
-                  inherit (component) nixvimBranch;
-                  modules = cfg.sharedModules ++ cfg.standaloneConfigModules
-                    ++ metadata.modules ++ [{ package = neovimPackage; }];
-                });
-              nixvimConfigs = builtins.map mkNixvimConfig' metadata.components;
-            in lib.listToAttrs nixvimConfigs;
-        in lib.concatMapAttrs generateNixvimConfigs validConfigs;
-      in {
-        # We'll reuse these.
-        inherit nixvimConfigurations;
-
-        checks = lib.mapAttrs' (name: nvim:
-          lib.nameValuePair "nixvim-check-${name}"
-          (inputs.nixvim.lib.${system}.check.mkTestDerivationFromNvim {
-            inherit nvim;
-            name = "${name} configuration";
-          })) nixvimConfigurations;
-      });
-  };
 }

modules/flake-parts/setups/shared/config-options.nix

@@ -1,6 +1,6 @@
 { systems }:
 
-{ lib, name, ... }: {
+{ lib, name, config, ... }: {
   options = {
     systems = lib.mkOption {
       type = with lib.types; listOf str;
@@ -54,6 +54,6 @@
   };
 
   config.modules = lib.singleton {
-    _module.args = { inherit (config) firstSetupArgs; }
+    _module.args = { inherit (config) firstSetupArgs; };
   };
 }

modules/flake-parts/setups/wrapper-manager.nix

@@ -156,31 +156,32 @@ in {
       ]);
   };
 
-  config = lib.mkIf (cfg.configs != { }) {
+  config = lib.mkMerge [
-    setups.wrapper-manager.sharedNixpkgsConfig =
+    {
-      config.setups.sharedNixpkgsConfig;
+      setups.wrapper-manager.sharedNixpkgsConfig =
+        config.setups.sharedNixpkgsConfig;
+    }
 
-    setups.wrapper-manager.sharedModules =
+    (lib.mkIf (cfg.configs != { }) {
-      [ ../../wrapper-manager ../../wrapper-manager/_private ];
+      perSystem = { system, config, lib, ... }:
-
+        let
-    perSystem = { system, config, lib, ... }:
+          validWrapperManagerConfigs =
-      let
+            lib.filterAttrs (_: metadata: lib.elem system metadata.systems)
-        validWrapperManagerConfigs =
+            cfg.configs;
-          lib.filterAttrs (_: metadata: lib.elem system metadata.systems)
+        in {
-          cfg.configs;
+          wrapperManagerPackages = lib.mapAttrs (name: metadata:
-      in {
+            let
-        wrapperManagerPackages = lib.mapAttrs (name: metadata:
+              pkgs = import inputs.${metadata.nixpkgs.branch} {
-          let
+                inherit (metadata.nixpkgs) config;
-            pkgs = import inputs.${metadata.nixpkgs.branch} {
+                inherit system;
-              inherit (metadata.nixpkgs) config;
+              };
-              inherit system;
+            in mkWrapperManagerPackage {
-            };
+              inherit pkgs;
-          in mkWrapperManagerPackage {
+              inherit (metadata.wrapper-manager) src;
-            inherit pkgs;
+              modules = cfg.sharedModules ++ cfg.standaloneModules
-            inherit (metadata.wrapper-manager) src;
+                ++ metadata.modules;
-            modules = cfg.sharedModules ++ cfg.standaloneModules
+            }) validWrapperManagerConfigs;
-              ++ metadata.modules;
+        };
-          }) validWrapperManagerConfigs;
+    });
-      };
+  ];
-  };
 }