feat: allow overrides of inputs of with-inputs-based project

Author: jbgi

README.md

@@ -72,7 +72,7 @@ Download our `default.nix` into your project `./with-inputs.nix`.
 curl https://raw.githubusercontent.com/vic/with-inputs/refs/heads/main/default.nix -o with-inputs.nix
 ```
 
-Or use npins or `builtins.fetchTarball` with a fixed revision of it. [^output-trick]
+Or use npins or `builtins.fetchTarball` with a fixed revision of it. [^output-trick] [^output-trick-2]
 
 ```shell
 npins add github vic with-inputs
@@ -90,11 +90,35 @@ let
 in 
 with-inputs outputs
 ```
+or if you want to allow overrides of inputs from a consumer project:
+```nix
+# default.nix
+{
+  inputsOverrides ? { },
+}:
+let
+   sources = import ./npins; # example with npins. use any other sources.
+   with-inputs = import sources.with-inputs sources {
+     # keep reading for follows and local inputs
+   };
+
+   outputs = localInputs: let inputs = localInputs // inputsOverrides; in
+     { }; # your flake-like outputs function
+in 
+with-inputs outputs
+```
 
 [^output-trick]: To use the experimental `nix` cli commands, create a `flake.nix` containing only
     ```nix
     { outputs = _: import ./.; }
     ```
+[^output-trick-2]: To additionally allow inputs overrides (eg, by a `with-inputs`-based consummer project):
+    ```nix
+    { outputs = inputsOverrides: import ./. { inherit inputsOverrides; }
+    ```
+
+### Flake backed by non-flake pins
+When `with-inputs` detect a flake dependency which does not declare any inputs, that flake `output` function is still called with the all available inputs, so they could be used as overrides.
 
 ### Follows and local checkout overrides
 

tests.nix

@@ -316,19 +316,19 @@ in
 
   # ── Dependency introspection ────────────────────────────────────────────────
 
-  introsepction.test-access-sub-flake-inputs = {
+  introspection.test-access-sub-flake-inputs = {
     # inputs.someFlake.inputs.dep — traverse a dependency's own inputs
     expr = (with-inputs { } { a = mkFlake { dep = mkSrc "/dep"; } { }; }).a.inputs.dep.outPath;
     expected = "/dep";
   };
 
-  introsepction.test-access-sub-flake-outputs = {
+  introspection.test-access-sub-flake-outputs = {
     # inputs.someFlake.outputs.lib — explicit outputs access
     expr = (with-inputs { } { a = mkFlake { } { lib = "mylib"; }; }).a.outputs.lib;
     expected = "mylib";
   };
 
-  introsepction.test-sub-flake-output-attrs-merged-at-top-level = {
+  introspection.test-sub-flake-output-attrs-merged-at-top-level = {
     # inputs.someFlake.lib ≡ inputs.someFlake.outputs.lib
     expr =
       let
@@ -346,6 +346,21 @@ in
     expected = "mylib";
   };
 
+  introspection.test-follow-sub-npins-with-inputs-input = {
+    # my-lib.inputs.nixpkgs.follows = "with-inputs-dep/nixpkgs" → traverse native inputs
+    expr =
+      (with-inputs
+        {
+          my-lib = mkSrc ./fixtures/fake-flake;
+          with-inputs-dep = mkSrc ./fixtures/with-inputs-flake;
+        }
+        {
+          my-lib.inputs.nixpkgs.follows = "with-inputs-dep/nixpkgs";
+        }
+      ).my-lib.inputs.nixpkgs.outPath;
+    expected = npins.nixpkgs.outPath;
+  };
+
   real-flakes.test-npins-nix-maid-nixosModules-output-is-readable = {
     expr =
       (with-inputs npins { } (inputs: {
@@ -378,6 +393,26 @@ in
     expected = npins.nixpkgs.outPath;
   };
 
+  real-flakes.test-sub-npins-with-inputs-nested-follows = {
+    # with-inputs-dep.inputs.nixpkgs.follows = "inputs/nixpkgs" → "blind" override of with-inputs-dep.inputs.nixpkgs
+    expr =
+      (with-inputs
+        {
+          inputs = mkFlake { nixpkgs = mkSrc "/nested-nixpkgs"; } { };
+          with-inputs-dep = mkSrc ./fixtures/with-inputs-flake;
+        }
+        {
+          with-inputs-dep.inputs.nixpkgs.follows = "inputs/nixpkgs";
+        }
+        (inputs: {
+          check = inputs.with-inputs-dep.usedNixpkgs;
+        })
+      ).check;
+    expected = {
+      outPath = "/nested-nixpkgs";
+    };
+  };
+
   non-flakes.test-non-flakes-are-not-evaluated = {
     expr =
       (with-inputs

with-inputs.nix

@@ -109,19 +109,33 @@ let
 
   mkFlakeInput =
     name: sourceInfo: flake:
+    let
+      topLevelInputs = inputs;
+    in
     let
       specs = flake.inputs or { };
-      inputs = builtins.mapAttrs (sub: spec: resolveSubInput name sub spec) specs;
+      direct = builtins.mapAttrs (sub: spec: resolveSubInput name sub spec) specs;
       indirect = builtins.mapAttrs (sub: _: resolveSubInput name sub { }) (
         builtins.functionArgs flake.outputs
       );
-      outputs = flake.outputs (indirect // inputs // { inherit self; });
+      nonEmptyInputs = direct != { } || indirect != { };
+      inputs =
+        if nonEmptyInputs then
+          indirect // direct
+        else
+          # Assume inputs are not handled by flake, but output function may still accept inputs overrides
+          builtins.removeAttrs allInputs [ name ]
+          // (builtins.mapAttrs (sub: spec: resolveSubInput name sub spec) (
+            topLevelInputs.${name}.inputs or { }
+          ));
+      outputs = flake.outputs (inputs // { inherit self; });
       self =
         sourceInfo
         // outputs
         // {
           _type = "flake";
-          inherit inputs outputs sourceInfo;
+          inputs = if nonEmptyInputs then inputs else outputs.inputs or { inherit self; };
+          inherit outputs sourceInfo;
         };
     in
     self;