flake.nix

{
  description = "ctl-scaffold";

  nixConfig = {
    extra-substituters = [ "https://plutonomicon.cachix.org" ];
    extra-trusted-public-keys = [ "plutonomicon.cachix.org-1:evUxtNULjCjOipxwAnYhNFeF/lyYU1FeNGaVAnm+QQw=" ];
    bash-prompt = "[\\[\\e[0;1m\\]\\[\\033[33m\\]$(git rev-parse --abbrev-ref HEAD) \\[\\e[0;32m\\]\\w\\[\\e[0m\\]]\\[\\e[0m\\]$ \\[\\e[0m\\]";
  };

  inputs = {
    flake-compat = {
      url = "github:edolstra/flake-compat";
      flake = false;
    };
    ctl = {
      type = "github";
      owner = "Plutonomicon";
      repo = "cardano-transaction-lib";
      rev = "f70a82f551d1aa4065312695784536d9fecbc947";
    };
    # To use the same version of `nixpkgs` as we do
    nixpkgs.follows = "ctl/nixpkgs";
  };

  outputs = { self, nixpkgs, ctl, ... }@inputs:
    let
      supportedSystems = [
        "x86_64-linux"
        "x86_64-darwin"
        "aarch64-linux"
        "aarch64-darwin"
      ];
      perSystem = nixpkgs.lib.genAttrs supportedSystems;

      # generate `pkgs` with CTL's overlays applied. This gives you access to
      # various additional packages. The versions are the same as those that CTL uses.
      nixpkgsFor = system: import nixpkgs {
        inherit system;
        overlays = [
          ctl.overlays.purescript
          ctl.overlays.runtime
          ctl.overlays.spago
        ];
      };


      # The configuration for the CTL runtime, which will be passed to the
      # expression that builds the JSON file used by Arion. This value can be
      # shared between `buildCtlRuntime` and `launchCtlRuntime`, as shown below
      #
      # You can refer to the final configuration value by passing a function
      # that takes a single arugment. Alternatively, you can pass an attrset
      # directly.
      #
      # Here we demonstrate how to add `extraServices` and `extraDockerCompose`.
      # For the other attributes, which have default values,
      # consult `defaultConfig` in `nix/runtime.nix`.
      runtimeConfig = { };
      # runtimeConfig = final: with final; {
      #   # You can add new services to the runtime. These should correspond to
      #   # Arion's `service` definition. The default is the empty attribute set
      #   extraServices = {
      #     # an image from dockerhub
      #     foo = {
      #       service = {
      #         image = "bar:foo";
      #         command = [
      #           "baz"
      #           "--quux"
      #         ];
      #       };

      #       # Or a Nix-based image
      #       foo2 = {
      #         service = {
      #           useHostStore = true;
      #           command = [
      #             "${(nixpkgsFor system).baz}/bin/baz"
      #             "--quux"
      #           ];
      #         };
      #       };
      #     };
      #   };
      #   # This corresponds to `docker-compose.raw` from Arion. You can add new
      #   # volumes, etc... using this
      #   extraDockerCompose = { volumes = { someVol = { }; }; };

      psProjectFor = pkgs:
        pkgs.purescriptProject rec {
          inherit pkgs;
          projectName = "ctl-scaffold";
          packageJson = ./package.json;
          packageLock = ./package-lock.json;
          src = builtins.path {
            path = ./.;
            name = "${projectName}-src";
            # Adjust the `filter` as necessary
            filter = path: ftype: !(pkgs.lib.hasSuffix ".md" path);
          };
          shell = {
            withRuntime = true;
            packageLockOnly = true;
            packages = with pkgs; [
              fd
              nodePackages.eslint
              nodePackages.prettier
            ];
          };
        };
    in
    {
      # `buildCtlRuntime` will generate a Nix expression that, when built with
      # `pkgs.arion.build`, outputs a JSON file compatible with Arion. This can
      # be run directly with Arion or passed to another derivation. Or you can
      # use `buildCtlRuntime` with `runArion` (from the `hercules-ci-effects`)
      # library
      #
      # Use `nix build .#<PACKAGE>` to build. To run with Arion (i.e. in your
      # shell): `arion --prebuilt-file ./result up`
      packages = perSystem (system:
        let
          pkgs = nixpkgsFor system;
        in
        {
          default = self.packages.${system}.ctl-scaffold-bundle-web;

          ctl-scaffold-bundle-web-esbuild = (psProjectFor pkgs).bundlePursProjectEsbuild {
            main = "Scaffold.Main";
          };

          ctl-scaffold-bundle-web-webpack = (psProjectFor pkgs).bundlePursProjectWebpack {
            main = "Scaffold.Main";
          };

          ctl-scaffold-runtime = pkgs.buildCtlRuntime runtimeConfig;
        });


      # `launchCtlRuntime` will generate a Nix expression from the provided
      # config, build it into a JSON file, and then run it with Arion
      #
      # Use `nix run .#<APP>` to run the services (e.g. `nix run .#ctl-runtime`)
      apps = perSystem (system:
        let
          pkgs = nixpkgsFor system;
        in
        {
          default = self.apps.${system}.ctl-scaffold-runtime;
          ctl-scaffold-runtime = pkgs.launchCtlRuntime runtimeConfig;
          ctl-scaffold-blockfrost-runtime = pkgs.launchCtlRuntime
            (pkgs.lib.recursiveUpdate runtimeConfig { blockfrost = { enable = true; }; });
          docs = (psProjectFor pkgs).launchSearchablePursDocs { };
        });

      checks = perSystem (system:
        let
          pkgs = nixpkgsFor system;
        in
        {
          ctl-scaffold-local-testnet-test = (psProjectFor pkgs).runLocalTestnetTest {
            testMain = "Test.Scaffold.Main";
          };

          formatting-check = pkgs.runCommand "formatting-check"
            {
              nativeBuildInputs = with pkgs; [
                fd
                easy-ps.purs-tidy
                nixpkgs-fmt
                nodePackages.prettier
              ];
            }
            ''
              cd ${self}
              purs-tidy check $(fd -epurs)
              nixpkgs-fmt --check $(fd -enix --exclude='spago*')
              prettier -c $(fd -ejs)
              touch $out
            '';

          js-lint-check = pkgs.runCommand "js-lint-check"
            {
              nativeBuildInputs = [ pkgs.nodePackages.eslint pkgs.fd ];
            }
            ''
              cd ${self}
              eslint $(fd -ejs)
              touch $out
            '';
        });

      devShells = perSystem (system:
        let
          pkgs = nixpkgsFor system;
        in
        {
          default = (psProjectFor pkgs).devShell;
        });
    };
}