@dbx-tools/projen 0.9.21 → 0.9.29

package/tasks/uniffi-release.mjs

@@ -1,579 +0,0 @@
-#!/usr/bin/env node
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-import { parseArgs } from "node:util";
-import { spawnSync } from "node:child_process";
-import {
-  installPythonBindings,
-  preparePythonProjectForPublication,
-  pythonBindingGeneratorArgs,
-  pythonBindingGeneratorName,
-} from "./uniffi-python.js";
-
-const require = createRequire(import.meta.url);
-const bundledToml = fileURLToPath(new URL("./smol-toml.cjs", import.meta.url));
-const toml = require(existsSync(bundledToml) ? bundledToml : "smol-toml");
-
-const parsed = parseArgs({
-  allowPositionals: true,
-  options: {
-    root: { type: "string" },
-    crate: { type: "string" },
-    node: { type: "string" },
-    python: { type: "string" },
-    "node-package": { type: "string" },
-    "native-package": { type: "string" },
-    "python-package": { type: "string" },
-    "python-module": { type: "string" },
-    "python-bindings": { type: "string" },
-    "cargo-target": { type: "string" },
-    "generator-target": { type: "string" },
-    "node-triple": { type: "string" },
-    "python-tag": { type: "string" },
-    os: { type: "string" },
-    cpu: { type: "string" },
-    libc: { type: "string" },
-    facade: { type: "string" },
-    version: { type: "string" },
-    output: { type: "string" },
-    "skip-build": { type: "boolean" },
-  },
-});
-
-const required = (name) => {
-  const value = parsed.values[name];
-  if (!value) throw new Error(`Missing --${name}`);
-  return value;
-};
-
-const root = resolve(parsed.values.root ?? process.cwd());
-const commandInvocation = (command, args) => {
-  if (process.platform !== "win32" || command !== "npm") return { command, args };
-  const npmCli = resolve(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
-  if (!existsSync(npmCli)) throw new Error(`Missing npm CLI ${npmCli}`);
-  return { command: process.execPath, args: [npmCli, ...args] };
-};
-const run = (command, args, cwd = root) => {
-  const invocation = commandInvocation(command, args);
-  const result = spawnSync(invocation.command, invocation.args, { cwd, stdio: "inherit" });
-  if (result.error) {
-    throw new Error(`${invocation.command} failed: ${result.error.message}`, {
-      cause: result.error,
-    });
-  }
-  if (result.status !== 0) throw new Error(`${invocation.command} exited with ${result.status}`);
-};
-
-const runWithRetry = (command, args, cwd = root, attempts = 6) => {
-  const signal = new Int32Array(new SharedArrayBuffer(4));
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    const invocation = commandInvocation(command, args);
-    const result = spawnSync(invocation.command, invocation.args, { cwd, stdio: "inherit" });
-    if (result.error) {
-      throw new Error(`${invocation.command} failed: ${result.error.message}`, {
-        cause: result.error,
-      });
-    }
-    if (result.status === 0) return;
-    if (attempt === attempts) {
-      throw new Error(
-        `${invocation.command} exited with ${result.status} after ${attempts} attempts`,
-      );
-    }
-    Atomics.wait(signal, 0, 0, 10_000);
-  }
-};
-
-const singlePackage = (directory) => {
-  const packages = readdirSync(directory)
-    .filter((file) => file.endsWith(".tgz"))
-    .map((file) => resolve(directory, file));
-  if (packages.length !== 1) {
-    throw new Error(`Expected one npm package in ${directory}, found ${packages.length}`);
-  }
-  return packages[0];
-};
-
-const localWorkspacePackages = () => {
-  const manifest = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
-  const workspaces = Array.isArray(manifest.workspaces) ? manifest.workspaces : [];
-  return new Map(
-    workspaces.flatMap((directory) => {
-      const manifestPath = resolve(root, directory, "package.json");
-      if (!existsSync(manifestPath)) return [];
-      const workspaceManifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-      return workspaceManifest.name ? [[workspaceManifest.name, workspaceManifest.version]] : [];
-    }),
-  );
-};
-
-/**
- * Read one bundled facade's static imports so local workspace dependency stubs
- * expose every requested ESM name. Callable proxy values support module helpers
- * and base classes that execute while the facade is imported.
- */
-const importedNames = (source, packageName) => {
-  const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(`(?:^|\\n)import\\s+([^;]+?)\\s+from\\s+["']${escaped}["'];`, "g");
-  const names = new Set();
-  let hasDefault = false;
-  for (const match of source.matchAll(pattern)) {
-    const clause = match[1].trim();
-    const named = /\{([\s\S]*?)\}/.exec(clause)?.[1];
-    if (named) {
-      for (const specifier of named.split(",")) {
-        const name = specifier.trim().split(/\s+as\s+/)[0];
-        if (name) names.add(name);
-      }
-    }
-    const beforeNamed = clause.split(/[,{\s]/, 1)[0];
-    if (beforeNamed && beforeNamed !== "*" && !clause.startsWith("{")) hasDefault = true;
-  }
-  return { names: [...names].sort(), hasDefault };
-};
-
-const testNodeFacade = ({
-  facadeDirectory,
-  facadePackage,
-  manifest,
-  nativePackage,
-  nodePackage,
-}) => {
-  const installDirectory = mkdtempSync(join(tmpdir(), "uniffi-facade-install-"));
-  try {
-    const workspacePackages = localWorkspacePackages();
-    const facadeSource = readFileSync(join(facadeDirectory, "lib", "index.js"), "utf8");
-    const bindings =
-      JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dbxToolsConfig?.rust?.bindings ??
-      [];
-    const localDependencies = Object.keys(manifest.dependencies ?? {}).flatMap((name, index) => {
-      const workspaceVersion = workspacePackages.get(name);
-      if (!workspaceVersion) return [];
-      const binding = bindings.find((binding) => binding.nodePackage === name);
-      if (binding) {
-        const stagedFacade = resolve(root, "dist/uniffi/facades", binding.crate, "npm-facade");
-        const stagedNative = resolve(root, "dist/uniffi/native");
-        const nativeName = existsSync(stagedNative)
-          ? readdirSync(stagedNative).find((file) =>
-              file.startsWith(`${binding.crate}-${required("node-triple")}-`),
-            )
-          : undefined;
-        if (existsSync(stagedFacade) && nativeName) {
-          return [singlePackage(stagedFacade), join(stagedNative, nativeName)];
-        }
-        const output = resolve(root, "dist/release", binding.crate, required("node-triple"));
-        if (existsSync(join(output, "npm-facade")) && existsSync(join(output, "npm"))) {
-          return [singlePackage(join(output, "npm-facade")), singlePackage(join(output, "npm"))];
-        }
-        return [];
-      }
-      const directory = join(installDirectory, "local-dependencies", String(index));
-      mkdirSync(directory, { recursive: true });
-      writeFileSync(
-        join(directory, "package.json"),
-        `${JSON.stringify({
-          name,
-          version: workspaceVersion,
-          type: "module",
-          exports: "./index.js",
-        })}\n`,
-      );
-      const imports = importedNames(facadeSource, name);
-      writeFileSync(
-        join(directory, "index.js"),
-        [
-          "const stub = new Proxy(function () {}, { get: () => stub, apply: () => stub });",
-          ...imports.names.map((name) => `export const ${name} = stub;`),
-          ...(imports.hasDefault ? ["export default stub;"] : []),
-          "",
-        ].join("\n"),
-      );
-      return [directory];
-    });
-    writeFileSync(
-      join(installDirectory, "package.json"),
-      `${JSON.stringify({ private: true, type: "module" })}\n`,
-    );
-    runWithRetry(
-      "npm",
-      [
-        "install",
-        "--ignore-scripts",
-        "--no-audit",
-        "--no-fund",
-        "--package-lock=false",
-        facadePackage,
-        nativePackage,
-        ...localDependencies,
-      ],
-      installDirectory,
-    );
-    run("node", ["-e", `import(${JSON.stringify(nodePackage)})`], installDirectory);
-  } finally {
-    rmSync(installDirectory, { recursive: true, force: true });
-  }
-};
-
-/** Resolve workspace and generated catalog protocols for a publishable facade. */
-const facadeDependency = (name, dependency, catalog, workspaceVersions) => {
-  if (typeof dependency !== "string") return dependency;
-  if (dependency.startsWith("workspace:")) {
-    const version = workspaceVersions.get(name);
-    if (!version) throw new Error(`Missing workspace version for ${name}`);
-    return dependency === "workspace:*"
-      ? version
-      : `${dependency.slice("workspace:".length)}${version}`;
-  }
-  if (!dependency.startsWith("catalog:")) return dependency;
-  const resolved = catalog[name];
-  if (!resolved) throw new Error(`Missing root catalog entry for ${name}`);
-  return resolved;
-};
-
-const writable = (path) => {
-  if (existsSync(path)) chmodSync(path, statSync(path).mode | 0o200);
-};
-
-const cargoMetadata = spawnSync("cargo", ["metadata", "--format-version", "1", "--no-deps"], {
-  cwd: root,
-  encoding: "utf8",
-});
-if (cargoMetadata.error) {
-  throw new Error(`cargo metadata failed: ${cargoMetadata.error.message}`, {
-    cause: cargoMetadata.error,
-  });
-}
-if (cargoMetadata.status !== 0) {
-  throw new Error(`cargo metadata exited with ${cargoMetadata.status}`);
-}
-const cargoTargetRoot = JSON.parse(cargoMetadata.stdout).target_directory;
-if (typeof cargoTargetRoot !== "string" || !cargoTargetRoot) {
-  throw new Error("cargo metadata returned no target_directory");
-}
-
-const libraryPath = (crate, cargoTarget, os) => {
-  const name = crate.replaceAll("-", "_");
-  const extension = os === "darwin" ? "dylib" : os === "win32" ? "dll" : "so";
-  const prefix = os === "win32" ? "" : "lib";
-  return resolve(cargoTargetRoot, cargoTarget, "release", `${prefix}${name}.${extension}`);
-};
-
-const packageNode = ({
-  library,
-  output,
-  nodeDirectory,
-  nodePackage,
-  nodeTriple,
-  os,
-  cpu,
-  version,
-  facade,
-}) => {
-  const libraryFile = basename(library);
-  const sourceManifest = JSON.parse(
-    readFileSync(resolve(root, nodeDirectory, "package.json"), "utf8"),
-  );
-  const nativePackage = resolve(output, "native-node");
-  mkdirSync(nativePackage, { recursive: true });
-  cpSync(library, join(nativePackage, libraryFile));
-  writeFileSync(
-    join(nativePackage, "package.json"),
-    `${JSON.stringify(
-      {
-        name: `${nodePackage}-${nodeTriple}`,
-        version,
-        description: `Native ${nodeTriple} library for ${nodePackage}`,
-        repository: sourceManifest.repository,
-        license: "Apache-2.0",
-        os: [os],
-        cpu: [cpu],
-        ...(parsed.values.libc ? { libc: [parsed.values.libc] } : {}),
-        files: [libraryFile],
-      },
-      null,
-      2,
-    )}\n`,
-  );
-  mkdirSync(resolve(output, "npm"), { recursive: true });
-  run("npm", ["pack", "--pack-destination", resolve(output, "npm")], nativePackage);
-
-  if (!facade) return;
-  packageNodeFacade({
-    output,
-    nodeDirectory,
-    nodePackage,
-    version,
-    nativePackage: singlePackage(resolve(output, "npm")),
-  });
-};
-
-const packageNodeFacade = ({ output, nodeDirectory, nodePackage, version, nativePackage }) => {
-  const facadeDirectory = resolve(output, "facade-node");
-  rmSync(facadeDirectory, { recursive: true, force: true });
-  rmSync(resolve(output, "npm-facade"), { recursive: true, force: true });
-  mkdirSync(output, { recursive: true });
-  cpSync(resolve(root, nodeDirectory), facadeDirectory, { recursive: true });
-  rmSync(join(facadeDirectory, "dist"), { recursive: true, force: true });
-  const barrel = join(facadeDirectory, "index.ts");
-  const barrelVersion = /^export const PACKAGE_VERSION = "([^"]+)";$/m.exec(
-    readFileSync(barrel, "utf8"),
-  )?.[1];
-  if (barrelVersion !== version) {
-    throw new Error(`Facade PACKAGE_VERSION ${String(barrelVersion)} does not match ${version}`);
-  }
-  for (const file of readdirSync(join(facadeDirectory, "src"))) {
-    if (/\.(dll|dylib|so)$/.test(file)) {
-      rmSync(join(facadeDirectory, "src", file), { force: true });
-    }
-  }
-  const ffiBindings = join(facadeDirectory, "src", "_bindings-ffi.ts");
-  writable(ffiBindings);
-  const ffiSource = readFileSync(ffiBindings, "utf8");
-  const packageSource = ffiSource.replace(
-    /(\s+callerUrl: import\.meta\.url,\n)(\s+\}\);)/,
-    `$1      npmPackageBase: ${JSON.stringify(`${nodePackage}-`)},\n      tripleStyle: "node",\n$2`,
-  );
-  if (packageSource === ffiSource) {
-    throw new Error(`Could not configure native package lookup in ${ffiBindings}`);
-  }
-  writeFileSync(ffiBindings, packageSource);
-  const manifestPath = join(facadeDirectory, "package.json");
-  writable(manifestPath);
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  const workspaceManifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
-  const catalog = workspaceManifest.catalog ?? {};
-  const workspaceVersions = localWorkspacePackages();
-  if (manifest.version !== version) {
-    throw new Error(`Facade package version ${String(manifest.version)} does not match ${version}`);
-  }
-  if (manifest.private === true) throw new Error(`${manifest.name} is private`);
-  manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
-  manifest.optionalDependencies = Object.fromEntries(
-    Object.entries(manifest.optionalDependencies ?? {}).map(([name, dependency]) => {
-      if (dependency !== version) {
-        throw new Error(`${manifest.name} optional dependency ${name} does not match ${version}`);
-      }
-      return [name, dependency];
-    }),
-  );
-  manifest.dependencies = Object.fromEntries(
-    Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
-      name,
-      facadeDependency(name, dependency, catalog, workspaceVersions),
-    ]),
-  );
-  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-  // Node loads the facade from node_modules, so every TypeScript entry point
-  // must be emitted and advertised as JavaScript.
-  rmSync(join(facadeDirectory, "lib"), { recursive: true, force: true });
-  run(
-    "bun",
-    [
-      "build",
-      "index.ts",
-      "--outdir",
-      "lib",
-      "--target",
-      "node",
-      "--format",
-      "esm",
-      "--packages",
-      "external",
-    ],
-    facadeDirectory,
-  );
-  const compiledPublish = { ...(manifest.publishConfig ?? {}) };
-  delete compiledPublish.access;
-  Object.assign(manifest, compiledPublish);
-  manifest.types = "./index.ts";
-  manifest.exports["."].types = "./index.ts";
-  delete manifest.publishConfig;
-  delete manifest.scripts;
-  delete manifest.devDependencies;
-  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-  const facadeOutput = resolve(output, "npm-facade");
-  mkdirSync(facadeOutput, { recursive: true });
-  run("npm", ["pack", "--pack-destination", facadeOutput], facadeDirectory);
-  if (nativePackage) {
-    testNodeFacade({
-      facadeDirectory,
-      facadePackage: singlePackage(facadeOutput),
-      manifest,
-      nativePackage,
-      nodePackage,
-    });
-  }
-};
-
-const packagePython = ({
-  crate,
-  library,
-  output,
-  pythonDirectory,
-  pythonTag,
-  version,
-  cargoTarget,
-  generatorTarget,
-  os,
-  pythonModule,
-  pythonBindings,
-}) => {
-  const pythonRoot = resolve(output, "python-root");
-  cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
-  const pyproject = join(pythonRoot, "pyproject.toml");
-  writable(pyproject);
-  const workspaceBindings =
-    JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dbxToolsConfig?.rust?.bindings ??
-    [];
-  writeFileSync(
-    pyproject,
-    preparePythonProjectForPublication(readFileSync(pyproject, "utf8"), {
-      packages: workspaceBindings.flatMap((binding) =>
-        binding.pythonPackage && binding.python
-          ? [{ name: binding.pythonPackage, directory: binding.python }]
-          : [],
-      ),
-      toml,
-      version,
-    }),
-  );
-  installPythonBindings({
-    crate,
-    library,
-    module: pythonModule,
-    packageRoot: pythonRoot,
-    platform: os,
-    generatedSource: pythonBindings,
-    run,
-    targetDirectory: resolve(cargoTargetRoot, generatorTarget ?? cargoTarget, "release"),
-  });
-
-  const wheelDirectory = resolve(output, "python");
-  mkdirSync(wheelDirectory, { recursive: true });
-  run("uv", ["build", "--wheel", "--out-dir", wheelDirectory], pythonRoot);
-  const wheels = readdirSync(wheelDirectory).filter((file) => file.endsWith(".whl"));
-  if (wheels.length !== 1) throw new Error(`Expected one Python wheel, found ${wheels.length}`);
-  run("uvx", [
-    "--from",
-    "wheel",
-    "wheel",
-    "tags",
-    "--remove",
-    "--platform-tag",
-    pythonTag,
-    join(wheelDirectory, wheels[0]),
-  ]);
-};
-
-const generatePython = () => {
-  const crate = required("crate");
-  const cargoTarget = required("cargo-target");
-  const os = required("os");
-  const output = resolve(root, required("output"));
-  const generator = resolve(
-    cargoTargetRoot,
-    cargoTarget,
-    "release",
-    pythonBindingGeneratorName(crate, os),
-  );
-  const library = libraryPath(crate, cargoTarget, os);
-  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
-  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
-  rmSync(output, { recursive: true, force: true });
-  mkdirSync(output, { recursive: true });
-  run(generator, pythonBindingGeneratorArgs({ crate, library, output }));
-};
-
-const build = () => {
-  const crate = required("crate");
-  const cargoTarget = required("cargo-target");
-  const nodeTriple = required("node-triple");
-  const pythonTag = required("python-tag");
-  const version = required("version");
-  const os = required("os");
-  const cpu = required("cpu");
-  const output = resolve(root, required("output"));
-  const library = libraryPath(crate, cargoTarget, os);
-
-  rmSync(output, { recursive: true, force: true });
-  mkdirSync(output, { recursive: true });
-  if (!parsed.values["skip-build"]) {
-    run("cargo", [
-      "build",
-      "--release",
-      ...(existsSync(resolve(root, "Cargo.lock")) ? ["--locked"] : []),
-      "--package",
-      crate,
-      "--features",
-      "uniffi-bindgen",
-      "--target",
-      cargoTarget,
-    ]);
-  }
-  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
-
-  const nodeDirectory = parsed.values.node;
-  const nodePackage = parsed.values["node-package"];
-  if (nodeDirectory && nodePackage) {
-    packageNode({
-      library,
-      output,
-      nodeDirectory,
-      nodePackage,
-      nodeTriple,
-      os,
-      cpu,
-      version,
-      facade: parsed.values.facade === "true",
-    });
-  }
-
-  const pythonDirectory = parsed.values.python;
-  if (pythonDirectory) {
-    packagePython({
-      crate,
-      library,
-      output,
-      pythonDirectory,
-      pythonTag,
-      version,
-      cargoTarget,
-      generatorTarget: parsed.values["generator-target"],
-      os,
-      pythonModule: required("python-module"),
-      pythonBindings: parsed.values["python-bindings"],
-    });
-  }
-};
-
-if (parsed.positionals[0] === "build") {
-  build();
-} else if (parsed.positionals[0] === "generate-python") {
-  generatePython();
-} else if (parsed.positionals[0] === "facade") {
-  packageNodeFacade({
-    output: resolve(root, required("output")),
-    nodeDirectory: required("node"),
-    nodePackage: required("node-package"),
-    version: required("version"),
-    nativePackage: parsed.values["native-package"]
-      ? resolve(root, parsed.values["native-package"])
-      : undefined,
-  });
-} else {
-  throw new Error("Expected build or facade command");
-}