fix typo

default.nix

@@ -11,7 +11,6 @@ let
     ;
   inherit (pkgs) lib;
   inherit (import sources.flake-inputs) import-flake;
-  inputs = (import-flake { src = ./.; }).inputs;
   inherit ((import-flake { src = ./.; }).inputs) nixops4;
   panel = import ./panel { inherit sources system; };
   pre-commit-check =
@@ -79,7 +78,6 @@ in
   # re-export inputs so they can be overridden granularly
   # (they can't be accessed from the outside any other way)
   inherit
-    inputs
     sources
     system
     pkgs

deployment/data-model-test.nix

@@ -1,119 +1,36 @@
 let
   inherit (import ../default.nix { }) pkgs inputs;
   inherit (pkgs) lib;
-  inherit (lib) mkOption types;
+  inherit (lib) mkOption;
   eval =
     module:
     (lib.evalModules {
       specialArgs = {
         inherit inputs;
-        # to be passed to nixops4Deployment
-        resourceProviderSystem = builtins.currentSystem;
       };
       modules = [
         module
         ./data-model.nix
       ];
     }).config;
-  nixops4Deployment = inputs.nixops4.modules.nixops4Deployment.default;
 in
 {
+  _class = "nix-unit";
+
   test-eval = {
     expr =
       let
         fediversity = eval (
           { config, ... }:
           {
-            _class = "fediversity-settings";
             config = {
-              resources.nixos-configuration = {
-                description = "An entire NixOS configuration";
-                request =
-                  { ... }:
-                  {
-                    _class = "fediversity-resource-request";
-                    options.config = mkOption {
-                      description = "Any options from NixOS";
-                    };
-                  };
-
-                policy =
-                  { config, ... }:
-                  {
-                    _class = "fediversity-resource-policy";
-
-                    options = {
-                      extra-config = mkOption {
-                        description = "Any options from NixOS";
-                      };
-                      apply = mkOption {
-                        type = with types; functionTo raw;
-                        default = requests: lib.mkMerge (requests ++ [ config.extra-config ]);
-                      };
-                    };
-                  };
-              };
-              resources.login-shell = {
-                _class = "fediversity-resource";
-                description = "The operator needs to be able to log into the shell";
-                request =
-                  { ... }:
-                  {
-                    _class = "fediversity-resource-request";
-                    options = {
-                      wheel = mkOption {
-                        description = "Whether the login user needs root permissions";
-                        type = types.bool;
-                        default = false;
-                      };
-                      packages = mkOption {
-                        description = "Packages that need to be available in the user environment";
-                        type = with types; attrsOf package;
-                      };
-                    };
-                  };
-                policy =
-                  { config, ... }:
-                  {
-                    _class = "fediversity-resource-policy";
-                    options = {
-                      username = mkOption {
-                        description = "Username for the operator";
-                        type = types.str; # TODO: use the proper constraints from NixOS
-                      };
-                      wheel = mkOption {
-                        description = "Whether to allow login with root permissions";
-                        type = types.bool;
-                        default = false;
-                      };
-                      apply = mkOption {
-                        type = with types; functionTo raw; # TODO: splice out the user type from NixOS
-                        default =
-                          requests:
-                          let
-                            # Filter out requests that need wheel if policy doesn't allow it
-                            validRequests = lib.filterAttrs (_name: req: !req.wheel || config.wheel) requests;
-                          in
-                          lib.optionalAttrs (validRequests != { }) {
-                            ${config.username} = {
-                              isNormalUser = true;
-                              packages = with lib; concatMapAttrs (_name: request: attrValues request.packages) validRequests;
-                              extraGroups = lib.optional config.wheel "wheel";
-                            };
-                          };
-                      };
-                    };
-                  };
-              };
               applications.hello =
                 { ... }:
                 {
-                  _class = "fediversity-application";
                   description = ''Command-line tool that will print "Hello, world!" on the terminal'';
                   module =
                     { ... }:
                     {
-                      _class = "fediversity-application-config";
                       options = {
                         enable = lib.mkEnableOption "Hello in the shell";
                       };
@@ -121,59 +38,19 @@ in
                   implementation =
                     cfg:
                     lib.optionalAttrs cfg.enable {
-                      _class = "fediversity-application-requirements";
                       dummy.login-shell.packages.hello = pkgs.hello;
                     };
                 };
-              environments.single-nixos-vm =
-                { config, ... }:
-                {
-                  _class = "fediversity-environment";
-                  resources.shell.login-shell.username = "operator";
-                  implementation =
-                    requests:
-                    { providers, ... }:
-                    {
-                      _class = "nixops4Deployment";
-                      providers = {
-                        inherit (inputs.nixops4.modules.nixops4Provider) local;
-                      };
-                      resources.the-machine = {
-                        _class = "nixops4Resource";
-                        type = providers.local.exec;
-                        imports = [
-                          inputs.nixops4-nixos.modules.nixops4Resource.nixos
-                        ];
-                        nixos.module =
-                          { ... }:
-                          {
-                            _class = "nixos";
-                            users.users = config.resources.shell.login-shell.apply (
-                              lib.filterAttrs (_name: value: value ? login-shell) requests
-                            );
-                          };
-                      };
-                    };
-                };
             };
             options = {
               example-configuration = mkOption {
                 type = config.configuration;
                 readOnly = true;
                 default = {
-                  _class = "fediversity-configuration";
                   enable = true;
                   applications.hello.enable = true;
                 };
               };
-              example-deployment = mkOption {
-                type = types.submoduleWith {
-                  class = "nixops4Deployment";
-                  modules = [ nixops4Deployment ];
-                };
-                readOnly = true;
-                default = config.environments.single-nixos-vm.deployment config.example-configuration;
-              };
             };
           }
         );
@@ -182,14 +59,12 @@ in
         inherit (fediversity)
           example-configuration
           ;
-        has-deployment = lib.isAttrs fediversity.example-deployment.resources.the-machine;
       };
     expected = {
       example-configuration = {
         enable = true;
         applications.hello.enable = true;
       };
-      has-deployment = true;
     };
   };
 }

deployment/data-model.nix

@@ -1,7 +1,6 @@
 {
   lib,
   config,
-  inputs,
   ...
 }:
 let
@@ -10,14 +9,13 @@ let
     attrsOf
     attrTag
     deferredModuleWith
-    submoduleWith
+    submodule
     optionType
     functionTo
     ;
 
   functionType = import ./function.nix;
-  application-requirements = {
+  application-resources = {
-    _class = "fediversity-application-requirements";
     options.resources = mkOption {
       # TODO: maybe transpose, and group the resources by type instead
       type = attrsOf (
@@ -25,182 +23,66 @@ let
       );
     };
   };
-  nixops4Deployment = inputs.nixops4.modules.nixops4Deployment.default;
 in
 {
-  _class = "fediversity-settings";
+  _class = "nixops4Deployment";
+
   options = {
-    resources = mkOption {
-      description = "Collection of deployment resources that can be required by applications and policed by hosting providers";
-      type = attrsOf (submoduleWith {
-        class = "fediversity-resource";
-        modules = [
-          (
-            { ... }:
-            {
-              options = {
-                description = mkOption {
-                  description = "Description of the resource to help application module authors and hosting providers to work with it";
-                  type = types.str;
-                };
-                request = mkOption {
-                  description = "Options for declaring resource requirements by an application, a description of how the resource is consumed or accessed";
-                  type = deferredModuleWith { staticModules = [ { _class = "fediversity-resource-request"; } ]; };
-                };
-                policy = mkOption {
-                  description = "Options for configuring the resource policy for the hosting provider, a description of how the resource is made available";
-                  type = submoduleWith {
-                    class = "fediversity-resource-policy";
-                    modules = [
-                      {
-                        options.apply = mkOption {
-                          description = "Apply the policy to a request";
-                        };
-                      }
-                    ];
-                  };
-                };
-              };
-            }
-          )
-        ];
-      });
-    };
     applications = mkOption {
       description = "Collection of Fediversity applications";
-      type = attrsOf (submoduleWith {
+      type = attrsOf (
-        class = "fediversity-application";
+        submodule (application: {
-        modules = [
+          _class = "fediversity-application";
-          (application: {
+          options = {
-            options = {
+            description = mkOption {
-              description = mkOption {
+              description = "Description to be shown in the application overview";
-                description = "Description to be shown in the application overview";
+              type = types.str;
-                type = types.str;
+            };
-              };
+            module = mkOption {
-              module = mkOption {
+              description = "Operator-facing configuration options for the application";
-                description = "Operator-facing configuration options for the application";
+              type = deferredModuleWith { staticModules = [ { _class = "fediversity-application-config"; } ]; };
-                type = deferredModuleWith { staticModules = [ { _class = "fediversity-application-config"; } ]; };
+            };
-              };
+            implementation = mkOption {
-              implementation = mkOption {
+              description = "Mapping of application configuration to deployment resources, a description of what an application needs to run";
-                description = "Mapping of application configuration to deployment resources, a description of what an application needs to run";
+              type = application.config.config-mapping.function-type;
-                type = application.config.config-mapping.function-type;
+            };
-              };
+            resources = mkOption {
-              resources = mkOption {
+              description = "Compute resources required by an application";
-                description = "Compute resources required by an application";
+              type = functionTo application.config.config-mapping.output-type;
-                type = functionTo application.config.config-mapping.output-type;
+              readOnly = true;
-                readOnly = true;
+              default = input: (application.config.implementation input).output;
-                default = input: (application.config.implementation input).output;
+            };
-              };
+            config-mapping = mkOption {
-              config-mapping = mkOption {
+              description = "Function type for the mapping from application configuration to required resources";
-                description = "Function type for the mapping from application configuration to required resources";
+              type = submodule functionType;
-                type = submoduleWith {
+              readOnly = true;
-                  class = "module-function";
+              default = {
-                  modules = [ functionType ];
+                input-type = application.config.module;
-                };
+                output-type = application-resources;
-                readOnly = true;
-                default = {
-                  input-type = application.config.module;
-                  output-type = application-requirements;
-                };
               };
             };
-          })
+          };
-        ];
+        })
-      });
+      );
-    };
-    environments = mkOption {
-      description = "Run-time environments for Fediversity applications to be deployed to";
-      type = attrsOf (submoduleWith {
-        class = "fediversity-environment";
-        modules = [
-          (environment: {
-            options = {
-              resources = mkOption {
-                description = ''
-                  Resources made available by the hosting provider, and their policies.
-
-                  Setting this is optional, but provides a place to declare that information for programmatic use in the resource mapping.
-                '';
-                # TODO: maybe transpose, and group the resources by type instead
-                type = attrsOf (
-                  attrTag (
-                    lib.mapAttrs (
-                      _name: resource:
-                      mkOption {
-                        type = submoduleWith {
-                          class = "fediversity-resource-policy";
-                          modules = [ resource.policy ];
-                        };
-                      }
-                    ) config.resources
-                  )
-                );
-              };
-              implementation = mkOption {
-                description = "Mapping of resources required by applications to available resources; the result can be deployed";
-                type = environment.config.resource-mapping.function-type;
-              };
-              resource-mapping = mkOption {
-                description = "Function type for the mapping from resources to a (NixOps4) deployment";
-                type = submoduleWith {
-                  class = "module-function";
-                  modules = [ functionType ];
-                };
-                readOnly = true;
-                default = {
-                  input-type = application-requirements;
-                  output-type = nixops4Deployment;
-                };
-              };
-              deployment = mkOption {
-                description = "Generate a deployment from a configuration";
-                type = functionTo (submoduleWith {
-                  class = "nixops4Deployment";
-                  modules = [ environment.config.resource-mapping.output-type ];
-                });
-                readOnly = true;
-                default =
-                  cfg:
-                  # TODO: check cfg.enable.true
-                  let
-                    required-resources = lib.mapAttrs (
-                      name: application-settings: config.applications.${name}.resources application-settings
-                    ) cfg.applications;
-                  in
-                  (environment.config.implementation required-resources).output;
-
-              };
-            };
-          })
-        ];
-      });
     };
     configuration = mkOption {
       description = "Configuration type declaring options to be set by operators";
       type = optionType;
       readOnly = true;
-      default = submoduleWith {
+      default = submodule {
-        class = "fediversity-configuration";
+        options = {
-        modules = [
+          enable = lib.mkEnableOption {
-          {
+            description = "your Fediversity configuration";
-            options = {
+          };
-              enable = lib.mkEnableOption {
+          applications = lib.mapAttrs (
-                description = "your Fediversity configuration";
+            _name: application:
-              };
+            mkOption {
-              applications = lib.mapAttrs (
+              description = application.description;
-                _name: application:
+              type = submodule application.module;
-                mkOption {
+              default = { };
-                  description = application.description;
+            }
-                  type = submoduleWith {
+          ) config.applications;
-                    class = "fediversity-application-config";
+        };
-                    modules = [ application.module ];
-                  };
-                  default = { };
-                }
-              ) config.applications;
-            };
-          }
-        ];
       };
     };
   };

deployment/function.nix

@@ -13,7 +13,6 @@ let
 in
 {
   options = {
-    _class = "module-function";
     input-type = mkOption {
       type = deferredModule;
     };