@dbx-tools/projen 0.6.163 → 0.6.174

package/tasks/uniffi-release.mjs

@@ -25,8 +25,7 @@ const parsed = parseArgs({
     node: { type: "string" },
     python: { type: "string" },
     "node-package": { type: "string" },
-    "node-generator": { type: "string" },
-    ubrn: { type: "string" },
+    "native-package": { type: "string" },
     "python-package": { type: "string" },
     "cargo-target": { type: "string" },
     "node-triple": { type: "string" },
@@ -65,9 +64,139 @@ 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]] : [];
+    }),
+  );
+};
+
+/**
+ * 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 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`,
+    );
+    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}"`);
 
+/** Resolve workspace and generated catalog protocols for a publishable facade. */
+const facadeDependency = (name, dependency, version, catalog) => {
+  if (typeof dependency !== "string") return dependency;
+  if (dependency.startsWith("workspace:")) return 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);
 };
@@ -80,7 +209,6 @@ const libraryPath = (crate, cargoTarget, os) => {
 };
 
 const packageNode = ({
-  crate,
   library,
   output,
   nodeDirectory,
@@ -90,9 +218,11 @@ const packageNode = ({
   cpu,
   version,
   facade,
-  nodeGenerator,
 }) => {
   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));
@@ -103,6 +233,7 @@ const packageNode = ({
         name: `${nodePackage}-${nodeTriple}`,
         version,
         description: `Native ${nodeTriple} library for ${nodePackage}`,
+        repository: sourceManifest.repository,
         license: "Apache-2.0",
         os: [os],
         cpu: [cpu],
@@ -117,12 +248,40 @@ const packageNode = ({
   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, "src", libraryFile), { force: true });
+  const barrel = join(facadeDirectory, "index.ts");
+  writable(barrel);
+  writeFileSync(
+    barrel,
+    readFileSync(barrel, "utf8").replace(
+      /^export const PACKAGE_VERSION = .*;$/m,
+      `export const PACKAGE_VERSION = ${JSON.stringify(version)};`,
+    ),
+  );
+  for (const file of readdirSync(join(facadeDirectory, "src"))) {
+    if (/\.(dll|dylib|so)$/.test(file)) {
+      rmSync(join(facadeDirectory, "src", file), { force: true });
+    }
+  }
   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 ?? {};
   manifest.version = version;
   manifest.private = false;
   manifest.license = manifest.license === "UNLICENSED" ? "Apache-2.0" : manifest.license;
@@ -132,29 +291,50 @@ const packageNode = ({
   manifest.dependencies = Object.fromEntries(
     Object.entries(manifest.dependencies ?? {}).map(([name, dependency]) => [
       name,
-      typeof dependency === "string" && dependency.startsWith("workspace:") ? version : dependency,
+      facadeDependency(name, dependency, version, catalog),
     ]),
   );
+  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`);
-  run("bun", [
-    resolve(root, nodeGenerator),
-    "--root",
-    root,
-    "--crate",
-    crate,
-    "--node",
-    facadeDirectory,
-    "--cargo-target",
-    required("cargo-target"),
-    "--node-package-base",
-    `${nodePackage}-`,
-    ...(parsed.values.ubrn ? ["--ubrn", parsed.values.ubrn, "--skip-barrels"] : []),
-    "--skip-build",
-  ]);
-  mkdirSync(resolve(output, "npm-facade"), { recursive: true });
-  run("npm", ["pack", "--pack-destination", resolve(output, "npm-facade")], facadeDirectory);
+  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 = ({
@@ -172,6 +352,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);
@@ -181,10 +374,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");
@@ -240,7 +442,6 @@ const build = () => {
   const nodePackage = parsed.values["node-package"];
   if (nodeDirectory && nodePackage) {
     packageNode({
-      crate,
       library,
       output,
       nodeDirectory,
@@ -250,7 +451,6 @@ const build = () => {
       cpu,
       version,
       facade: parsed.values.facade === "true",
-      nodeGenerator: required("node-generator"),
     });
   }
 
@@ -269,5 +469,18 @@ const build = () => {
   }
 };
 
-if (parsed.positionals[0] !== "build") throw new Error("Expected build command");
-build();
+if (parsed.positionals[0] === "build") {
+  build();
+} 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");
+}

package/tasks/uniffi.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env -S bun
+import { spawnSync } from "node:child_process";
 import {
   cpSync,
   existsSync,
@@ -14,11 +15,13 @@ 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,
+  mergePythonBindingExports,
 } from "../src/uniffi.ts";
 
 const { values } = parseArgs({
@@ -43,6 +46,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 +69,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 +137,68 @@ 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")];
+  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, makeDefaultedInterfaceParametersOptional(readFileSync(file, "utf8")));
   }
@@ -176,6 +213,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,32 +250,34 @@ 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`,
-    );
-  }
+  makeWritable(pythonInit);
+  writeFileSync(
+    pythonInit,
+    mergePythonBindingExports(
+      existsSync(pythonInit) ? readFileSync(pythonInit, "utf8") : "",
+      readFileSync(pythonBindings, "utf8"),
+      { crate, file: pythonInit },
+    ),
+  );
+  makeReadonly(pythonInit);
   const pythonLibrary = join(pythonPackage, basename(library));
   makeWritable(pythonLibrary);
   cpSync(library, pythonLibrary);