{
  description = "A very basic flake";

  inputs = {
    nixpkgs.url = "flake:nixpkgs";
    crane.url = "github:ipetkov/crane";
  };

  outputs =
    {
      self,
      nixpkgs,
      crane,
    }:
    let
      inherit (nixpkgs) lib;
      src = lib.fileset.toSource {
        root = ./.;
        fileset =
          with lib.fileset;
          intersection (gitTracked ./.) (unions [
            (fileFilter (
              file:
              file.type == "directory"
              || file.hasExt "rs"
              || file.hasExt "toml"
              || file.name == "Cargo.lock"
              || file.hasExt "sql"
              || file.name == "openapi-def.yaml"
              || file.hasExt "html"
            ) ./.)
          ]);
      };

      forAllSystems =
        function:
        nixpkgs.lib.genAttrs
          [
            "x86_64-linux"
            "aarch64-linux"
          ]
          (
            system:
            function (
              import nixpkgs {
                inherit system;
                overlays = [
                  (_: final: overlay final)
                ];
              }
            )
          );
      overlay =
        pkgs:
        let
          buildCraneLib = crane.mkLib pkgs.buildPackages;

          commonArgs = pkgs: {
            inherit src;
            strictDeps = true;

            nativeBuildInputs = [ pkgs.buildPackages.pkg-config ];

            env.OPENSSL_NO_VENDOR = true;

            buildInputs = [ pkgs.openssl ];

            # PKG_CONFIG_ALLOW_CROSS = if pkgs.stdenv.buildPlatform != pkgs.stdenv.hostPlatform then 1 else 0;

            doCheck = false;
          };

          openapi = buildCraneLib.buildPackage (
            let
              common = (commonArgs pkgs.buildPackages);
            in
            common
            // {
              cargoArtifacts = buildCraneLib.buildDepsOnly common;

              pnameSuffix = "-openapi.json";

              nativeBuildInputs =
                common.nativeBuildInputs
                ++ (with pkgs.buildPackages; [
                  yq-go
                  redocly
                ]);

              cargoExtraArgs = "--bin generate-schemas";

              preBuild = ''
                touch openapi.json
              '';

              installPhaseCommand = ''
                ''${CARGO_TARGET_DIR:-target}/$CARGO_PROFILE/generate-schemas
                rm -rf target
                yq eval-all -n 'load("openapi-def.yaml") *n load("schemas/schemas.json")' > openapi-temp.yaml
                redocly bundle openapi-temp.yaml -o openapi.json
                cp openapi.json $out
              '';
            }
          );

          bankserver = pkgs.callPackage ./package.nix {
            inherit src openapi;
            commonArgs = commonArgs pkgs;
            craneLib = crane.mkLib pkgs;
          };
        in
        {
          inherit bankserver;
          bankserverDocker = pkgs.dockerTools.buildLayeredImage {
            name = "bankserver";
            # tag = "latest";
            created = "now";
            contents = [
              bankserver
              pkgs.catatonit
              pkgs.cacert
            ];
            config = {
              Env = [ "HOST=::" ];
              # Entrypoint = ["/bin/bankserver"];
              Entrypoint = [
                "/bin/catatonit"
                "--"
              ];
              Cmd = [ "/bin/bankserver" ];
              ExposedPorts = {
                "3845/tcp" = { };
              };
            };
          };
        };
    in
    {
      packages = forAllSystems (pkgs: {
        default = pkgs.bankserver;
        dockerImage = pkgs.bankserverDocker;
        dockerImage-cross-aarch64-linux = pkgs.pkgsCross.aarch64-multiplatform.bankserverDocker;
      });
      devShells = forAllSystems (pkgs: {
        default = pkgs.mkShell {
          packages = with pkgs; [
            hurl
            redocly
            yq-go
            just
            pkg-config
            openssl
          ];
        };
      });
    };
}