@dbx-tools/projen 0.9.19 → 0.9.28

package/tasks/publish-uniffi-local.ts

@@ -1,314 +0,0 @@
-#!/usr/bin/env -S bun
-import { chmodSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { arch, platform } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-import { json, log, object } from "@dbx-tools/shared-core";
-import { parse, stringify } from "smol-toml";
-import { captureTaskCommand, runTaskCommand, taskCommandSucceeds } from "../src/_task-command.ts";
-import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
-import type { RustBindingMapping, RustWorkspaceMapping } from "../src/project-rs.ts";
-
-const logger = log.logger("projen:publish-uniffi-local");
-
-const parsed = parseArgs({
-  options: {
-    version: { type: "string" },
-    registry: { type: "string" },
-    "pypi-publish-url": { type: "string" },
-    "cargo-registry": { type: "string" },
-  },
-});
-
-function run(command: string, args: string[], capture = false): string {
-  if (capture) return captureTaskCommand(repoRoot, command, args, { check: true });
-  runTaskCommand(repoRoot, command, args);
-  return "";
-}
-
-function commandAvailable(command: string): boolean {
-  return taskCommandSucceeds(repoRoot, command, ["--version"]);
-}
-
-function rustHost(): string {
-  const host = run("rustc", ["-vV"], true).match(/^host:\s+(.+)$/m)?.[1];
-  if (!host) throw new Error("Unable to detect the local Rust target from rustc -vV");
-  return host;
-}
-
-function pythonTag(): string {
-  const value = run(
-    "uv",
-    [
-      "run",
-      "--no-project",
-      "python",
-      "-c",
-      "import sysconfig; print(sysconfig.get_platform().replace('-', '_').replace('.', '_'))",
-    ],
-    true,
-  );
-  if (!value) throw new Error("Unable to detect the local Python wheel platform tag");
-  return value;
-}
-
-function nativeTarget(): {
-  cpu: "arm64" | "x64";
-  libc?: "glibc";
-  node: string;
-  os: "darwin" | "linux" | "win32";
-} {
-  const os = platform();
-  const machine = arch();
-  const cpu = machine === "arm64" ? "arm64" : machine === "x64" ? "x64" : undefined;
-  if (!cpu) throw new Error(`Unsupported local architecture: ${machine}`);
-  if (os === "darwin") return { os, cpu, node: `darwin-${cpu}` };
-  if (os === "win32") return { os, cpu, node: `win32-${cpu}-msvc` };
-  if (os === "linux") {
-    const libc = rustHost().includes("musl") ? undefined : "glibc";
-    return { os, cpu, node: `linux-${cpu}-${libc ? "gnu" : "musl"}`, ...(libc ? { libc } : {}) };
-  }
-  throw new Error(`Unsupported local platform: ${os}`);
-}
-
-function rustConfig(): RustWorkspaceMapping | undefined {
-  const value = readDbxToolsConfig(repoRoot)?.rust;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-  const config = value as Partial<RustWorkspaceMapping>;
-  return Array.isArray(config.bindings) ? (config as RustWorkspaceMapping) : undefined;
-}
-
-function artifacts(directory: string, suffix: string): string[] {
-  if (!existsSync(directory)) return [];
-  return readdirSync(directory)
-    .filter((name) => name.endsWith(suffix))
-    .map((name) => join(directory, name));
-}
-
-function cargoVersionExists(crateName: string, version: string, registry: string): boolean {
-  return taskCommandSucceeds(repoRoot, "cargo", [
-    "info",
-    `${crateName}@${version}`,
-    "--registry",
-    registry,
-  ]);
-}
-
-interface CargoMetadataPackage {
-  dependencies: Array<{ name: string; source?: string | null }>;
-  manifest_path: string;
-  name: string;
-}
-
-function orderedCargoManifests(config: RustWorkspaceMapping): string[] {
-  const configured = new Set(config.crates.map((crate) => resolve(repoRoot, crate, "Cargo.toml")));
-  const metadata = json.parseRecord(
-    run("cargo", ["metadata", "--format-version", "1", "--no-deps", "--locked"], true),
-  );
-  if (!metadata || !Array.isArray(metadata.packages)) {
-    throw new Error("Cargo metadata did not return workspace packages");
-  }
-  const packages = metadata.packages.filter(object.isRecord).map((pkg) => {
-    if (
-      typeof pkg.name !== "string" ||
-      typeof pkg.manifest_path !== "string" ||
-      !Array.isArray(pkg.dependencies)
-    ) {
-      throw new Error("Cargo metadata returned an invalid package");
-    }
-    return {
-      name: pkg.name,
-      manifest_path: resolve(pkg.manifest_path),
-      dependencies: pkg.dependencies.filter(object.isRecord).map((dependency) => {
-        if (typeof dependency.name !== "string") {
-          throw new Error(`Cargo metadata returned an invalid dependency for ${pkg.name}`);
-        }
-        return {
-          name: dependency.name,
-          source: typeof dependency.source === "string" ? dependency.source : null,
-        };
-      }),
-    } satisfies CargoMetadataPackage;
-  });
-  const publishable = new Map(
-    packages
-      .filter((pkg) => configured.has(pkg.manifest_path))
-      .filter((pkg) => {
-        const manifest = parse(readFileSync(pkg.manifest_path, "utf8")) as {
-          package?: { publish?: boolean };
-        };
-        return manifest.package?.publish !== false;
-      })
-      .map((pkg) => [pkg.name, pkg]),
-  );
-  const ordered: CargoMetadataPackage[] = [];
-  const visiting = new Set<string>();
-  const completed = new Set<string>();
-  const visit = (pkg: CargoMetadataPackage): void => {
-    if (completed.has(pkg.name)) return;
-    if (visiting.has(pkg.name)) {
-      throw new Error(`Cyclic Cargo publication dependency: ${pkg.name}`);
-    }
-    visiting.add(pkg.name);
-    for (const dependency of pkg.dependencies) {
-      if (dependency.source) continue;
-      const workspaceDependency = publishable.get(dependency.name);
-      if (workspaceDependency) visit(workspaceDependency);
-    }
-    visiting.delete(pkg.name);
-    completed.add(pkg.name);
-    ordered.push(pkg);
-  };
-  for (const pkg of publishable.values()) visit(pkg);
-  return ordered.map((pkg) => pkg.manifest_path);
-}
-
-function publishCargo(config: RustWorkspaceMapping, registry: string, version: string): void {
-  const manifests = orderedCargoManifests(config);
-  const originals = new Map(
-    manifests.map((manifest) => [manifest, readFileSync(manifest, "utf8")]),
-  );
-  try {
-    const crateNames = manifests.map((manifest) => {
-      const document = parse(readFileSync(manifest, "utf8")) as {
-        package?: { name?: string };
-      };
-      if (!document.package?.name) {
-        throw new Error(`Cargo manifest has no package name: ${manifest}`);
-      }
-      return document.package.name;
-    });
-    for (const manifest of manifests) {
-      const mode = statSync(manifest).mode;
-      const document = parse(readFileSync(manifest, "utf8")) as Record<string, unknown>;
-      for (const crateName of crateNames) {
-        if (!crateName) continue;
-        for (const sectionName of ["dependencies", "dev-dependencies", "build-dependencies"]) {
-          const section = document[sectionName];
-          if (!section || typeof section !== "object" || Array.isArray(section)) continue;
-          const dependency = (section as Record<string, unknown>)[crateName];
-          if (!dependency || typeof dependency !== "object" || Array.isArray(dependency)) {
-            continue;
-          }
-          (dependency as Record<string, unknown>).registry = registry;
-        }
-      }
-      chmodSync(manifest, mode | 0o200);
-      writeFileSync(manifest, `${stringify(document).trimEnd()}\n`);
-      chmodSync(manifest, mode);
-    }
-    for (const crateName of crateNames) {
-      if (!crateName) continue;
-      if (cargoVersionExists(crateName, version, registry)) {
-        logger.info(`skip published ${crateName} @ ${version}`);
-        continue;
-      }
-      run("cargo", [
-        "publish",
-        "--package",
-        crateName,
-        "--registry",
-        registry,
-        "--allow-dirty",
-        "--no-verify",
-      ]);
-    }
-  } finally {
-    for (const [manifest, source] of originals) {
-      const mode = statSync(manifest).mode;
-      chmodSync(manifest, mode | 0o200);
-      writeFileSync(manifest, source);
-      chmodSync(manifest, mode);
-    }
-  }
-}
-
-function buildAndPublish(binding: RustBindingMapping, version: string): void {
-  const registry = parsed.values.registry;
-  const pypiPublishUrl = parsed.values["pypi-publish-url"];
-  const includeNode = Boolean(registry && binding.node && binding.nodePackage);
-  const includePython = Boolean(pypiPublishUrl && binding.python && binding.pythonPackage);
-  if (!includeNode && !includePython) return;
-
-  const target = nativeTarget();
-  const output = resolve(repoRoot, "dist/uniffi");
-  run("node", [
-    resolve(dirname(fileURLToPath(import.meta.url)), "uniffi-release.mjs"),
-    "build",
-    "--crate",
-    binding.crate,
-    "--node",
-    includeNode ? binding.node! : "",
-    "--python",
-    includePython ? binding.python! : "",
-    "--node-package",
-    includeNode ? binding.nodePackage! : "",
-    "--python-package",
-    includePython ? binding.pythonPackage! : "",
-    "--python-module",
-    includePython ? binding.pythonModule! : "",
-    "--cargo-target",
-    rustHost(),
-    "--node-triple",
-    target.node,
-    "--python-tag",
-    pythonTag(),
-    "--os",
-    target.os,
-    "--cpu",
-    target.cpu,
-    "--libc",
-    target.libc ?? "",
-    "--facade",
-    "true",
-    "--version",
-    version,
-    "--output",
-    "dist/uniffi",
-  ]);
-
-  if (includeNode) {
-    const publishNpmScript = resolve(dirname(fileURLToPath(import.meta.url)), "publish-npm.ts");
-    for (const directory of [join(output, "npm"), join(output, "npm-facade")]) {
-      if (artifacts(directory, ".tgz").length === 0) continue;
-      run(process.execPath, [
-        publishNpmScript,
-        "--directory",
-        directory,
-        "--version",
-        version,
-        "--registry",
-        registry!,
-      ]);
-    }
-  }
-  if (includePython) {
-    const wheels = artifacts(join(output, "python"), ".whl");
-    if (wheels.length === 0) throw new Error(`No wheel produced for ${binding.crate}`);
-    run("uvx", [
-      "--from",
-      "devpi-client",
-      "devpi",
-      "upload",
-      "--index",
-      pypiPublishUrl!,
-      "--from-dir",
-      join(output, "python"),
-    ]);
-  }
-}
-
-const version = parsed.values.version;
-if (!version) throw new Error("Missing --version");
-const config = rustConfig();
-if (config?.bindings.length) {
-  if (!commandAvailable("cargo") || !commandAvailable("rustc")) {
-    throw new Error("Cargo and rustc are required because UniFFI Rust projects were detected");
-  }
-  for (const binding of config.bindings) buildAndPublish(binding, version);
-}
-const cargoRegistry = parsed.values["cargo-registry"];
-if (cargoRegistry && config?.crates.length) {
-  publishCargo(config, cargoRegistry, version);
-}