deployment/data-model-test.nix

@@ -22,7 +22,6 @@ in
         fediversity = eval (
           { config, ... }:
           {
-            _class = "fediversity-settings";
             config = {
               resources.nixos-configuration = {
                 description = "An entire NixOS configuration";
@@ -52,7 +51,6 @@ in
                   };
               };
               resources.login-shell = {
-                _class = "fediversity-resource";
                 description = "The operator needs to be able to log into the shell";
                 request =
                   { ... }:
@@ -106,12 +104,10 @@ in
               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";
                       };
@@ -119,25 +115,21 @@ 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
@@ -145,7 +137,6 @@ in
                         nixos.module =
                           { ... }:
                           {
-                            _class = "nixos";
                             users.users = config.resources.shell.login-shell.apply (
                               lib.filterAttrs (_name: value: value ? login-shell) requests
                             );
@@ -159,16 +150,12 @@ in
                 type = config.configuration;
                 readOnly = true;
                 default = {
-                  _class = "fediversity-configuration";
                   enable = true;
                   applications.hello.enable = true;
                 };
               };
               example-deployment = mkOption {
-                type = types.submoduleWith {
+                type = types.submodule nixops4Deployment;
-                  class = "nixops4Deployment";
-                  modules = [ nixops4Deployment ];
-                };
                 readOnly = true;
                 default = config.environments.single-nixos-vm.deployment config.example-configuration;
               };

deployment/data-model.nix

@@ -10,14 +10,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 (
@@ -28,179 +27,147 @@ let
   nixops4Deployment = inputs.nixops4.modules.nixops4Deployment.default;
 in
 {
-  _class = "fediversity-settings";
   options = {
     resources = mkOption {
       description = "Collection of deployment resources that can be required by applications and policed by hosting providers";
-      type = attrsOf (submoduleWith {
+      type = attrsOf (
-        class = "fediversity-resource";
+        submodule (
-        modules = [
+          { ... }:
-          (
+          {
-            { ... }:
+            _class = "fediversity-resource";
-            {
+            options = {
-              options = {
+              description = mkOption {
-                description = mkOption {
+                description = "Description of the resource to help application module authors and hosting providers to work with it";
-                  description = "Description of the resource to help application module authors and hosting providers to work with it";
+                type = types.str;
-                  type = types.str;
+              };
-                };
+              request = mkOption {
-                request = mkOption {
+                description = "Options for declaring resource requirements by an application, a description of how the resource is consumed or accessed";
-                  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"; } ]; };
-                  type = deferredModuleWith { staticModules = [ { _class = "fediversity-resource-request"; } ]; };
+              };
-                };
+              policy = mkOption {
-                policy = mkOption {
+                description = "Options for configuring the resource policy for the hosting provider, a description of how the resource is made available";
-                  description = "Options for configuring the resource policy for the hosting provider, a description of how the resource is made available";
+                type = deferredModuleWith {
-                  type = submoduleWith {
+                  staticModules = [
-                    class = "fediversity-resource-policy";
+                    {
-                    modules = [
+                      _class = "fediversity-resource-policy";
-                      {
+                      options.apply = mkOption {
-                        options.apply = mkOption {
+                        description = "Apply the policy to a request";
-                          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 {
+      type = attrsOf (
-        class = "fediversity-environment";
+        submodule (environment: {
-        modules = [
+          _class = "fediversity-environment";
-          (environment: {
+          options = {
-            options = {
+            resources = mkOption {
-              resources = mkOption {
+              description = ''
-                description = ''
+                Resources made available by the hosting provider, and their policies.
-                  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 = "fediversity-deployment";
-                  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;
 
+                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 = submodule 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 = submodule functionType;
+              readOnly = true;
+              default = {
+                input-type = application-resources;
+                output-type = nixops4Deployment;
               };
             };
-          })
+            deployment = mkOption {
-        ];
+              description = "Generate a deployment from a configuration";
-      });
+              type = functionTo (submodule 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;
     };
@@ -23,16 +22,18 @@ in
     function-type = mkOption {
       type = optionType;
       readOnly = true;
-      default = functionTo (submodule {
+      default = functionTo (
-        options = {
+        submodule (function: {
-          input = mkOption {
+          options = {
-            type = submodule config.input-type;
+            input = mkOption {
+              type = submodule config.input-type;
+            };
+            output = mkOption {
+              type = submodule config.output-type;
+            };
           };
-          output = mkOption {
+        })
-            type = submodule config.output-type;
+      );
-          };
-        };
-      });
     };
   };
 }