@ifunny/ifunny-api-types 1.0.3 → 1.2.0

package/.devenv/bootstrap/bootstrapLib.nix

@@ -0,0 +1,630 @@
+# Shared library functions for devenv evaluation
+{ inputs }:
+
+rec {
+  # Helper to get overlays for a given input
+  getOverlays =
+    inputName: inputAttrs:
+    let
+      lib = inputs.nixpkgs.lib;
+    in
+    map (
+      overlay:
+      let
+        input =
+          inputs.${inputName} or (throw "No such input `${inputName}` while trying to configure overlays.");
+      in
+      input.overlays.${overlay}
+        or (throw "Input `${inputName}` has no overlay called `${overlay}`. Supported overlays: ${lib.concatStringsSep ", " (builtins.attrNames input.overlays)}")
+    ) inputAttrs.overlays or [ ];
+
+  # Main function to create devenv configuration for a specific system with profiles support
+  # This is the full-featured version used by default.nix
+  mkDevenvForSystem =
+    {
+      version,
+      is_development_version ? false,
+      require_version_match ? false,
+      system,
+      devenv_root,
+      devenv_lock,
+      git_root ? null,
+      devenv_dotfile,
+      devenv_dotfile_path,
+      devenv_tmpdir,
+      devenv_runtime,
+      devenv_state ? null,
+      devenv_istesting ? false,
+      devenv_direnvrc_latest_version,
+      active_profiles ? [ ],
+      hostname,
+      username,
+      cli_options ? [ ],
+      skip_local_src ? false,
+      secretspec ? null,
+      devenv_inputs ? { },
+      devenv_imports ? [ ],
+      impure ? false,
+      nixpkgs_config ? { },
+      lock_fingerprint ? null,
+      primops ? { },
+    }:
+    let
+      inherit (inputs) nixpkgs;
+      lib = nixpkgs.lib;
+      targetSystem = system;
+
+      overlays = lib.flatten (lib.mapAttrsToList getOverlays devenv_inputs);
+      unfreePackageError =
+        pkg:
+        let
+          name = lib.getName pkg;
+        in
+        throw ''
+          devenv: package '${name}' has an unfree license.
+
+          To allow all unfree packages, add this to devenv.yaml:
+
+            allow_unfree: true
+
+          To allow only this package, add this to devenv.yaml:
+
+            nixpkgs:
+              permitted_unfree_packages:
+                - ${name}
+        '';
+
+      # Helper to create pkgs for a given system with nixpkgs_config
+      mkPkgsForSystem =
+        evalSystem:
+        import nixpkgs {
+          system = evalSystem;
+          config =
+            nixpkgs_config
+            // {
+              # nixpkgs' check-meta.nix natively handles permittedInsecurePackages
+              # via allowInsecureDefaultPredicate using the full derivation name.
+              # We must NOT override allowInsecurePredicate here, as lib.getName
+              # strips the version, causing mismatches with user-provided entries
+              # like "openssl-1.1.1w".
+              #
+              # For unfree packages, nixpkgs does not natively support
+              # permittedUnfreePackages, so we provide a custom predicate.
+              allowUnfreePredicate =
+                if nixpkgs_config.allowUnfree or false then
+                  (_: true)
+                else if (nixpkgs_config.permittedUnfreePackages or [ ]) != [ ] then
+                  (
+                    pkg:
+                    builtins.elem (lib.getName pkg) (nixpkgs_config.permittedUnfreePackages or [ ])
+                    || unfreePackageError pkg
+                  )
+                else
+                  unfreePackageError;
+            }
+            // lib.optionalAttrs ((nixpkgs_config.allowlistedLicenses or [ ]) != [ ]) {
+              allowlistedLicenses = map (name: lib.licenses.${name}) (nixpkgs_config.allowlistedLicenses or [ ]);
+            }
+            // lib.optionalAttrs ((nixpkgs_config.blocklistedLicenses or [ ]) != [ ]) {
+              blocklistedLicenses = map (name: lib.licenses.${name}) (nixpkgs_config.blocklistedLicenses or [ ]);
+            };
+          inherit overlays;
+        };
+
+      pkgsBootstrap = mkPkgsForSystem targetSystem;
+
+      # Helper to resolve a path to a list of module files, trying .nix first then /devenv.nix.
+      # Includes devenv.local.nix when present.
+      # Keep the entries as unimported paths: the module system uses them as each module's
+      # file (for error locations) and key (for deduplication).
+      tryImport =
+        resolvedPath: basePath:
+        if lib.hasSuffix ".nix" basePath then
+          [ resolvedPath ]
+        else
+          let
+            devenvpath = resolvedPath + "/devenv.nix";
+            localpath = resolvedPath + "/devenv.local.nix";
+          in
+          if builtins.pathExists devenvpath then
+            [ devenvpath ] ++ lib.optional (builtins.pathExists localpath) localpath
+          else
+            throw (basePath + "/devenv.nix file does not exist");
+
+      importModule =
+        path:
+        if lib.hasPrefix "path:" path then
+          # path: prefix indicates a local filesystem path - strip it and import directly
+          let
+            actualPath = builtins.substring 5 999999 path;
+          in
+          tryImport (/. + actualPath) path
+        else if lib.hasPrefix "/" path then
+          # Absolute path - import directly (avoids input resolution and NAR hash computation)
+          tryImport (/. + path) path
+        else if lib.hasPrefix "./" path then
+          # Relative paths are relative to devenv_root, not bootstrap directory
+          let
+            relPath = builtins.substring 1 255 path;
+          in
+          tryImport (/. + devenv_root + relPath) path
+        else if lib.hasPrefix "../" path then
+          # Parent relative paths also relative to devenv_root
+          tryImport (/. + devenv_root + "/${path}") path
+        else
+          let
+            paths = lib.splitString "/" path;
+            name = builtins.head paths;
+            input = inputs.${name} or (throw "Unknown input ${name}");
+            subpath = lib.concatStringsSep "/" (builtins.tail paths);
+            devenvpath = input + lib.optionalString (subpath != "") "/${subpath}";
+          in
+          tryImport devenvpath path;
+
+      # Common modules shared between main evaluation and cross-system evaluation
+      mkCommonModules =
+        evalPkgs:
+        [
+          (
+            { config, ... }:
+            {
+              _module.args.pkgs = evalPkgs.appendOverlays (config.overlays or [ ]);
+              _module.args.secretspec = secretspec;
+              _module.args.devenvPrimops = primops;
+            }
+          )
+          (inputs.devenv.modules + /top-level.nix)
+          (
+            { options, ... }:
+            {
+              config.devenv = lib.mkMerge [
+                {
+                  root = devenv_root;
+                  dotfile = devenv_dotfile;
+                }
+                (
+                  if builtins.hasAttr "cli" options.devenv then
+                    {
+                      cli.version = version;
+                      cli.isDevelopment = is_development_version;
+                    }
+                  else
+                    {
+                      cliVersion = version;
+                    }
+                )
+                (lib.optionalAttrs
+                  (builtins.hasAttr "cli" options.devenv && builtins.hasAttr "requireVersionMatch" options.devenv.cli)
+                  {
+                    cli.requireVersionMatch = require_version_match;
+                  }
+                )
+                (lib.optionalAttrs (builtins.hasAttr "tmpdir" options.devenv) {
+                  tmpdir = devenv_tmpdir;
+                })
+                (lib.optionalAttrs (builtins.hasAttr "isTesting" options.devenv) {
+                  isTesting = devenv_istesting;
+                })
+                (lib.optionalAttrs (builtins.hasAttr "runtime" options.devenv) {
+                  runtime = devenv_runtime;
+                })
+                (lib.optionalAttrs (builtins.hasAttr "state" options.devenv && devenv_state != null) {
+                  state = lib.mkForce devenv_state;
+                })
+                (lib.optionalAttrs (builtins.hasAttr "direnvrcLatestVersion" options.devenv) {
+                  direnvrcLatestVersion = devenv_direnvrc_latest_version;
+                })
+              ];
+            }
+          )
+          (
+            { options, ... }:
+            {
+              config = lib.mkMerge [
+                (lib.optionalAttrs (builtins.hasAttr "git" options) {
+                  git.root = git_root;
+                })
+              ];
+            }
+          )
+        ]
+        ++ (lib.flatten (map importModule devenv_imports))
+        ++ (
+          if !skip_local_src then
+            (importModule (devenv_root + "/devenv.nix"))
+            ++ (
+              let
+                localPath = devenv_root + "/devenv.local.nix";
+              in
+              lib.optional (builtins.pathExists localPath) localPath
+            )
+          else
+            [ ]
+        )
+        ++ [
+          cli_options
+        ];
+
+      # Phase 1: Base evaluation to extract profile definitions
+      baseProject = lib.evalModules {
+        class = "devenv";
+        specialArgs = inputs // {
+          inherit inputs secretspec primops;
+        };
+        modules = mkCommonModules pkgsBootstrap;
+      };
+
+      # Phase 2: Extract and apply profiles using extendModules with priority overrides
+      project =
+        let
+          # Build ordered list of profile names: hostname -> user -> manual
+          manualProfiles = active_profiles;
+          currentHostname = hostname;
+          currentUsername = username;
+          hostnameProfiles = lib.optional (
+            currentHostname != null
+            && currentHostname != ""
+            && builtins.hasAttr currentHostname (baseProject.config.profiles.hostname or { })
+          ) "hostname.${currentHostname}";
+          userProfiles = lib.optional (
+            currentUsername != null
+            && currentUsername != ""
+            && builtins.hasAttr currentUsername (baseProject.config.profiles.user or { })
+          ) "user.${currentUsername}";
+
+          # Ordered list of profiles to activate
+          orderedProfiles = hostnameProfiles ++ userProfiles ++ manualProfiles;
+
+          # Resolve profile extends with cycle detection
+          resolveProfileExtends =
+            profileName: visited:
+            if builtins.elem profileName visited then
+              throw "Circular dependency detected in profile extends: ${lib.concatStringsSep " -> " visited} -> ${profileName}"
+            else
+              let
+                profile = getProfileConfig profileName;
+                extends = profile.extends or [ ];
+                newVisited = visited ++ [ profileName ];
+                extendedProfiles = lib.flatten (map (name: resolveProfileExtends name newVisited) extends);
+              in
+              extendedProfiles ++ [ profileName ];
+
+          # Get profile configuration by name from baseProject
+          getProfileConfig =
+            profileName:
+            if lib.hasPrefix "hostname." profileName then
+              let
+                name = lib.removePrefix "hostname." profileName;
+              in
+              baseProject.config.profiles.hostname.${name}
+            else if lib.hasPrefix "user." profileName then
+              let
+                name = lib.removePrefix "user." profileName;
+              in
+              baseProject.config.profiles.user.${name}
+            else
+              let
+                availableProfiles = builtins.attrNames (baseProject.config.profiles or { });
+                hostnameProfiles = map (n: "hostname.${n}") (
+                  builtins.attrNames (baseProject.config.profiles.hostname or { })
+                );
+                userProfiles = map (n: "user.${n}") (builtins.attrNames (baseProject.config.profiles.user or { }));
+                allAvailableProfiles = availableProfiles ++ hostnameProfiles ++ userProfiles;
+              in
+              baseProject.config.profiles.${profileName}
+                or (throw "Profile '${profileName}' not found. Available profiles: ${lib.concatStringsSep ", " allAvailableProfiles}");
+
+          # Fold over ordered profiles to build final list with extends
+          expandedProfiles = lib.foldl' (
+            acc: profileName:
+            let
+              allProfileNames = resolveProfileExtends profileName [ ];
+            in
+            acc ++ allProfileNames
+          ) [ ] orderedProfiles;
+
+          # Map over expanded profiles and apply priorities
+          allPrioritizedModules = lib.imap0 (
+            index: profileName:
+            let
+              profilePriority = (lib.modules.defaultOverridePriority - 1) - index;
+              profileConfig = getProfileConfig profileName;
+
+              typeNeedsOverride =
+                type:
+                if type == null then
+                  false
+                else
+                  let
+                    typeName = type.name or type._type or "";
+
+                    isLeafType = builtins.elem typeName [
+                      "str"
+                      "int"
+                      "bool"
+                      "enum"
+                      "path"
+                      "package"
+                      "float"
+                      "anything"
+                    ];
+                  in
+                  if isLeafType then
+                    true
+                  else if typeName == "nullOr" then
+                    let
+                      innerType =
+                        type.elemType
+                          or (if type ? nestedTypes && type.nestedTypes ? elemType then type.nestedTypes.elemType else null);
+                    in
+                    if innerType != null then typeNeedsOverride innerType else false
+                  else
+                    false;
+
+              pathNeedsOverride =
+                optionPath:
+                let
+                  directOption = lib.attrByPath optionPath null baseProject.options;
+                in
+                if directOption != null && lib.isOption directOption then
+                  typeNeedsOverride directOption.type
+                else if optionPath != [ ] then
+                  let
+                    parentPath = lib.init optionPath;
+                    parentOption = lib.attrByPath parentPath null baseProject.options;
+                  in
+                  if parentOption != null && lib.isOption parentOption then
+                    let
+                      freeformType = parentOption.type.freeformType or parentOption.type.nestedTypes.freeformType or null;
+                      elementType =
+                        if freeformType ? elemType then
+                          freeformType.elemType
+                        else if freeformType ? nestedTypes && freeformType.nestedTypes ? elemType then
+                          freeformType.nestedTypes.elemType
+                        else
+                          freeformType;
+                    in
+                    typeNeedsOverride elementType
+                  else
+                    false
+                else
+                  false;
+
+              applyModuleOverride =
+                config:
+                if builtins.isFunction config then
+                  let
+                    wrapper = args: applyOverrideRecursive (config args) [ ];
+                  in
+                  lib.mirrorFunctionArgs config wrapper
+                else
+                  applyOverrideRecursive config [ ];
+
+              applyOverrideRecursive =
+                config: optionPath:
+                if lib.isAttrs config && config ? _type then
+                  config
+                else if pathNeedsOverride optionPath then
+                  lib.mkOverride profilePriority config
+                else if lib.isAttrs config then
+                  lib.mapAttrs (name: value: applyOverrideRecursive value (optionPath ++ [ name ])) config
+                else
+                  config;
+
+              prioritizedConfig = (
+                profileConfig.module
+                // {
+                  imports = lib.map (
+                    importItem:
+                    importItem
+                    // {
+                      imports = lib.map (nestedImport: applyModuleOverride nestedImport) (importItem.imports or [ ]);
+                    }
+                  ) (profileConfig.module.imports or [ ]);
+                }
+              );
+            in
+            prioritizedConfig
+          ) expandedProfiles;
+        in
+        if allPrioritizedModules == [ ] then
+          baseProject
+        else
+          baseProject.extendModules { modules = allPrioritizedModules; };
+
+      config = project.config;
+
+      # Per-container scoped re-evaluation that flips `isBuilding` for the
+      # container being built. Selecting one container cannot pollute the
+      # evaluation of any other operation, since each `containerBuilds.<name>`
+      # is its own `extendModules` scope.
+      mkContainerBuilds =
+        evalProject:
+        lib.genAttrs (lib.attrNames evalProject.config.containers) (
+          name:
+          let
+            scoped = evalProject.extendModules {
+              modules = [
+                {
+                  container.isBuilding = lib.mkForce true;
+                  containers.${name}.isBuilding = lib.mkForce true;
+                }
+              ];
+            };
+          in
+          scoped.config.containers.${name}
+        );
+
+      containerBuilds = mkContainerBuilds project;
+
+      # Apply config overlays to pkgs
+      pkgs = pkgsBootstrap.appendOverlays (config.overlays or [ ]);
+
+      options = pkgs.nixosOptionsDoc {
+        options = builtins.removeAttrs project.options [ "_module" ];
+        warningsAreErrors = false;
+        transformOptions =
+          let
+            isDocType =
+              v:
+              builtins.elem v [
+                "literalDocBook"
+                "literalExpression"
+                "literalMD"
+                "mdDoc"
+              ];
+          in
+          lib.attrsets.mapAttrs (
+            _: v:
+            if v ? _type && isDocType v._type then
+              v.text
+            else if v ? _type && v._type == "derivation" then
+              v.name
+            else
+              v
+          );
+      };
+
+      build =
+        options: config:
+        lib.concatMapAttrs (
+          name: option:
+          if lib.isOption option then
+            let
+              typeName = option.type.name or "";
+            in
+            if
+              builtins.elem typeName [
+                "output"
+                "outputOf"
+              ]
+            then
+              {
+                ${name} = config.${name};
+              }
+            else
+              { }
+          else if builtins.isAttrs option && !lib.isDerivation option then
+            let
+              v = build option config.${name};
+            in
+            if v != { } then { ${name} = v; } else { }
+          else
+            { }
+        ) options;
+
+      # Helper to evaluate devenv for a specific system (for cross-compilation, e.g. macOS building Linux containers)
+      evalForSystem =
+        evalSystem:
+        let
+          evalPkgs = mkPkgsForSystem evalSystem;
+          evalProject = lib.evalModules {
+            class = "devenv";
+            specialArgs = inputs // {
+              inherit inputs secretspec primops;
+            };
+            modules = mkCommonModules evalPkgs;
+          };
+        in
+        {
+          config = evalProject.config;
+          containerBuilds = mkContainerBuilds evalProject;
+        };
+
+      # All supported systems for cross-compilation (lazily evaluated)
+      allSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+
+      # Generate perSystem entries for all systems (only evaluated when accessed)
+      perSystemConfigs = lib.genAttrs allSystems (
+        perSystem:
+        if perSystem == targetSystem then { inherit config containerBuilds; } else evalForSystem perSystem
+      );
+    in
+    {
+      inherit
+        pkgs
+        config
+        options
+        project
+        inputs
+        ;
+      bash = pkgs.bash;
+      shell = config.shell;
+      # Older pinned modules predate the optional localhost proxy.
+      processProxyEnabled = config.process.proxy.enable or false;
+      optionsJSON = options.optionsJSON;
+      info = config.info;
+      ci = config.ciDerivation;
+      build = build project.options config;
+      devenv = {
+        # Backwards compatibility: wrap config in devenv attribute for code expecting devenv.config.*
+        inherit config containerBuilds;
+        # perSystem structure for cross-compilation (e.g. macOS building Linux containers)
+        perSystem = perSystemConfigs;
+      };
+    };
+
+  # Simplified devenv evaluation for inputs
+  # This is a lightweight version suitable for evaluating an input's devenv.nix
+  mkDevenvForInput =
+    {
+      # The input to evaluate (must have outPath and sourceInfo)
+      input,
+      # All resolved inputs (for specialArgs)
+      allInputs,
+      # System to evaluate for
+      system ? builtins.currentSystem,
+      # Nixpkgs to use (defaults to allInputs.nixpkgs)
+      nixpkgs ? allInputs.nixpkgs or (throw "nixpkgs input required"),
+      # Devenv modules (defaults to allInputs.devenv)
+      devenv ? allInputs.devenv or (throw "devenv input required"),
+    }:
+    let
+      devenvPath = input.outPath + "/devenv.nix";
+      hasDevenv = builtins.pathExists devenvPath;
+    in
+    if !hasDevenv then
+      throw ''
+        Input does not have a devenv.nix file.
+        Expected file at: ${toString devenvPath}
+
+        To use this input's devenv configuration, the input must provide a devenv.nix file.
+      ''
+    else
+      let
+        pkgs = import nixpkgs {
+          inherit system;
+          config = { };
+        };
+        lib = pkgs.lib;
+
+        project = lib.evalModules {
+          class = "devenv";
+          specialArgs = allInputs // {
+            inputs = allInputs;
+            secretspec = null;
+          };
+          modules = [
+            (
+              { config, ... }:
+              {
+                _module.args.pkgs = pkgs.appendOverlays (config.overlays or [ ]);
+              }
+            )
+            (devenv.outPath + "/src/modules/top-level.nix")
+            devenvPath
+          ];
+        };
+      in
+      {
+        inherit pkgs;
+        config = project.config;
+        options = project.options;
+        inherit project;
+      };
+}

package/.devenv/bootstrap/default.nix

@@ -0,0 +1,22 @@
+args@{
+  system,
+  # The project root (location of devenv.nix)
+  devenv_root,
+  devenv_lock,
+  ...
+}:
+
+let
+  inherit
+    (import ./resolve-lock.nix {
+      src = devenv_root;
+      lockFilePath = devenv_lock;
+      inherit system;
+    })
+    inputs
+    ;
+
+  bootstrapLib = import ./bootstrapLib.nix { inherit inputs; };
+in
+
+bootstrapLib.mkDevenvForSystem args