@dbx-tools/projen 0.6.161 → 0.6.168

package/tasks/uniffi-release.mjs

@@ -65,6 +65,82 @@ const run = (command, args, cwd = root) => {
   if (result.status !== 0) throw new Error(`${invocation.command} exited with ${result.status}`);
 };
 
+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]] : [];
+    }),
+  );
+};
+
+const testNodeFacade = ({ facadePackage, manifest, nativePackage, nodePackage }) => {
+  const installDirectory = mkdtempSync(join(tmpdir(), "uniffi-facade-install-"));
+  try {
+    const workspacePackages = localWorkspacePackages();
+    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 output = resolve(root, "dist/release", binding.crate, required("node-triple"));
+        return [singlePackage(join(output, "npm-facade")), singlePackage(join(output, "npm"))];
+      }
+      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`,
+      );
+      writeFileSync(join(directory, "index.js"), "export {};\n");
+      return [directory];
+    });
+    writeFileSync(
+      join(installDirectory, "package.json"),
+      `${JSON.stringify({ private: true, type: "module" })}\n`,
+    );
+    run(
+      "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 });
+  }
+};
+
 const replaceVersion = (source, version) =>
   source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
 
@@ -135,8 +211,6 @@ const packageNode = ({
       typeof dependency === "string" && dependency.startsWith("workspace:") ? version : dependency,
     ]),
   );
-  delete manifest.scripts;
-  delete manifest.devDependencies;
   writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
   run("bun", [
     resolve(root, nodeGenerator),
@@ -150,13 +224,47 @@ const packageNode = ({
     required("cargo-target"),
     "--node-package-base",
     `${nodePackage}-`,
-    "--ubrn",
-    required("ubrn"),
+    ...(parsed.values.ubrn ? ["--ubrn", parsed.values.ubrn, "--skip-barrels"] : []),
     "--skip-build",
-    "--skip-barrels",
   ]);
-  mkdirSync(resolve(output, "npm-facade"), { recursive: true });
-  run("npm", ["pack", "--pack-destination", resolve(output, "npm-facade")], facadeDirectory);
+  // Node loads the facade from node_modules, so every TypeScript entry point
+  // must be emitted and advertised as JavaScript. Bun is always available in
+  // the facade row, including when the UBRN cache skips the workspace install.
+  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);
+  testNodeFacade({
+    facadePackage: singlePackage(facadeOutput),
+    manifest,
+    nativePackage: singlePackage(resolve(output, "npm")),
+    nodePackage,
+  });
 };
 
 const packagePython = ({
@@ -174,6 +282,19 @@ const packagePython = ({
   const pyproject = join(pythonRoot, "pyproject.toml");
   writable(pyproject);
   writeFileSync(pyproject, replaceVersion(readFileSync(pyproject, "utf8"), version));
+  const workspaceBindings =
+    JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dbxToolsConfig?.rust?.bindings ??
+    [];
+  let metadata = readFileSync(pyproject, "utf8");
+  for (const binding of workspaceBindings) {
+    if (!binding.pythonPackage) continue;
+    const escaped = binding.pythonPackage.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    metadata = metadata.replace(
+      new RegExp(`"${escaped} @ git\\+[^"\\n]+"`, "g"),
+      JSON.stringify(`${binding.pythonPackage}==${version}`),
+    );
+  }
+  writeFileSync(pyproject, metadata);
 
   const packageName = crate.replace(/^dbx-tools-/, "").replaceAll("-", "_");
   const packageDirectory = resolve(pythonRoot, "src", "dbx_tools", packageName);
@@ -183,10 +304,19 @@ const packagePython = ({
     "target",
     cargoTarget,
     "release",
-    `uniffi-bindgen${os === "win32" ? ".exe" : ""}`,
+    `${crate}-uniffi-bindgen${os === "win32" ? ".exe" : ""}`,
   );
   if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
-  run(generator, ["generate", "--language", "python", "--out-dir", generatedDirectory, library]);
+  run(generator, [
+    "generate",
+    "--language",
+    "python",
+    "--crate",
+    crate.replaceAll("-", "_"),
+    "--out-dir",
+    generatedDirectory,
+    library,
+  ]);
   const bindings = join(packageDirectory, "bindings.py");
   writable(bindings);
   const body = readFileSync(join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`), "utf8");

package/tasks/uniffi.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env -S bun
+import { spawnSync } from "node:child_process";
 import {
   cpSync,
   existsSync,
@@ -14,10 +15,11 @@ 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 type { RustWorkspaceMapping } from "../src/project-rs.ts";
 import {
   addExplicitInterfaceReexports,
+  addTypeScriptExtensionsToBindingImports,
   makeDefaultedInterfaceParametersOptional,
 } from "../src/uniffi.ts";
 
@@ -43,6 +45,11 @@ const root = 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";
@@ -61,6 +68,9 @@ const run = (command: string, args: string[]) => {
   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}`);
 };
 
@@ -126,42 +136,60 @@ if (values.node) {
   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)!));
+  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);
     }
-  } 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 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")];
+  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, makeDefaultedInterfaceParametersOptional(readFileSync(file, "utf8")));
   }
@@ -176,6 +204,13 @@ if (values.node) {
     ),
   );
   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`,
@@ -206,31 +241,26 @@ if (values.python) {
     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,
-  ]);
+  run(
+    join(targetDirectory, `${crate}-uniffi-bindgen${process.platform === "win32" ? ".exe" : ""}`),
+    [
+      "generate",
+      "--language",
+      "python",
+      "--crate",
+      libraryName,
+      "--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`,
-    );
+    writeFileSync(pythonInit, "");
   }
   const pythonLibrary = join(pythonPackage, basename(library));
   makeWritable(pythonLibrary);