macltok

{

  inputs = {

    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";

    fenix = {

      url = "github:nix-community/fenix";

      inputs.nixpkgs.follows = "nixpkgs";

    };

  };

  outputs =

    {

      self,

      nixpkgs,

      fenix,

    }:

    let

      forAllSystems = nixpkgs.lib.genAttrs nixpkgs.lib.systems.flakeExposed;

      webManifest = builtins.fromTOML (builtins.readFile ./harness/web/Cargo.toml);

      storeFeature = nixpkgs.lib.removePrefix "macltok/" (builtins.head webManifest.features.store);

      webLock = builtins.fromTOML (builtins.readFile ./harness/web/Cargo.lock);

      lockedVersion =

        name: (nixpkgs.lib.findFirst (p: p.name == name) null webLock.package).version;

      # wasm-bindgen-test-runner refuses a module built by any other wasm-bindgen version

      wasmBindgenCli =

        pkgs:

        pkgs.buildWasmBindgenCli rec {

          src = pkgs.fetchCrate {

            pname = "wasm-bindgen-cli";

            version = lockedVersion "wasm-bindgen";

            hash = "sha256-a7lcXJnnZkYReja+iUO7NqqrWyv3toxnUgQb8s4IS5s=";

          };

          cargoDeps = pkgs.rustPlatform.fetchCargoVendor {

            inherit src;

            inherit (src) pname version;

            hash = "sha256-R1Tas33Ursy8kqsxguAkG0ZhNed2n5uFTAhw1l2qlLY=";

          };

        };

      wasmToolchain =

        system:

        let

          toolchains = fenix.packages.${system};

        in

        toolchains.combine [

          toolchains.stable.cargo

          toolchains.stable.clippy

          toolchains.stable.rustc

          toolchains.stable.rustfmt

          toolchains.stable.rust-src

          toolchains.targets.wasm32-unknown-unknown.stable.rust-std

        ];

    in

    {

      packages = forAllSystems (

        system:

        let

          pkgs = nixpkgs.legacyPackages.${system};

        in

        {

          default = pkgs.rustPlatform.buildRustPackage {

            pname = "macltok";

            version = "0.1.0";

            src = self;

            cargoLock.lockFile = ./Cargo.lock;

            preBuild = "export NIX_BUILD_CORES=2";

            SSL_CERT_FILE = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";

          };

        }

      );

      checks = forAllSystems (

        system:

        let

          pkgs = nixpkgs.legacyPackages.${system};

          toolchain = wasmToolchain system;

          wasmPlatform = pkgs.makeRustPlatform {

            cargo = toolchain;

            rustc = toolchain;

          };

          # continuwuity refuses to start without /etc/resolv.conf, which the build sandbox lacks, or with

          # stdenv's deliberately bogus SSL_CERT_FILE. no exec, run.nu launches through a shell that exits at

          # once and would trip --die-with-parent, so this shell stays as the parent run.nu kills

          sandboxedHomeserver = pkgs.writeShellScriptBin "conduwuit" ''

            export SSL_CERT_FILE=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt

            ${pkgs.lib.getExe pkgs.bubblewrap} --die-with-parent --dev-bind / / --tmpfs /etc \

              --ro-bind ${pkgs.writeText "resolv.conf" "nameserver 127.0.0.1\n"} /etc/resolv.conf \

              ${pkgs.lib.getExe' pkgs.matrix-continuwuity "conduwuit"} "$@"

          '';

        in

        {

          default = self.packages.${system}.default;

          sqlite = pkgs.rustPlatform.buildRustPackage {

            pname = "macltok-sqlite-check";

            version = "0.1.0";

            src = self;

            cargoLock.lockFile = ./Cargo.lock;

            preBuild = "export NIX_BUILD_CORES=2";

            buildFeatures = [

              "sqlite"

              "mirror"

            ];

            nativeBuildInputs = [ pkgs.pkg-config ];

            buildInputs = [ pkgs.sqlite ];

            SSL_CERT_FILE = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";

          };

          wasm = wasmPlatform.buildRustPackage {

            pname = "macltok-wasm-check";

            version = "0.1.0";

            src = self;

            cargoLock.lockFile = ./Cargo.lock;

            buildPhase = ''

              runHook preBuild

              cargo check --offline --frozen --lib --target wasm32-unknown-unknown -j 2

              cargo check --offline --frozen --lib \

                --target wasm32-unknown-unknown --features ${storeFeature},mirror -j 2

              runHook postBuild

            '';

            doCheck = false;

            installPhase = "touch $out";

          };

          web = wasmPlatform.buildRustPackage {

            pname = "macltok-web-check";

            version = "0.1.0";

            src = self;

            cargoRoot = "harness/web";

            cargoLock.lockFile = ./harness/web/Cargo.lock;

            nativeBuildInputs = with pkgs; [

              (wasmBindgenCli pkgs)

              firefox

              geckodriver

              sandboxedHomeserver

              nushell

            ];

            buildPhase = ''

              runHook preBuild

              export HOME=$TMPDIR

              nu --no-config-file harness/web/run.nu

              runHook postBuild

            '';

            doCheck = false;

            installPhase = "touch $out";

          };

        }

      );

      devShells = forAllSystems (

        system:

        let

          pkgs = nixpkgs.legacyPackages.${system};

        in

        {

          default = pkgs.mkShell {

            packages = with pkgs; [

              cargo

              clippy

              pkg-config

              rust-analyzer

              rustc

              rustfmt

              sqlite

            ];

          };

          web = pkgs.mkShell {

            packages = with pkgs; [

              (wasmToolchain system)

              (wasmBindgenCli pkgs)

              binaryen

              brotli

              firefox

              geckodriver

              matrix-continuwuity

              nushell

            ];

            MACLTOK_STORE_FEATURE = storeFeature;

          };

        }

      );

    };

}