flake.nix

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    opam2json = {
      url = "github:tweag/opam2json";
      inputs.nixpkgs.follows = "nixpkgs";
    };

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

    # Used for examples/tests and as a default repository
    opam-repository = {
      url = "github:ocaml/opam-repository";
      flake = false;
    };

    # used for opam-monorepo
    opam-overlays = {
      url = "github:dune-universe/opam-overlays";
      flake = false;
    };
    mirage-opam-overlays = {
      url = "github:dune-universe/mirage-opam-overlays";
      flake = false;
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      flake-utils,
      opam2json,
      opam-repository,
      opam-overlays,
      mirage-opam-overlays,
      ...
    }@inputs:
    {
      aux = import ./src/lib.nix nixpkgs.lib;
      templates.simple = {
        description = "Simply build an opam package, preferrably a library, from a local directory";
        path = ./templates/simple;
      };
      templates.executable = {
        description = "Build an executable from a local opam package, and provide a development shell with some convinient tooling";
        path = ./templates/executable;
      };
      templates.multi-package = {
        description = "Build multiple packages from a single workspace, and provide a development shell with some convinient tooling";
        path = ./templates/multi-package;
      };
      templates.default = self.templates.simple;

      overlays = {
        ocaml-overlay = import ./src/overlays/ocaml.nix;
        ocaml-static-overlay = import ./src/overlays/ocaml-static.nix;
      };
    }
    // flake-utils.lib.eachDefaultSystem (
      system:
      let
        # The formats of opam2json output that we support
        opam2json-versions = [ "0.4" ];
        pkgs = nixpkgs.legacyPackages.${system}.extend (
          nixpkgs.lib.composeManyExtensions [
            (final: prev: {
              opam2json =
                if __elem (prev.opam2json.version or null) opam2json-versions then
                  prev.opam2json
                else
                  (opam2json.overlay final prev).opam2json;
            })
          ]
        );
        opam-nix = import ./src/opam.nix {
          inherit
            pkgs
            opam-repository
            opam-overlays
            mirage-opam-overlays
            ;
        };
      in
      rec {
        lib = opam-nix;
        checks = packages // (pkgs.callPackage ./examples/docfile { inherit opam-nix; }).checks;

        legacyPackages = __mapAttrs (
          name: versions:
          let
            allVersions = __listToAttrs (
              map (
                version:
                nixpkgs.lib.nameValuePair version
                  (lib.queryToScope { } (
                    {
                      ocaml-base-compiler = "*";
                    }
                    // {
                      ${name} = version;
                    }
                  )).${name}
              ) versions
            );
          in
          allVersions
          // {
            latest = allVersions.${nixpkgs.lib.last versions};
          }
        ) (lib.listRepo opam-repository);

        allChecks = pkgs.runCommand "opam-nix-checks" { checks = __attrValues checks; } "touch $out";

        packages =
          let
            examples = rec {
              _0install = (import ./examples/0install/flake.nix).outputs {
                self = _0install;
                opam-nix = inputs.self;
                inherit (inputs) flake-utils;
              };
              coq = (import ./examples/coq/flake.nix).outputs {
                self = coq;
                opam-nix = inputs.self;
                inherit (inputs) nixpkgs opam-repository flake-utils;
              };
              frama-c = (import ./examples/frama-c/flake.nix).outputs {
                self = frama-c;
                opam-nix = inputs.self;
                inherit (inputs) flake-utils;
              };
              opam-ed = (import ./examples/opam-ed/flake.nix).outputs {
                self = opam-ed;
                opam-nix = inputs.self;
                inherit (inputs) flake-utils;
              };
              opam2json = (import ./examples/opam2json/flake.nix).outputs {
                self = opam2json;
                opam-nix = inputs.self;
                inherit (inputs) opam2json flake-utils;
              };
              ocaml-lsp = (import ./examples/ocaml-lsp/flake.nix).outputs {
                self = ocaml-lsp;
                opam-nix = inputs.self;
                inherit (inputs) nixpkgs flake-utils;
              };
              opam2json-static = (import ./examples/opam2json-static/flake.nix).outputs {
                self = opam2json-static;
                opam-nix = inputs.self;
                inherit (inputs) opam2json flake-utils;
              };
              tezos = (import ./examples/tezos/flake.nix).outputs {
                self = tezos;
                opam-nix = inputs.self;
                inherit (inputs) flake-utils;
              };
              materialized-opam-ed = (import ./examples/materialized-opam-ed/flake.nix).outputs {
                self = materialized-opam-ed;
                opam-nix = inputs.self;
                inherit (inputs) flake-utils;
              };
            };
          in
          {
            opam-nix-gen = pkgs.substituteAll {
              name = "opam-nix-gen";
              src = ./scripts/opam-nix-gen.in;
              dir = "bin";
              isExecutable = true;
              inherit (pkgs) runtimeShell coreutils nix;
              opamNix = "${self}";
            };
            opam-nix-regen = pkgs.substituteAll {
              name = "opam-nix-regen";
              src = ./scripts/opam-nix-regen.in;
              dir = "bin";
              isExecutable = true;
              inherit (pkgs) runtimeShell jq;
              opamNixGen = "${self.packages.${system}.opam-nix-gen}/bin/opam-nix-gen";
            };
          }
          // builtins.mapAttrs (_: e: e.defaultPackage.${system}) examples;
      }
    );
}