Fediversity/deployment/data-model.nix

{
  lib,
  config,
  inputs,
  ...
}:
let
  inherit (lib) mkOption types;
  inherit (lib.types)
    attrsOf
    attrTag
    deferredModuleWith
    submoduleWith
    optionType
    functionTo
    ;

  functionType = import ./function.nix;
  application-requirements = {
    _class = "fediversity-application-requirements";
    options.resources = mkOption {
      # TODO: maybe transpose, and group the resources by type instead
      type = attrsOf (
        attrTag (lib.mapAttrs (_name: resource: mkOption { type = resource.request; }) config.resources)
      );
    };
  };
  nixops4Deployment = import ./deployment.nix { inherit lib inputs; };
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 {
        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 {
        class = "fediversity-application";
        modules = [
          (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;
              };
              config-mapping = mkOption {
                description = "Function type for the mapping from application configuration to required resources";
                type = submoduleWith {
                  class = "module-function";
                  modules = [ functionType ];
                };
                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 {
        class = "fediversity-configuration";
        modules = [
          {
            options = {
              enable = lib.mkEnableOption {
                description = "your Fediversity configuration";
              };
              applications = lib.mapAttrs (
                _name: application:
                mkOption {
                  description = application.description;
                  type = submoduleWith {
                    class = "fediversity-application-config";
                    modules = [ application.module ];
                  };
                  default = { };
                }
              ) config.applications;
            };
          }
        ];
      };
    };
  };
}