colmena/flake.nix

{
  description = "A simple, stateless NixOS deployment tool modeled after NixOps.";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    stable.url = "github:NixOS/nixpkgs/nixos-24.11";

    nix-github-actions = {
      url = "github:nix-community/nix-github-actions";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    flake-utils.url = "github:numtide/flake-utils";

    flake-compat = {
      url = "github:edolstra/flake-compat";
      flake = false;
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      stable,
      flake-utils,
      nix-github-actions,
      ...
    }@inputs:
    let
      supportedSystems = [
        "x86_64-linux"
        "i686-linux"
        "aarch64-linux"
        "x86_64-darwin"
        "aarch64-darwin"
      ];
    in
    flake-utils.lib.eachSystem supportedSystems (
      system:
      let
        pkgs = import nixpkgs { inherit system; };
      in
      rec {
        # We still maintain the expression in a Nixpkgs-acceptable form
        defaultPackage = self.packages.${system}.colmena;
        packages = rec {
          colmena = pkgs.callPackage ./package.nix { };

          # Full user manual
          manual =
            let
              suppressModuleArgsDocs =
                { lib, ... }:
                {
                  options = {
                    _module.args = lib.mkOption {
                      internal = true;
                    };
                  };
                };
              colmena = self.packages.${system}.colmena;
              deploymentOptionsMd =
                (pkgs.nixosOptionsDoc {
                  inherit
                    (pkgs.lib.evalModules {
                      modules = [
                        ./src/nix/hive/options/deployment.nix
                        suppressModuleArgsDocs
                      ];
                      specialArgs = {
                        name = "nixos";
                        nodes = { };
                      };
                    })
                    options
                    ;
                }).optionsCommonMark;
              metaOptionsMd =
                (pkgs.nixosOptionsDoc {
                  inherit
                    (pkgs.lib.evalModules {
                      modules = [
                        ./src/nix/hive/options/meta.nix
                        suppressModuleArgsDocs
                      ];
                    })
                    options
                    ;
                }).optionsCommonMark;
            in
            pkgs.callPackage ./manual {
              inherit colmena deploymentOptionsMd metaOptionsMd;
            };

          # User manual without the CLI reference
          manualFast = manual.override { colmena = null; };

          # User manual with the version treated as stable
          manualForceStable = manual.override { unstable = false; };
        };

        defaultApp = self.apps.${system}.colmena;
        apps.default = self.apps.${system}.colmena;
        apps.colmena = {
          type = "app";
          program = pkgs.lib.getExe defaultPackage;
        };

        devShell = pkgs.mkShell {
          RUST_SRC_PATH = pkgs.rustPlatform.rustLibSrc;
          NIX_PATH = "nixpkgs=${pkgs.path}";

          inputsFrom = [
            defaultPackage
            packages.manualFast
          ];
          packages = with pkgs; [
            bashInteractive
            editorconfig-checker
            clippy
            rust-analyzer
            cargo-outdated
            cargo-audit
            rustfmt
            python3
            python3Packages.flake8
          ];
        };
        checks =
          let
            inputsOverlay = final: prev: {
              _inputs = inputs;
            };
          in
          if pkgs.stdenv.isLinux then
            import ./integration-tests {
              pkgs = import nixpkgs {
                inherit system;
                overlays = [
                  self.overlays.default
                  inputsOverlay
                ];
              };
              pkgsStable = import stable {
                inherit system;
                overlays = [
                  self.overlays.default
                  inputsOverlay
                ];
              };
            }
          else
            { };
      }
    )
    // {
      overlay = self.overlays.default;
      overlays.default = final: prev: {
        colmena = final.callPackage ./package.nix { };
      };
      nixosModules = {
        deploymentOptions = import ./src/nix/hive/options/deployment.nix;
        metaOptions = import ./src/nix/hive/options/meta.nix;

        keyChownModule = import ./src/nix/hive/modules/key-chown.nix;
        keyServiceModule = import ./src/nix/hive/modules/key-service.nix;
        assertionModule = import ./src/nix/hive/modules/assertions.nix;
      };

      lib.makeHive =
        rawHive:
        import ./src/nix/hive/eval.nix {
          inherit rawHive;
          hermetic = true;
        };

      githubActions = nix-github-actions.lib.mkGithubMatrix {
        checks = {
          inherit (self.checks) x86_64-linux;
        };
      };
    };
}