deployment/data-model-test.nix

@@ -99,11 +99,12 @@ in
                     {
                       options.enable = lib.mkEnableOption "Hello in the shell";
                     };
-                  implementation =
-                    cfg:
-                    lib.optionalAttrs cfg.enable {
+                  implementation = cfg: {
+                    input = cfg;
+                    output = lib.optionalAttrs cfg.enable {
                       resources.hello.login-shell.packages.hello = pkgs.hello;
                     };
+                  };
                 };
               environments.single-nixos-vm =
                 { config, ... }:
@@ -151,7 +152,7 @@ in
             };
           }
         );
-        resources = fediversity.applications.hello.implementation fediversity.example-configuration.applications.hello;
+        resources = fediversity.applications.hello.resources fediversity.example-configuration.applications.hello;
         hello-shell = resources.resources.hello.login-shell;
         environment = fediversity.environments.single-nixos-vm.resources.operator-environment.login-shell;
         result = mkDeployment {

deployment/data-model.nix

@@ -15,6 +15,7 @@ let
     functionTo
     ;
 
+  functionType = import ./function.nix;
   application-resources = submodule {
     options.resources = mkOption {
       # TODO: maybe transpose, and group the resources by type instead
@@ -84,24 +85,41 @@ in
     };
     applications = mkOption {
       description = "Collection of Fediversity applications";
-      type = attrsOf (submodule {
-        _class = "fediversity-application";
-        options = {
-          description = mkOption {
-            description = "Description to be shown in the application overview";
-            type = types.str;
+      type = attrsOf (
+        submodule (application: {
+          _class = "fediversity-application";
+          options = {
+            description = mkOption {
+              description = "Description to be shown in the application overview";
+              type = types.str;
+            };
+            module = mkOption {
+              description = "Operator-facing configuration options for the application";
+              type = deferredModuleWith { staticModules = [ { _class = "fediversity-application-config"; } ]; };
+            };
+            implementation = mkOption {
+              description = "Mapping of application configuration to deployment resources, a description of what an application needs to run";
+              type = application.config.config-mapping.function-type;
+            };
+            resources = mkOption {
+              description = "Compute resources required by an application";
+              type = functionTo application.config.config-mapping.output-type;
+              readOnly = true;
+              default = input: (application.config.implementation input).output;
+            };
+            # TODO(@fricklerhandwerk): this needs a better name, it's just the type
+            config-mapping = mkOption {
+              description = "Function type for the mapping from application configuration to required resources";
+              type = submodule functionType;
+              readOnly = true;
+              default = {
+                input-type = submodule application.config.module;
+                output-type = application-resources;
+              };
+            };
           };
-          module = mkOption {
-            description = "Operator-facing configuration options for the application";
-            type = deferredModuleWith { staticModules = [ { _class = "fediversity-application-config"; } ]; };
-          };
-          implementation = mkOption {
-            description = "Mapping of application configuration to deployment resources required by an application";
-            # input: submodule application.config.module
-            type = functionTo application-resources;
-          };
-        };
-      });
+        })
+      );
     };
     environments = mkOption {
       description = "Run-time environments for Fediversity applications to be deployed to";
@@ -123,16 +141,24 @@ in
               );
             };
             implementation = mkOption {
-              description = "Mapping from resources required by applications to available resources to a deployment";
-              # input: application-resources
-              type = functionTo nixops4Deployment;
+              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;
+              };
             };
             # TODO(@fricklerhandwerk): maybe this should be a separate thing such as `fediversity-setup`,
             # which makes explicit which applications and environments are available.
             # then the deployments can simply be the result of the function application baked into this module.
             deployment = mkOption {
               description = "Generate a deployment from a configuration, by applying an environment's resource policies to the applications' resource mappings";
-              type = functionTo nixops4Deployment;
+              type = functionTo (environment.config.resource-mapping.output-type);
               readOnly = true;
               default =
                 cfg:

deployment/function.nix

@@ -0,0 +1,36 @@
+/**
+  Modular function type
+*/
+{ config, lib, ... }:
+let
+  inherit (lib) mkOption types;
+  inherit (types)
+    submodule
+    functionTo
+    optionType
+    ;
+in
+{
+  options = {
+    input-type = mkOption {
+      type = optionType;
+    };
+    output-type = mkOption {
+      type = optionType;
+    };
+    function-type = mkOption {
+      type = optionType;
+      readOnly = true;
+      default = functionTo (submodule {
+        options = {
+          input = mkOption {
+            type = config.input-type;
+          };
+          output = mkOption {
+            type = config.output-type;
+          };
+        };
+      });
+    };
+  };
+}