@dbx-tools/projen 0.9.19 → 0.9.28

package/tasks/uniffi.ts

@@ -1,271 +0,0 @@
-#!/usr/bin/env -S bun
-import { spawnSync } from "node:child_process";
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-import { installPythonBindings } from "./uniffi-python.js";
-import { makeReadonly, makeWritable, stampGenerated } from "../src/generated.ts";
-import type { RustWorkspaceMapping } from "../src/project-rs.ts";
-import {
-  addExplicitInterfaceReexports,
-  addTypeScriptExtensionsToBindingImports,
-  makeDefaultedInterfaceParametersOptional,
-  removeObsoleteInterfaceAliases,
-} from "../src/uniffi.ts";
-
-const { values } = parseArgs({
-  options: {
-    root: { type: "string" },
-    crate: { type: "string" },
-    node: { type: "string" },
-    python: { type: "string" },
-    "python-module": { type: "string" },
-    "cargo-target": { type: "string" },
-    "node-package-base": { type: "string" },
-    ubrn: { type: "string" },
-    "skip-build": { type: "boolean" },
-    "skip-barrels": { type: "boolean" },
-  },
-});
-if (!values.crate || (!values.node && !values.python)) {
-  throw new Error("Expected --crate and at least one of --node or --python");
-}
-
-const root = values.root
-  ? resolve(values.root)
-  : resolve(dirname(fileURLToPath(import.meta.url)), "../..");
-const crate = values.crate;
-const libraryName = crate.replaceAll("-", "_");
-const workspace = JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dbxToolsConfig
-  ?.rust as RustWorkspaceMapping | undefined;
-const binding = workspace?.bindings.find((binding) => binding.crate === crate);
-const dependencies =
-  workspace?.bindings.filter((candidate) => binding?.dependencies?.includes(candidate.crate)) ?? [];
-const extension =
-  process.platform === "darwin" ? "dylib" : process.platform === "win32" ? "dll" : "so";
-const prefix = process.platform === "win32" ? "" : "lib";
-const normalizedOutput = (value: string): string =>
-  value
-    .replace(/[\p{Extended_Pictographic}\uFE0F]/gu, "")
-    .replace(/[ \t]+$/gm, "")
-    .trim();
-const run = (command: string, args: string[]) => {
-  const result = spawnSync(command, args, { cwd: root, encoding: "utf8" });
-  const stdout = normalizedOutput(result.stdout ?? "");
-  const stderr = normalizedOutput(result.stderr ?? "");
-  if (stdout) process.stdout.write(`${stdout}\n`);
-  if (stderr) process.stderr.write(`${stderr}\n`);
-  if (result.error) {
-    throw new Error(`${command} failed: ${result.error.message}`, { cause: result.error });
-  }
-  if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
-};
-
-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) as { target_directory?: unknown })
-  .target_directory;
-if (typeof cargoTargetRoot !== "string" || !cargoTargetRoot) {
-  throw new Error("cargo metadata returned no target_directory");
-}
-const targetDirectory = values["cargo-target"]
-  ? join(cargoTargetRoot, values["cargo-target"], "release")
-  : join(cargoTargetRoot, "release");
-const library = join(targetDirectory, `${prefix}${libraryName}.${extension}`);
-
-const replaceGenerated = (source: string, destination: string): void => {
-  const deadline = Date.now() + 5_000;
-  const signal = new Int32Array(new SharedArrayBuffer(4));
-  while (!existsSync(source) && Date.now() < deadline) Atomics.wait(signal, 0, 0, 25);
-  if (!existsSync(source)) throw new Error(`Missing generated binding: ${source}`);
-  mkdirSync(dirname(destination), { recursive: true });
-  makeWritable(destination);
-  rmSync(destination, { force: true });
-  try {
-    renameSync(source, destination);
-  } catch (error) {
-    if (!(error instanceof Error) || !("code" in error) || error.code !== "EXDEV") throw error;
-    cpSync(source, destination);
-    rmSync(source, { force: true });
-  }
-};
-
-if (!values["skip-build"]) {
-  run("cargo", [
-    "build",
-    "--release",
-    ...(existsSync(join(root, "Cargo.lock")) ? ["--locked"] : []),
-    "--package",
-    crate,
-    "--features",
-    "uniffi-bindgen",
-    ...(values["cargo-target"] ? ["--target", values["cargo-target"]] : []),
-  ]);
-}
-if (!existsSync(library)) throw new Error(`Missing compiled UniFFI library: ${library}`);
-
-if (values.node) {
-  const nodeSource = resolve(root, values.node, "src");
-  const nodeOutput = mkdtempSync(join(tmpdir(), `${libraryName}-node-`));
-  run(values.ubrn ? resolve(values.ubrn) : join(root, "node_modules/.bin/ubrn"), [
-    "generate",
-    "napi",
-    "bindings",
-    "--library",
-    "--ts-dir",
-    nodeOutput,
-    ...(values["node-package-base"]
-      ? ["--lib-package-base", values["node-package-base"], "--lib-node-triple"]
-      : ["--lib-colocated"]),
-    library,
-  ]);
-  const generatedModules = readdirSync(nodeOutput).filter(
-    (file) => file.endsWith(".ts") && file !== "index.ts",
-  );
-  for (const dependency of dependencies) {
-    if (!dependency.nodePackage) throw new Error(`Missing Node binding for ${dependency.crate}`);
-    const namespace = dependency.crate.replaceAll("-", "_");
-    for (const file of readdirSync(nodeOutput).filter((file) => file.endsWith(".ts"))) {
-      const path = join(nodeOutput, file);
-      const source = readFileSync(path, "utf8")
-        .replace(
-          new RegExp(`import (\\w+) from ["']\\./${namespace}["'];`, "g"),
-          `import { uniffiModule as $1 } from "${dependency.nodePackage}";`,
-        )
-        .replaceAll(`'./${namespace}'`, `'${dependency.nodePackage}'`)
-        .replaceAll(`"./${namespace}"`, `"${dependency.nodePackage}"`);
-      writeFileSync(path, source);
-    }
-    for (const suffix of [".ts", "-ffi.ts"]) {
-      const file = `${namespace}${suffix}`;
-      rmSync(join(nodeOutput, file), { force: true });
-      const index = generatedModules.indexOf(file);
-      if (index >= 0) generatedModules.splice(index, 1);
-    }
-  }
-  const ownModules = generatedModules.filter(
-    (file) => file === `${libraryName}.ts` || file === `${libraryName}-ffi.ts`,
-  );
-  if (ownModules.length !== 2 || generatedModules.length !== 2) {
-    throw new Error(`Unmapped UniFFI components in ${crate}: ${generatedModules.join(", ")}`);
-  }
-  writeFileSync(
-    join(nodeOutput, "index.ts"),
-    [
-      `export * from './${libraryName}';`,
-      `import uniffiModule from './${libraryName}';`,
-      "uniffiModule.initialize();",
-      "export { uniffiModule };",
-      "export async function uniffiInitAsync() {}",
-      "",
-    ].join("\n"),
-  );
-  const nodeBindings = join(nodeSource, "bindings.ts");
-  const generatedFiles = [join(nodeSource, "_bindings.ts"), join(nodeSource, "_bindings-ffi.ts")];
-  const legacyExports = resolve(root, values.node, "exports.ts");
-  if (
-    existsSync(legacyExports) &&
-    readFileSync(legacyExports, "utf8").trim() === 'export * from "./src/bindings.ts";'
-  ) {
-    makeWritable(legacyExports);
-    rmSync(legacyExports, { force: true });
-  }
-  replaceGenerated(join(nodeOutput, "index.ts"), nodeBindings);
-  replaceGenerated(join(nodeOutput, libraryName + ".ts"), generatedFiles[0]);
-  replaceGenerated(join(nodeOutput, libraryName + "-ffi.ts"), generatedFiles[1]);
-  writeFileSync(
-    nodeBindings,
-    readFileSync(nodeBindings, "utf8").replaceAll("./" + libraryName, "./_bindings"),
-  );
-  writeFileSync(
-    generatedFiles[0],
-    readFileSync(generatedFiles[0], "utf8").replaceAll(
-      "./" + libraryName + "-ffi",
-      "./_bindings-ffi",
-    ),
-  );
-  for (const file of generatedFiles) {
-    writeFileSync(
-      file,
-      removeObsoleteInterfaceAliases(
-        makeDefaultedInterfaceParametersOptional(readFileSync(file, "utf8")),
-      ),
-    );
-  }
-  writeFileSync(
-    nodeBindings,
-    addExplicitInterfaceReexports(
-      readFileSync(nodeBindings, "utf8"),
-      generatedFiles.map((file) => ({
-        specifier: `./${basename(file, ".ts")}`,
-        source: readFileSync(file, "utf8"),
-      })),
-    ),
-  );
-  for (const file of [nodeBindings, ...generatedFiles]) {
-    // Consumers type-check these files through workspace source exports, while
-    // the generated runtime internals are validated by UniFFI's own build.
-    const source = addTypeScriptExtensionsToBindingImports(readFileSync(file, "utf8")).replace(
-      /[ \t]+$/gm,
-      "",
-    );
-    writeFileSync(file, `/* eslint-disable */\n// @ts-nocheck\n${source}`);
-    stampGenerated(file, {
-      tool: "UniFFI binding generation",
-      source: `the ${crate} Rust exports`,
-    });
-  }
-  if (!values["node-package-base"]) {
-    const nodeLibrary = join(nodeSource, basename(library));
-    makeWritable(nodeLibrary);
-    cpSync(library, nodeLibrary);
-    makeReadonly(nodeLibrary);
-  }
-  rmSync(resolve(root, values.node, "src/generated"), { recursive: true, force: true });
-  rmSync(nodeOutput, { recursive: true, force: true });
-  if (!values["skip-barrels"]) {
-    run(process.execPath, [
-      resolve(dirname(fileURLToPath(import.meta.url)), "barrels.ts"),
-      "--dir",
-      resolve(root, values.node),
-    ]);
-  }
-}
-
-if (values.python) {
-  if (!values["python-module"]) {
-    throw new Error("Expected --python-module with --python");
-  }
-  installPythonBindings({
-    crate,
-    library,
-    module: values["python-module"],
-    packageRoot: resolve(root, values.python),
-    platform: process.platform,
-    readonly: true,
-    run,
-    targetDirectory,
-  });
-}