fedimint-observer/flake.nix at 51d69dc73d6def690d3af9f976b65cd2cd2da310 · fedibtc/fedimint-observer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    flakebox = {
      url = "github:rustshop/flakebox";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = { self, nixpkgs, flake-utils, flakebox }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs {
          inherit system;
        };
        flakeboxLib = flakebox.lib.${system} { };
        lib = pkgs.lib;
        stdenv = pkgs.stdenv;

        toolchains = flakeboxLib.mkFenixToolchain {
          components = [
            "rustc"
            "cargo"
            "clippy"
            "rust-analyzer"
            "rust-src"
          ];

          args = {
            nativeBuildInputs = with pkgs; [
              wasm-bindgen-cli
              wasm-pack
              trunk
              nodejs
              nodePackages.tailwindcss
            ];
          };
          targets = (pkgs.lib.getAttrs
            ([
              "default"
              "wasm32-unknown"
            ])
            (flakeboxLib.mkStdTargets { })
          );
        };

        rustSrc = flakeboxLib.filterSubPaths {
          root = builtins.path {
            name = "fmo";
            path = ./.;
          };
          paths = [
            "Cargo.toml"
            "Cargo.lock"
            ".cargo"
            "fmo_api_types"
            "fmo_server"
            "fmo_frontend"
            "tailwind.config.js"
          ];
        };

        nativePackages =
          (flakeboxLib.craneMultiBuild { toolchains = { default = toolchains; }; }) (craneLib':
            let
              craneLib = (craneLib'.overrideArgs {
                pname = "fmo_server";
                version = "0.1.0";
                src = rustSrc;
                cargoExtraArgs = "--package=fmo_server --features=stability_pool_v1";
                RUSTFLAGS = "--cfg tokio_unstable";
              });
            in
            rec {
              workspaceDeps = craneLib.buildWorkspaceDepsOnly { };
              workspaceBuild = craneLib.buildWorkspace {
                cargoArtifacts = workspaceDeps;
              };
              fmo_server = craneLib.buildPackage { };
              fmo_server_image = pkgs.dockerTools.buildLayeredImage {
                name = "fmo_server";
                contents = [ fmo_server pkgs.bash pkgs.coreutils ];
                config = {
                  Cmd = [
                    "${fmo_server}/bin/fmo_server"
                  ];
                };
              };

            });

        wasmPackages =
          let
            craneLib = (flakeboxLib.mkStdToolchains { }).wasm32-unknown.craneLib;

            wasmArgs = {
              src = rustSrc;

              cargoExtraArgs = "--package=fmo_frontend";
              trunkIndexPath = "fmo_frontend/index.html";
              strictDeps = true;

              pname = "fmo_frontend";
              version = "0.1.0";

              # Specify the wasm32 target
              CARGO_BUILD_TARGET = "wasm32-unknown-unknown";
              RUSTFLAGS = "--cfg=web_sys_unstable_apis";
            };

            cargoArtifactsWasm = craneLib.buildDepsOnly (wasmArgs // {
              doCheck = false;
            });
          in
          rec {
            fmo_frontend = api: craneLib.buildTrunkPackage (wasmArgs // {
              nativeBuildInputs = with pkgs; [
                wasm-pack
                nodejs
                binaryen
                nodePackages.tailwindcss
              ];

              FMO_API_SERVER = api;

              wasm-bindgen-cli = pkgs.wasm-bindgen-cli.override {
                version = "0.2.92";
                hash = "sha256-1VwY8vQy7soKEgbki4LD+v259751kKxSxmo/gqE6yV0=";
                cargoHash = "sha256-aACJ+lYNEU8FFBs158G1/JG8sc6Rq080PeKCMnwdpH0=";
              };
            });
            fmo_frontend_default = fmo_frontend "http://localhost:3000";
          };
      in
      {
        devShells = flakeboxLib.mkShells {
          toolchain = toolchains;

          nativeBuildInputs = [
            pkgs.postgresql
            # sqlite is used only for creating the dump file for migrating existing instances
            pkgs.sqlite
          ] ++ lib.optionals stdenv.isDarwin [
            pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
          ];

          shellHook = ''
            source scripts/pg_dev/env.sh
            echo "Type 'just pg_start' to start the $PGDATABASE database, use 'pg' to connect to it"
          '';

          RUSTFLAGS = "--cfg=web_sys_unstable_apis --cfg=tokio_unstable";
        };

        legacyPackages = nativePackages // wasmPackages;
        packages.default = nativePackages.fmo_server;
      }
    );
}