@dbx-tools/projen 0.6.142 → 0.6.144

package/tasks/uniffi-release.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env -S bun
+import {
+  chmodSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { spawnSync } from "node:child_process";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const parsed = parseArgs({
+  allowPositionals: true,
+  options: {
+    crate: { type: "string" },
+    rust: { type: "string" },
+    node: { type: "string" },
+    python: { type: "string" },
+    "node-package": { type: "string" },
+    "python-package": { type: "string" },
+    "cargo-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" },
+  },
+});
+
+const required = (name: keyof typeof parsed.values): string => {
+  const value = parsed.values[name];
+  if (!value) throw new Error(`Missing --${name}`);
+  return value;
+};
+
+const run = (command: string, args: string[], cwd = root): void => {
+  const result = spawnSync(command, args, { cwd, stdio: "inherit" });
+  if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
+};
+
+const replaceVersion = (source: string, version: string): string =>
+  source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
+
+function build(): void {
+  const crate = required("crate");
+  required("rust");
+  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 nodeDirectory = parsed.values.node;
+  const pythonDirectory = parsed.values.python;
+  const nodePackage = parsed.values["node-package"];
+  const pythonPackage = parsed.values["python-package"];
+  const libraryName = crate.replaceAll("-", "_");
+  const extension = os === "darwin" ? "dylib" : os === "win32" ? "dll" : "so";
+  const prefix = os === "win32" ? "" : "lib";
+  const libraryFile = `${prefix}${libraryName}.${extension}`;
+  const library = resolve(root, "target", cargoTarget, "release", libraryFile);
+  const output = resolve(root, "dist/uniffi");
+
+  rmSync(output, { recursive: true, force: true });
+  mkdirSync(join(output, "npm"), { recursive: true });
+  mkdirSync(join(output, "npm-facade"), { recursive: true });
+  mkdirSync(join(output, "python"), { recursive: true });
+  run("cargo", ["build", "--release", "--package", crate, "--target", cargoTarget]);
+  if (!existsSync(library)) throw new Error(`Missing native library ${library}`);
+
+  if (nodeDirectory && nodePackage) {
+    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}`,
+          license: "Apache-2.0",
+          os: [os],
+          cpu: [cpu],
+          ...(parsed.values.libc ? { libc: [parsed.values.libc] } : {}),
+          files: [libraryFile],
+        },
+        null,
+        2,
+      )}\n`,
+    );
+    run("npm", ["pack", "--pack-destination", resolve(output, "npm")], nativePackage);
+
+    if (parsed.values.facade === "true") {
+      const facade = resolve(output, "facade-node");
+      cpSync(resolve(root, nodeDirectory), facade, { recursive: true });
+      rmSync(join(facade, "src", libraryFile), { force: true });
+      const manifestPath = join(facade, "package.json");
+      const manifestMode = statSync(manifestPath).mode;
+      chmodSync(manifestPath, manifestMode | 0o200);
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+      manifest.version = version;
+      manifest.private = false;
+      manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
+      manifest.optionalDependencies = Object.fromEntries(
+        Object.keys(manifest.optionalDependencies ?? {}).map((name) => [name, version]),
+      );
+      manifest.dependencies = Object.fromEntries(
+        Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
+          name,
+          typeof dependency === "string" && dependency.startsWith("workspace:")
+            ? version
+            : dependency,
+        ]),
+      );
+      delete manifest.scripts;
+      delete manifest.devDependencies;
+      writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+      const generator = resolve(root, "node_modules/@dbx-tools/projen/tasks/uniffi.ts");
+      run("bun", [
+        generator,
+        "--crate",
+        crate,
+        "--node",
+        facade,
+        "--cargo-target",
+        cargoTarget,
+        "--node-package-base",
+        `${nodePackage}-`,
+      ]);
+      run("npm", ["pack", "--pack-destination", resolve(output, "npm-facade")], facade);
+    }
+  }
+
+  if (pythonDirectory && pythonPackage) {
+    const pythonRoot = resolve(output, "python-root");
+    cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
+    const pyproject = join(pythonRoot, "pyproject.toml");
+    const mode = statSync(pyproject).mode;
+    chmodSync(pyproject, mode | 0o200);
+    writeFileSync(pyproject, replaceVersion(readFileSync(pyproject, "utf8"), version));
+    const generator = resolve(root, "node_modules/@dbx-tools/projen/tasks/uniffi.ts");
+    run("bun", [
+      generator,
+      "--crate",
+      crate,
+      "--python",
+      pythonRoot,
+      "--cargo-target",
+      cargoTarget,
+    ]);
+    run("uv", ["build", "--wheel", "--out-dir", resolve(output, "python")], pythonRoot);
+    const wheels = [...new Bun.Glob("*.whl").scanSync(join(output, "python"))];
+    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(output, "python", wheels[0]!)]);
+  }
+}
+
+if (parsed.positionals[0] !== "build") throw new Error("Expected build command");
+build();

package/tasks/uniffi.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env -S bun
+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 { spawnSync } from "node:child_process";
+import { makeReadonly, makeWritable, stampGenerated } from "../src/generated.ts";
+import {
+  addExplicitInterfaceReexports,
+  makeDefaultedInterfaceParametersOptional,
+} from "../src/uniffi.ts";
+
+const { values } = parseArgs({
+  options: {
+    crate: { type: "string" },
+    node: { type: "string" },
+    python: { type: "string" },
+    "cargo-target": { type: "string" },
+    "node-package-base": { type: "string" },
+  },
+});
+if (!values.crate || (!values.node && !values.python)) {
+  throw new Error("Expected --crate and at least one of --node or --python");
+}
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const crate = values.crate;
+const libraryName = crate.replaceAll("-", "_");
+const extension =
+  process.platform === "darwin" ? "dylib" : process.platform === "win32" ? "dll" : "so";
+const prefix = process.platform === "win32" ? "" : "lib";
+const targetDirectory = values["cargo-target"]
+  ? join(root, "target", values["cargo-target"], "release")
+  : join(root, "target", "release");
+const library = join(targetDirectory, `${prefix}${libraryName}.${extension}`);
+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.status !== 0) throw new Error(`${command} exited with ${result.status}`);
+};
+
+const replaceGenerated = (source: string, destination: string): void => {
+  const deadline = Date.now() + 5_000;
+  while (!existsSync(source) && Date.now() < deadline) Bun.sleepSync(25);
+  if (!existsSync(source)) throw new Error(`Missing generated binding: ${source}`);
+  mkdirSync(dirname(destination), { recursive: true });
+  makeWritable(destination);
+  rmSync(destination, { force: true });
+  renameSync(source, destination);
+};
+
+const stampGeneratedPython = (file: string): void => {
+  makeWritable(file);
+  const body = readFileSync(file, "utf8");
+  writeFileSync(
+    file,
+    [
+      "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
+      `# Regenerated from the ${crate} Rust exports.`,
+      "# Hand edits are overwritten on the next watch; this file is read-only.",
+      "",
+      body,
+    ].join("\n"),
+  );
+  makeReadonly(file);
+};
+
+run("cargo", [
+  "build",
+  "--release",
+  "--package",
+  crate,
+  ...(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(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",
+  );
+  const linkedComponents = generatedModules.length > 2;
+  const nodeBindings = join(nodeSource, "bindings.ts");
+  const linkedNames = new Map(generatedModules.map((file) => [file, `_bindings-${file}`]));
+  const generatedFiles = linkedComponents
+    ? generatedModules.map((file) => join(nodeSource, linkedNames.get(file)!))
+    : [join(nodeSource, "_bindings.ts"), join(nodeSource, "_bindings-ffi.ts")];
+  replaceGenerated(join(nodeOutput, "index.ts"), nodeBindings);
+  if (linkedComponents) {
+    for (const file of generatedModules) {
+      replaceGenerated(join(nodeOutput, file), join(nodeSource, linkedNames.get(file)!));
+    }
+  } else {
+    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"),
+    );
+  }
+  if (linkedComponents) {
+    for (const file of [nodeBindings, ...generatedFiles]) {
+      let source = readFileSync(file, "utf8");
+      for (const [generated, destination] of linkedNames) {
+        const from = generated.slice(0, -3);
+        const to = destination.slice(0, -3);
+        source = source
+          .replaceAll(`'./${from}'`, `'./${to}'`)
+          .replaceAll(`"./${from}"`, `"./${to}"`);
+      }
+      writeFileSync(file, source);
+    }
+  }
+  for (const file of generatedFiles) {
+    writeFileSync(file, 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]) {
+    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 });
+  run(process.execPath, [
+    resolve(dirname(fileURLToPath(import.meta.url)), "barrels.ts"),
+    "--dir",
+    resolve(root, values.node),
+  ]);
+}
+
+if (values.python) {
+  const pythonPackage = resolve(
+    root,
+    values.python,
+    "src/dbx_tools",
+    crate.replace(/^dbx-tools-/, "").replaceAll("-", "_"),
+  );
+  const pythonOutput = mkdtempSync(join(tmpdir(), `${libraryName}-python-`));
+  run("cargo", [
+    "run",
+    "--release",
+    "--package",
+    crate,
+    "--bin",
+    "uniffi-bindgen",
+    "--",
+    "generate",
+    "--language",
+    "python",
+    "--out-dir",
+    pythonOutput,
+    library,
+  ]);
+  const generated = join(pythonOutput, `${libraryName}.py`);
+  const pythonBindings = join(pythonPackage, "bindings.py");
+  replaceGenerated(generated, pythonBindings);
+  stampGeneratedPython(pythonBindings);
+  const pythonInit = join(pythonPackage, "__init__.py");
+  if (!existsSync(pythonInit)) {
+    writeFileSync(
+      pythonInit,
+      `\"\"\"Python bindings for ${crate}.\"\"\"\n\nfrom .bindings import *  # noqa: F403\n`,
+    );
+  }
+  const pythonLibrary = join(pythonPackage, basename(library));
+  makeWritable(pythonLibrary);
+  cpSync(library, pythonLibrary);
+  makeReadonly(pythonLibrary);
+  rmSync(join(pythonPackage, "_generated"), { recursive: true, force: true });
+  rmSync(pythonOutput, { recursive: true, force: true });
+}