dynix/package.nix

# SPDX-FileCopyrightText: 2026 Qyriad <qyriad@qyriad.me>
#
# SPDX-License-Identifier: EUPL-1.1

{
  lib,
  clangStdenv,
  callPackage,
  linkFarm,
  rustHooks,
  rustPackages,
  versionCheckHook,
  writeScript,
}: lib.callWith' rustPackages ({
  rustPlatform,
  cargo,
}: let
  stdenv = clangStdenv;
  cargoToml = lib.importTOML ./Cargo.toml;
  cargoPackage = cargoToml.package;
in stdenv.mkDerivation (finalAttrs: let
  self = finalAttrs.finalPackage;
in {
  pname = cargoPackage.name;
  version = cargoPackage.version;

  strictDeps = true;
  __structuredAttrs = true;

  outputs = [ "out" "modules" ];

  # These are propagated to sub-derivations.
  doCheck = true;
  doInstallCheck = true;

  buildCommand = ''
    mkdir -p "$out"
    cp -r --reflink=auto "$dynixCommand/"* "$out/"
    mkdir -p "$modules"
    cp -r --reflink=auto "$dynixModules/"* "$modules/"
    install -Dm a=rx "$dynixTestingClient" "$out/libexec/dynix-testing-client.py"
  '';

  #
  # SUB-DERIVATONS
  #

  dynixTestingClient = writeScript "dynix-testing-client.py" ''
    #!/usr/bin/env python3
    import socket, sys, os, json
    try:
        sockpath = sys.argv[1]
    except IndexError:
        sockpath = f"{os.environ['XDG_RUNTIME_DIR']}/dynix.sock"
    sock = socket.socket(family=socket.AF_UNIX)
    sock.connect(sockpath)
    sock.sendall(sys.stdin.buffer.read())
    sock.settimeout(20)
    reply = json.loads(sock.recv(256).decode("utf-8"))
    print(json.dumps(reply, indent=2))
    sys.exit(reply["status"])
  '';

  dynixCommand = stdenv.mkDerivation {
    pname = "${self.pname}-command";
    inherit (self) version;
    inherit (self) strictDeps __structuredAttrs;
    inherit (self) doCheck doInstallCheck;

    outputs = [ "out" "doc" ];

    src = lib.fileset.toSource {
      root = ./.;
      fileset = lib.fileset.unions [
        ./Cargo.toml
        ./Cargo.lock
        ./src
      ];
    };

    cargoDeps = rustPlatform.importCargoLock {
      lockFile = ./Cargo.lock;
    };

    postInstall = ''
      cargo doc --document-private-items
      mkdir -p "$doc"
      cp -r ./target/doc/* "$doc/"
    '';

    nativeBuildInputs = rustHooks.asList ++ [
      cargo
    ];

    nativeInstallCheckInputs = [
      versionCheckHook
    ];

    meta = {
      mainProgram = "dynix";
      description = "The Rust part of Dynix";
      inherit (self.meta) license;
    };
  };

  dynixModules = stdenv.mkDerivation {
    pname = "${self.pname}-modules";
    inherit (self) version;
    inherit (self) strictDeps __structuredAttrs;
    inherit (self) doCheck doInstallCheck;

    src = lib.fileset.toSource {
      root = ./modules/dynamicism;
      fileset = lib.fileset.unions [
        ./modules/dynamicism
      ];
    };

    phases = [ "unpackPhase" "patchPhase" "installPhase" ];

    modulesOut = "${placeholder "out"}/share/nixos/modules/dynix";

    installPhase = lib.dedent ''
      runHook preInstall

      mkdir -p "$modulesOut"
      cp -r "$src/"* "$modulesOut/"

      runHook postInstall
    '';

    meta = {
      description = "The NixOS modules part of Dynix";
      inherit (self.meta) license;
    };
  };

  #
  # ----------------------------------------------------------------------------
  #

  passthru.mkDevShell = {
    path,
    mkShell,
    python3Packages,
    fenixToolchain,
    cargo,
  }: let
    mkShell' = mkShell.override { inherit stdenv; };
    pyEnv = python3Packages.python.withPackages (p: [ p.beartype ]);
    # Fenix's Cargo doesn't have completions, but Nixpkgs' does.
    cargoCompletions = linkFarm "cargo-bash-completions" {
      "share/bash-completion" = cargo + "/share/bash-completion";
    };
  in mkShell' {
    name = "devshell-for-${self.name}";
    inputsFrom = [ self ];
    packages = [
      pyEnv
      stdenv.cc
      fenixToolchain
      cargoCompletions
    ];
    env.PYTHONPATH = [
      "${pyEnv}/${pyEnv.sitePackages}"
      # Cursed.
      "${path}/nixos/lib/test-driver/src"
    ] |> lib.concatStringsSep ":";

    passthru = { inherit cargoCompletions; };
  };

  passthru.modulesPath = self.modules + "/share/nixos/modules";
  passthru.dynix = self.modulesPath + "/dynix";

  passthru.tests = lib.fix (callPackage ./tests {
    dynix = self;
  }).packages;

  passthru.allTests = linkFarm "dynix-all-tests" self.tests;

  meta = {
    longDescription = lib.dedent ''
      Default output contains the Rust binary.
      The `modules` output contains the modules prefixed under `/share/nixos/modules/dynix`.
      The `dynix` passthru attr is a shortcut for the modules output *with* the modules prefix,
      and thus `dynix.dynix` can be passed directly to `imports = [`.
    '';
    license = with lib.licenses; [ eupl12 ];
    mainProgram = "dynix";
    outputsToInstall = [ "out" "modules" ];
  };
}))