syndicate-flake/flake.nix

{
  description = "Syndicate utilities";

  inputs = {
    nixpkgs.url = "github:ehmry/nixpkgs/nim";
    rust = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = { self, nixpkgs, rust }: {
    lib = nixpkgs.lib.extend (import ./lib.nix);

    overlays.default = final: prev:
      let
        rust' = (prev.extend rust.overlay).rust-bin.nightly.latest.default;

        nimOverlay = final': prev': {
          noiseprotocol = final'.callPackage ./packages/nim/noiseprotocol { };

          preserves = prev'.preserves.overrideAttrs (finalAttrs: prevAttrs: {
            pname = "preserves";
            version = "20230806";
            src = final.fetchFromGitea {
              domain = "git.syndicate-lang.org";
              owner = "ehmry";
              repo = "preserves-nim";
              rev = finalAttrs.version;
              hash = "sha256-kSIGqdcbrrdDiD7AbH0jOuqxywqbS7htBRBdJc1RO3U=";
            };
            nimFlags = [ "--path:${final'.nim.passthru.nim}/nim" ];
          });

          syndicate = prev'.syndicate.overrideAttrs (finalAttrs: prevAttrs: {
            version = "20230816";
            src = final.fetchFromGitea {
              domain = "git.syndicate-lang.org";
              owner = "ehmry";
              repo = "${finalAttrs.pname}-nim";
              rev = finalAttrs.version;
              hash = "sha256-0zZngM2OFicDNisZVAKMS1yOfgf3huL21uA4AU1lWMg=";
            };
            nimFlags = [ ];
          });

          syndicate_utils =
            final'.callPackage ./packages/syndicate_utils-nim { };
          syndicated-open = final'.callPackage ./packages/syndicated-open { };
          xdg_open_ng =
            builtins.trace "xdg_open_ng has been renamed to syndicated-open"
            final'.syndicated-open;
        };
      in {
        inherit (self) lib;

        acpi_actor = final.nim2Packages.callPackage ./packages/acpi_actor { };

        fontconfig_actor =
          final.nim2Packages.callPackage ./packages/fontconfig_actor { };

        libnotify_actor =
          final.nim2Packages.callPackage ./packages/libnotify_actor { };

        nimPackages = prev.nimPackages.overrideScope' nimOverlay;
        nim2Packages = prev.nim2Packages.overrideScope' nimOverlay;

        nix_actor = final.nim2Packages.callPackage ./packages/nix_actor { };

        noise-c = final.callPackage ./packages/noise-c { };

        python3Packages = prev.python3Packages.overrideScope (final': prev': {
          preserves = final'.callPackage ./packages/preserves-py { };
          syndicate = final'.callPackage ./packages/syndicate-py { };
        });

        preserves-tools =
          final.callPackage ./packages/preserves-tools { rust = rust'; };

        sqlite_actor =
          final.nim2Packages.callPackage ./packages/sqlite_actor { };

        squeak = final.callPackage ./packages/squeak { };
        squeaker = final.python3Packages.callPackage ./packages/squeaker { };

        syndicate-server =
          final.callPackage ./packages/syndicate-server { rust = rust'; };

        synit-pid1 = final.callPackage ./packages/synit-pid1 { rust = rust'; };

        xapian_actor =
          final.nim2Packages.callPackage ./packages/xapian_actor { };
      };

    legacyPackages =
      self.lib.mapAttrs (system: pkgs: pkgs.extend self.overlays.default) {
        inherit (nixpkgs.legacyPackages) x86_64-linux;
      };

    packages = self.lib.mapAttrs (system: pkgs:
      with pkgs; {
        inherit fontconfig_actor libnotify_actor noise-c preserves-tools squeak
          squeaker syndicate-server;
        inherit (nim2Packages) syndicate_utils xdg_open_ng;
        preserves-nim = nim2Packages.preserves;
        preserves-py = python3Packages.preserves;
        syndicate-nim = nim2Packages.syndicate;
        syndicate-py = python3Packages.syndicate;
      }) self.legacyPackages;

    nixosModules.default = self.nixosModules.syndicate-server;
    nixosModules.syndicate-server =
      # A little hack to apply our overlay to this module only.
      { config, lib, pkgs, ... }:
      (import ./nixos/syndicate-server.nix) {
        inherit config lib;
        pkgs = pkgs.extend self.overlays.default;
      };

    devShells = self.lib.mapAttrs (system: pkgs:
      with pkgs; {
        default =
          mkShell { packages = builtins.attrValues self.packages.${system}; };
      }) self.legacyPackages;

    checks = self.lib.mapAttrs (system: pkgs':
      with import (nixpkgs + "/nixos/lib/testing-python.nix") {
        inherit system;
        pkgs = pkgs';
      }; {
        simple = simpleTest {
          name = "http";
          nodes.machine = { config, pkgs, ... }: {
            imports = [ self.nixosModules.syndicate-server ];

            nixpkgs.pkgs = pkgs';

            services.syndicate.tty1 = {
              enable = true;
              user = "loser";
              config = [ ];
            };
            users.users.loser.isNormalUser = true;
          };
          testScript = ''
            machine.wait_for_job("syndicate-tty1")
          '';
        };
      }) { inherit (self.legacyPackages) x86_64-linux; };
  };
}