nix-gitlab-ci/lib/flakeModule.nix

{
  flake-parts-lib,
  lib,
  ...
}: {
  options.perSystem = flake-parts-lib.mkPerSystemOption (
    {
      config,
      pkgs,
      ...
    }: let
      cilib = import ./. {inherit lib pkgs;};
      inherit (cilib.pipeline) mkPipeline;
      inherit (lib) types mkOption;

      cfg = config.ci.config;

      subType = options: types.submodule {inherit options;};
      mkNullOption = type:
        mkOption {
          default = null;
          type = types.nullOr type;
        };

      configType = subType {
        nix-jobs-by-default = mkOption {
          type = types.bool;
          default = true;
          description = "Handle jobs nix-based by default or via opt-in (in a job set nix.enable = true) if false";
        };
      };
      jobType = subType {
        # nix ci opts
        nix = mkOption {
          type = subType {
            enable = mkOption {
              type = types.bool;
              default = cfg.nix-jobs-by-default;
              description = "Handle this job as a nix job";
            };
            deps = mkOption {
              type = types.listOf types.package;
              default = [];
              description = "Dependencies/packages to install for this job";
            };
            enable-runner-cache = mkOption {
              type = types.bool;
              default = false;
              description = ''
                Cache this job using the GitLab Runner cache.
                Warning: useful for tiny jobs, but most of the time it just takes an eternity.
              '';
            };
            runner-cache-key = mkOption {
              type = types.str;
              default = "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG";
              description = "Cache key to use for the runner nix cache. Requires enable-runner-cache = true";
            };
          };
          default = {};
          description = "Configure Nix Gitlab CI for each job individually";
        };
        # gitlab opts
        script = mkOption {
          type = types.listOf types.str;
          default = [];
        };
        stage = mkOption {
          type = types.str;
          default = "test";
        };
        image = mkOption {
          type = types.str;
          default = "$NIX_CI_IMAGE";
        };
        after_script = mkNullOption (types.listOf types.str);
        allow_failure = mkNullOption (types.either types.attrs types.bool);
        artifacts = mkNullOption (types.attrs);
        before_script = mkNullOption (types.listOf types.str);
        cache = mkNullOption (types.either (types.listOf types.attrs) types.attrs);
        coverage = mkNullOption (types.str);
        dependencies = mkNullOption (types.listOf types.str);
        environment = mkNullOption (types.either types.attrs types.str);
        extends = mkNullOption (types.str);
        hooks = mkNullOption (types.attrs);
        id_tokens = mkNullOption (types.attrs);
        "inherit" = mkNullOption (types.attrs);
        interruptible = mkNullOption (types.bool);
        needs = mkNullOption (types.listOf (types.either types.str types.attrs));
        publish = mkNullOption (types.str);
        pages = mkNullOption (types.attrs);
        parallel = mkNullOption (types.either types.int types.attrs);
        release = mkNullOption (types.attrs);
        retry = mkNullOption (types.either types.int types.attrs);
        rules = mkNullOption (types.listOf types.attrs);
        resource_group = mkNullOption (types.str);
        secrets = mkNullOption (types.attrs);
        services = mkNullOption (types.listOf types.attrs);
        start_in = mkNullOption (types.str);
        tags = mkNullOption (types.listOf types.str);
        timeout = mkNullOption (types.str);
        variables = mkNullOption (types.attrs);
        when = mkNullOption (types.str);
      };

      ciType = subType {
        config = mkOption {
          type = configType;
          description = ''
            Configuration options for the nix part itself
          '';
          default = {};
        };
        image = mkNullOption (types.str);
        variables = mkNullOption (types.attrs);
        default = mkNullOption (types.attrs);
        stages = mkNullOption (types.listOf types.str);
        include = mkNullOption (types.attrs);
        workflow = mkNullOption (types.attrs);
        jobs = mkOption {
          type = types.lazyAttrsOf jobType;
          default = {};
        };
      };
    in {
      options = {
        pipelines = mkOption {
          type = types.lazyAttrsOf ciType;
          description = ''
            Create multiple GitLab CI pipelines.

            See README.md for more information about how a pipeline is selected.
          '';
          default = {};
          apply = op: let
            # NOTE: show warning if "default" is set and config.ci is not {}
            legacyMode = config.ci != {};
            defaultExists = builtins.hasAttr "default" op;
            value =
              {
                "default" = config.ci;
              }
              // op;
          in
            if defaultExists && legacyMode
            then builtins.trace "Warning: config.ci is overwritten by pipelines.default" value
            else value;
        };
        ci = mkOption {
          type = ciType;
          description = ''
            Note: this is a shorthand for writing `pipelines."default"`

            Generate a Gitlab CI configuration which can be used to trigger a child pipeline.
            This will inject code which pre-downloads the nix deps before each job and adds them to PATH.
          '';
          default = {};
        };
      };

      config.legacyPackages = lib.fold (pipeline: acc: acc // pipeline) {} (
        map (
          pipeline_name:
            (mkPipeline {
              pipeline = config.pipelines."${pipeline_name}";
              name = pipeline_name;
            }).packages
        ) (builtins.attrNames config.pipelines)
      );
    }
  );
}