flake.lock.nix

# Adapted from https://github.com/edolstra/flake-compat/blob/master/default.nix
#
# This version only gives back the inputs. In that mode, flake becomes little
# more than a niv replacement.
{
  src ? ./.,
}:
let
  lockFilePath = src + "/flake.lock";

  lockFile = builtins.fromJSON (builtins.readFile lockFilePath);

  # Emulate builtins.fetchTree
  #
  # TODO: only implement polyfill if the builtin doesn't exist?
  fetchTree =
    info:
    if info.type == "github" then
      {
        outPath = fetchTarball {
          url = "https://api.${info.host or "github.com"}/repos/${info.owner}/${info.repo}/tarball/${info.rev}";
          sha256 = info.narHash;
        };
        rev = info.rev;
        shortRev = builtins.substring 0 7 info.rev;
        lastModified = info.lastModified;
        narHash = info.narHash;
      }
    else if info.type == "git" then
      {
        outPath = builtins.fetchGit (
          {
            url = info.url;
            sha256 = info.narHash;
          }
          // (if info ? rev then { inherit (info) rev; } else { })
          // (if info ? ref then { inherit (info) ref; } else { })
        );
        lastModified = info.lastModified;
        narHash = info.narHash;
      }
      // (
        if info ? rev then
          {
            rev = info.rev;
            shortRev = builtins.substring 0 7 info.rev;
          }
        else
          { }
      )
    else if info.type == "path" then
      {
        outPath = builtins.path { path = info.path; };
        narHash = info.narHash;
      }
    else if info.type == "tarball" then
      {
        outPath = fetchTarball {
          url = info.url;
          sha256 = info.narHash;
        };
        narHash = info.narHash;
      }
    else if info.type == "gitlab" then
      {
        inherit (info) rev narHash lastModified;
        outPath = fetchTarball {
          url = "https://${info.host or "gitlab.com"}/api/v4/projects/${info.owner}%2F${info.repo}/repository/archive.tar.gz?sha=${info.rev}";
          sha256 = info.narHash;
        };
        shortRev = builtins.substring 0 7 info.rev;
      }
    else
      # FIXME: add Mercurial, tarball inputs.
      throw "flake input has unsupported input type '${info.type}'";

  allNodes = builtins.mapAttrs (
    key: node:
    let
      sourceInfo =
        if key == lockFile.root then
          { }
        else
          fetchTree (node.info or { } // removeAttrs node.locked [ "dir" ]);

      inputs = builtins.mapAttrs (inputName: inputSpec: allNodes.${resolveInput inputSpec}) (
        node.inputs or { }
      );

      # Resolve a input spec into a node name. An input spec is
      # either a node name, or a 'follows' path from the root
      # node.
      resolveInput =
        inputSpec: if builtins.isList inputSpec then getInputByPath lockFile.root inputSpec else inputSpec;

      # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
      # root node, returning the final node.
      getInputByPath =
        nodeName: path:
        if path == [ ] then
          nodeName
        else
          getInputByPath
            # Since this could be a 'follows' input, call resolveInput.
            (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
            (builtins.tail path);

      result = sourceInfo // {
        inherit inputs;
        inherit sourceInfo;
      };
    in
    if node.flake or true then result else sourceInfo
  ) lockFile.nodes;

  result =
    if lockFile.version >= 5 && lockFile.version <= 7 then
      allNodes.${lockFile.root}.inputs
    else
      throw "lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}";

in
result