WIP: implement mappings

turns out we also need a collection of configurations, obviously
next: figure out where to wire everything up to obtain a deployment

deployment/data-model-test.nix

@@ -1,6 +1,7 @@
 let
   inherit (import ../default.nix { }) pkgs inputs;
   inherit (pkgs) lib;
+  inherit (lib) mkOption types;
   eval =
     module:
     (lib.evalModules {
@@ -12,57 +13,53 @@ let
         ./data-model.nix
       ];
     }).config;
+  nixops4Deployment = inputs.nixops4.modules.nixops4Deployment.default;
 in
 {
   test-eval = {
     expr =
       let
-        example = eval (
+        fediversity = eval (
           { config, ... }:
           {
-            providers.single-ssh-host =
-              { ... }:
-              {
-                system.stateVersion = "25.05";
+            config = {
+              resources.nixos = {
+                # TODO: consumer = ?
+                # TODO: provider = ?
               };
-            resources.bar.runtime-environment.single-ssh-host = {
-              ssh = {
-                host = "localhost";
-                username = "root";
-                authentication.password = "";
+              applications.hello = {
+                description = ''Command-line tool that will print "Hello, world!" on the terminal'';
+                # TODO: module = ?
+                # TODO: config=mapping = ?
+              };
+              environments.single-nixos-vm = {
+                # TODO: resources = ?
+                # TODO: resource-mapping = ?
               };
             };
-            applications.foo.module =
-              { pkgs, ... }:
-              {
-                environment.systemPackages = [
-                  pkgs.hello
-                ];
+            options = {
+              example-configuration = mkOption {
+                type = config.configuration;
+                readOnly = true;
+                default = {
+                  enable = true;
+                  applications.hello.enable = true;
                 };
-            deployments.baz = {
-              module = { };
-              runtime-environment = config.resources.bar.runtime-environment;
               };
-            migrations.boo = {
-              deployment = config.deployments.baz;
-              runtime-environment = config.resources.bar.runtime-environment;
+              example-deployment = mkOption {
+                type = nixops4Deployment;
+                readOnly = true;
+                default = config.environments.single-nixos-vm.deployment config.example-configuration;
+              };
             };
           }
         );
       in
       {
-        has-provider = lib.isAttrs example.providers.single-ssh-host;
-        has-resource = lib.isAttrs example.resources.bar.runtime-environment.single-ssh-host.module;
-        has-application = lib.isAttrs example.applications.foo.module;
-        has-deployment = lib.isAttrs example.deployments.baz.module;
-        has-migration = lib.isAttrs example.migrations.boo.deployment;
+
       };
-    expected = {
-      has-provider = true;
-      has-resource = true;
-      has-application = true;
-      has-deployment = true;
-      has-migration = true;
+    expected =
+      {
       };
   };
 }

deployment/data-model.nix

@@ -5,19 +5,18 @@
   ...
 }:
 let
-  inherit (lib) mkOption;
+  inherit (lib) mkOption types;
   inherit (lib.types)
     attrsOf
     attrTag
     deferredModuleWith
-    mergeTypes
-    nullOr
     submoduleWith
     submodule
-    str
+    optionType
+    functionTo
     ;
 
-  functionType = import ./interface.nix;
+  functionType = import ./function.nix;
   application-resources = {
     options.resources = mkOption {
       type = attrsOf (
@@ -42,11 +41,11 @@ in
             _class = "fediversity-resource";
             options = {
               consumer = mkOption {
-                description = "Configuration of the resource by an application, a description of how the resource is consumed";
+                description = "Options for declaring resource requirements by an application, a description of how the resource is consumed";
                 type = deferredModuleWith { staticModules = [ { _class = "fediversity-resource-consumer"; } ]; };
               };
               provider = mkOption {
-                description = "Configuration of the resource by the hosting provider, a description of how the resource is made available";
+                description = "Options for configuring the resource for the hosting provider, a description of how the resource is made available";
                 type = deferredModuleWith { staticModules = [ { _class = "fediversity-resource-provider"; } ]; };
               };
             };
@@ -60,18 +59,25 @@ in
         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"; } ]; };
             };
-            config-mapping = mkOption {
+            implementation = mkOption {
               description = "Mapping of application configuration to deployment resources, a description of what an application needs to run";
-              type = application.config.function.implementation;
+              type = application.config.config-mapping.function-type;
             };
-            # TODO: somewhere we still need to
-            # - apply = { implementation = config-mapping; input = <application configuration value from operator>; }
-            # - apply.output
-            function = mkOption {
+            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;
+            };
+            config-mapping = mkOption {
               description = "Function type for the mapping from application configuration to required resources";
               type = submodule functionType;
               readOnly = true;
@@ -100,23 +106,59 @@ in
                 )
               );
             };
-            resource-mapping = mkOption {
+            implementation = mkOption {
               description = "Mapping of resources required by applications to available resources; the result can be deployed";
-              type = environment.config.function.implementation;
-              # TODO: type = consumer-resources /* same as the output of application.config-mapping, should be in a `let` */ -> nixops4Deployment
+              type = environment.config.resource-mapping.function-type;
             };
-            function = mkOption {
+            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 = submodule nixops4Deployment;
+                output-type = nixops4Deployment;
               };
             };
+            deployment = mkOption {
+              description = "Generate a deployment from a configuration";
+              type = functionTo 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 = submodule (configuration: {
+        options = {
+          enable = mkOption {
+            description = "Whether to enable the configuration";
+            type = types.bool;
+            default = false;
+          };
+          applications = lib.mapAttrs (
+            name: application:
+            mkOption {
+              description = application.description;
+              type = submodule application.module;
+              default = { };
+            }
+          ) config.applications;
+        };
+      });
+    };
   };
 }

deployment/function.nix

@@ -0,0 +1,30 @@
+/**
+  Modular function type
+*/
+{ config, ... }:
+{
+  options = {
+    input-type = mkOption {
+      type = deferredModule;
+    };
+    output-type = mkOption {
+      type = deferredModule;
+    };
+    function-type = mkOption {
+      type = optionType;
+      readOnly = true;
+      default = functionTo (
+        submodule (function: {
+          options = {
+            input = mkOption {
+              type = submodule config.input-type;
+            };
+            output = mkOption {
+              type = submodule config.output-type;
+            };
+          };
+        })
+      );
+    };
+  };
+}

deployment/interface.nix

@@ -1,49 +0,0 @@
-/**
-  Modular function type
-*/
-{ config, ... }:
-{
-  options = {
-    input-type = mkOption {
-      type = deferredModule;
-    };
-    output-type = mkOption {
-      type = deferredModule;
-    };
-    implementation = mkOption {
-      type = optionType;
-      readOnly = true;
-      default = implementationTo (
-        submodule (implementation: {
-          options = {
-            input = mkOption {
-              type = submodule config.input-type;
-            };
-            output = mkOption {
-              type = submodule config.output-type;
-            };
-          };
-        })
-      );
-    };
-    apply = mkOption {
-      type = optionType;
-      readOnly = true;
-      default = submodule (apply: {
-        options = {
-          implementation = mkOption {
-            type = config.implementation;
-          };
-          input = mkOption {
-            type = submodule config.input-type;
-          };
-          output = mkOption {
-            type = submodule config.output-type;
-            readOnly = true;
-            default = (apply.config.implementation apply.config.input).output;
-          };
-        };
-      });
-    };
-  };
-}