surrealpatch/flake.nix

{
  description = "A scalable, distributed, collaborative, document-graph database, for the realtime web";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11-small";
    flake-utils.url = "github:numtide/flake-utils/v1.0.0";
    crane = {
      url = "github:ipetkov/crane/v0.16.3";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-compat = {
      url = "github:edolstra/flake-compat";
      flake = false;
    };
  };

  outputs =
    inputs:
    with inputs;

    # Make systems available as variables to prevent typos
    with flake-utils.lib.system;

    # let-in expressions, very similar to Rust's let bindings.  These names
    # are used to express the output but not themselves paths in the output.
    let

      nativeSystems = [
        aarch64-darwin
        aarch64-linux
        x86_64-darwin
        x86_64-linux
      ];

    in
    # Build the output set for each default system and map system sets into
    # attributes, resulting in paths such as:
    # nix build .#packages.x86_64-linux.<name>
    flake-utils.lib.eachSystem nativeSystems (
      system:

      let

        pkgs = import nixpkgs { inherit system; };

        util = import ./pkg/nix/util.nix {
          inherit system;
          inherit (pkgs) lib;
          systems = flake-utils.lib.system;
          flake = self;
        };

        mkRustToolchain =
          {
            target,
            extraComponents ? [ ],
          }:
          with fenix.packages.${system};
          combine (
            [
              stable.rustc
              stable.cargo
              targets.${target}.stable.rust-std
            ]
            ++ extraComponents
          );

        buildPlatform = pkgs.stdenv.buildPlatform.config;

      in
      # Make platforms available as variables to prevent typos
      with util.platforms;

      rec {
        packages =
          {
            # nix build
            default = packages.${buildPlatform} or packages.x86_64-unknown-linux-gnu;

            # nix build .#docker-image
            docker-image = import ./pkg/nix/drv/docker.nix {
              inherit util;
              inherit (pkgs) cacert dockerTools;
              package = packages.x86_64-unknown-linux-gnu;
            };

            # nix build .#static-binary
            static-binary = packages.x86_64-unknown-linux-musl;

            # nix build .#wasm
            wasm = packages.wasm32-unknown-unknown;

            # nix build .#windows-binary
            windows-binary = packages.x86_64-pc-windows-gnu;
          }
          // (pkgs.lib.attrsets.mapAttrs (
            target: _:
            let
              spec = import ./pkg/nix/spec/${target}.nix { inherit pkgs target util; };
            in
            import ./pkg/nix/drv/binary.nix {
              inherit
                pkgs
                util
                spec
                crane
                ;
              rustToolchain = mkRustToolchain { inherit target; };
            }
          ) util.platforms);

        devShells =
          {
            # nix develop
            default = devShells.${buildPlatform} or devShells.x86_64-unknown-linux-gnu;

            # nix develop .#static-binary
            static-binary = devShells.x86_64-unknown-linux-musl;

            # nix develop .#wasm
            wasm = devShells.wasm32-unknown-unknown;

            # nix develop .#windows-binary
            windows-binary = devShells.x86_64-pc-windows-gnu;
          }
          // (pkgs.lib.attrsets.mapAttrs (
            target: _:
            let
              spec = (import ./pkg/nix/spec/${target}.nix) { inherit pkgs target util; };
              extraComponents = with fenix.packages.${system}; [
                targets.${target}.stable.rust-src
                rust-analyzer
                targets.${target}.stable.rustfmt
              ];
              rustToolchain = mkRustToolchain { inherit target extraComponents; };
              buildSpec = spec.buildSpec;
            in
            pkgs.mkShell (
              buildSpec
              // {
                hardeningDisable = [ "fortify" ];

                depsBuildBuild =
                  buildSpec.depsBuildBuild or [ ]
                  #++ [ rustToolchain ]
                  ++ (with pkgs; [
                    nixfmt
                    cargo-watch
                    wasm-pack
                    pre-commit
                    cargo-make
                  ]);

                inherit (util) SURREAL_BUILD_METADATA;
              }
            )
          ) util.platforms);

        # nix run
        apps.default = flake-utils.lib.mkApp { drv = packages.default; };

      }
    );
}