@dbx-tools/projen 0.6.161 → 0.6.168

package/src/project-rs.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { project as coreProject } from "@dbx-tools/core";
 import { string } from "@dbx-tools/shared-core";
 import { Project, TextFile, YamlFile, javascript } from "projen";
+import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
 import type { DBXToolsProject } from "./project.ts";
 import {
   DBXToolsTypeScriptProject,
@@ -27,6 +28,7 @@ export interface CargoDependencyOptions {
   readonly workspace?: boolean;
   readonly path?: string;
   readonly optional?: boolean;
+  readonly package?: string;
   readonly defaultFeatures?: boolean;
   readonly features?: readonly string[];
 }
@@ -155,6 +157,8 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
 ] as const;
 
 const RUST_CACHE_ENV = {
+  CARGO_INCREMENTAL: "0",
+  CARGO_TERM_COLOR: "always",
   RUSTC_WRAPPER: "sccache",
   SCCACHE_GHA_ENABLED: "true",
 } as const;
@@ -202,8 +206,9 @@ function releaseTargets(options: DBXToolsRustWorkspaceOptions): readonly UniFFIR
     const target = UNIFFI_RELEASE_TARGETS.find(
       (candidate) => candidate.os === platform.os && candidate.cpu === platform.cpu,
     );
-    if (!target)
+    if (!target) {
       throw new Error(`Unsupported Rust release platform: ${platform.os}-${platform.cpu}`);
+    }
     return target;
   });
 }
@@ -246,6 +251,7 @@ export interface RustBindingMapping {
   readonly pythonPackage?: string;
   readonly pythonModule?: string;
   readonly facadeTarget?: boolean;
+  readonly dependencies?: readonly string[];
 }
 
 /** Persisted Rust workspace state consumed by `sync --watch`. */
@@ -256,6 +262,28 @@ export interface RustWorkspaceMapping {
   readonly releaseWorkflow?: string;
 }
 
+export function orderRustBindings(bindings: readonly RustBindingMapping[]): RustBindingMapping[] {
+  const ordered: RustBindingMapping[] = [];
+  const visiting = new Set<string>();
+  const completed = new Set<string>();
+  const visit = (binding: RustBindingMapping): void => {
+    if (completed.has(binding.crate)) return;
+    if (visiting.has(binding.crate))
+      throw new Error(`Cyclic Rust binding dependency: ${binding.crate}`);
+    visiting.add(binding.crate);
+    for (const name of binding.dependencies ?? []) {
+      const dependency = bindings.find((candidate) => candidate.crate === name);
+      if (!dependency) throw new Error(`Missing Rust binding dependency: ${name}`);
+      visit(dependency);
+    }
+    visiting.delete(binding.crate);
+    completed.add(binding.crate);
+    ordered.push(binding);
+  };
+  for (const binding of bindings) visit(binding);
+  return ordered;
+}
+
 function rustSources(directory: string): string[] {
   if (!existsSync(directory)) return [];
   const files: string[] = [];
@@ -293,6 +321,7 @@ function cargoDependency(
     ...(!value.version && value.path && workspaceVersion ? { version: workspaceVersion } : {}),
     ...(value.workspace ? { workspace: true } : {}),
     ...(value.path ? { path: value.path } : {}),
+    ...(value.package ? { package: value.package } : {}),
     ...(value.optional ? { optional: true } : {}),
     ...(value.defaultFeatures === false ? { "default-features": false } : {}),
     ...(value.features?.length ? { features: [...value.features] } : {}),
@@ -365,7 +394,7 @@ export class DBXToolsRustProject extends Project implements DBXToolsProject {
       ...(this.uniffi || binary
         ? {
             bin: this.uniffi
-              ? { name: "uniffi-bindgen", path: "uniffi-bindgen.rs" }
+              ? { name: `${crateName}-uniffi-bindgen`, path: "uniffi-bindgen.rs" }
               : { name: binaryName, path: "src/main.rs" },
           }
         : {}),
@@ -446,27 +475,75 @@ export class DBXToolsRustWorkspace {
     );
 
     const bindings = this.packages.filter((pkg) => pkg.uniffi);
-    this.bindingMappings = bindings.map((pkg) => {
-      const targets = pkg.packageOptions.bindings ?? ["node", "python"];
-      const packageName = pkg.packageOptions.directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
-      return {
-        crate: pkg.crateName,
-        rust: `${root}/${pkg.packageOptions.directory}`,
-        ...(targets.includes("node")
-          ? {
-              node: `${nodeRoot}/${pkg.packageOptions.directory}`,
-              nodePackage: `@${scope}/${packageName}`,
-            }
-          : {}),
-        ...(targets.includes("python")
-          ? {
-              python: `${options.pythonRoot ?? "packages/py"}/${pkg.packageOptions.directory}`,
-              pythonPackage: pkg.crateName,
-              pythonModule: pythonModuleName(pythonModulePrefix, pkg.packageOptions.directory),
-            }
-          : {}),
-      };
-    });
+    const bindingDependencies = (pkg: DBXToolsRustProject, language: "node" | "python") =>
+      bindings.filter(
+        (dependency) =>
+          dependency !== pkg &&
+          (dependency.packageOptions.bindings ?? ["node", "python"]).includes(language) &&
+          Object.entries(pkg.packageOptions.dependencies ?? {}).some(([name, value]) => {
+            const resolved =
+              typeof value === "object" && value.workspace
+                ? (options.workspaceDependencies?.[name] ?? value)
+                : value;
+            return (
+              name === dependency.crateName ||
+              (typeof resolved === "object" &&
+                (resolved.package === dependency.crateName ||
+                  (resolved.path !== undefined &&
+                    resolve(
+                      typeof value === "object" && value.workspace ? project.outdir : pkg.outdir,
+                      resolved.path,
+                    ) === dependency.outdir)))
+            );
+          }),
+      );
+    this.bindingMappings = orderRustBindings(
+      bindings.map((pkg) => {
+        const targets = pkg.packageOptions.bindings ?? ["node", "python"];
+        const packageName = pkg.packageOptions.directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+        const dependencies = [
+          ...new Set([...bindingDependencies(pkg, "node"), ...bindingDependencies(pkg, "python")]),
+        ].map((dependency) => dependency.crateName);
+        return {
+          crate: pkg.crateName,
+          ...(dependencies.length ? { dependencies } : {}),
+          rust: `${root}/${pkg.packageOptions.directory}`,
+          ...(targets.includes("node")
+            ? {
+                node: `${nodeRoot}/${pkg.packageOptions.directory}`,
+                nodePackage: `@${scope}/${packageName}`,
+              }
+            : {}),
+          ...(targets.includes("python")
+            ? {
+                python: `${options.pythonRoot ?? "packages/py"}/${pkg.packageOptions.directory}`,
+                pythonPackage: pkg.crateName,
+                pythonModule: pythonModuleName(pythonModulePrefix, pkg.packageOptions.directory),
+              }
+            : {}),
+        };
+      }),
+    );
+    for (const pkg of bindings) {
+      const dependencies = bindingDependencies(pkg, "python");
+      if (dependencies.length === 0) continue;
+      pkg.tryRemoveFile("uniffi.toml");
+      new TextFile(pkg, "uniffi.toml", {
+        lines: renderToml({
+          "bindings.python": { cdylib_name: pkg.crateName.replaceAll("-", "_") },
+          "bindings.typescript": { strictTypeChecking: true },
+          ...pkg.packageOptions.uniffiConfig,
+          "bindings.python.external_packages": Object.fromEntries(
+            dependencies.map((dependency) => [
+              dependency.crateName.replaceAll("-", "_"),
+              `${pythonModuleName(pythonModulePrefix, dependency.packageOptions.directory)}.bindings`,
+            ]),
+          ),
+        })
+          .trimEnd()
+          .split("\n"),
+      });
+    }
     const releaseEnabled =
       (options.release ?? true) &&
       (this.bindingMappings.length > 0 ||
@@ -483,13 +560,7 @@ export class DBXToolsRustWorkspace {
     project.gitignore.addPatterns(
       "target/",
       ...this.bindingMappings.flatMap((binding) => [
-        ...(binding.node
-          ? [
-              `${binding.node}/src/bindings.ts`,
-              `${binding.node}/src/_bindings*.ts`,
-              `${binding.node}/src/*${binding.crate.replaceAll("-", "_")}.*`,
-            ]
-          : []),
+        ...(binding.node ? [`${binding.node}/src/*${binding.crate.replaceAll("-", "_")}.*`] : []),
         ...(binding.python && binding.pythonModule
           ? [
               `${binding.python}/src/${binding.pythonModule.replaceAll(".", "/")}/bindings.py`,
@@ -498,6 +569,13 @@ export class DBXToolsRustWorkspace {
           : []),
       ]),
     );
+    for (const binding of this.bindingMappings) {
+      if (!binding.node) {
+        continue;
+      }
+      project.prettier?.addIgnorePattern(`${binding.node}/src/bindings.ts`);
+      project.prettier?.addIgnorePattern(`${binding.node}/src/_bindings*.ts`);
+    }
     this.pythonPackages = bindings
       .filter((pkg) => (pkg.packageOptions.bindings ?? ["node", "python"]).includes("python"))
       .map((pkg) => {
@@ -508,6 +586,9 @@ export class DBXToolsRustWorkspace {
           module,
           description: `Python bindings for ${pkg.crateName}`,
           private: true,
+          internalDependencies: bindingDependencies(pkg, "python").map(
+            (dependency) => dependency.packageOptions.directory,
+          ),
           generatedSources: [`src/${module.replaceAll(".", "/")}/bindings.py`],
           trustedPublisher: {
             workflowName: options.releaseWorkflowName ?? "rust-release",
@@ -543,7 +624,6 @@ export class DBXToolsRustWorkspace {
         `@${scope}/${directory.toLowerCase().replace(/[^a-z0-9-]+/g, "-")}`,
       );
       node.package.addField("private", true);
-      node.package.file.addDeletionOverride("publishConfig");
       node.package.addField("description", `Node bindings for ${binding.crateName}`);
       const nativeTargets = releaseTargets(options);
       if (options.release ?? true) {
@@ -558,6 +638,11 @@ export class DBXToolsRustWorkspace {
         );
       }
       node.addDeps("@ubjs/core@0.31.0-5", "@ubjs/node@0.31.0-5");
+      node.addDeps(
+        ...bindingDependencies(binding, "node").map(
+          (dependency) => `@${scope}/${dependency.packageOptions.directory}@workspace:*`,
+        ),
+      );
       if (binding.packageOptions.nodeDependencies?.length) {
         node.addDeps(...binding.packageOptions.nodeDependencies);
       }
@@ -565,7 +650,6 @@ export class DBXToolsRustWorkspace {
       if (binding.packageOptions.nodeDevDependencies?.length) {
         node.addDevDeps(...binding.packageOptions.nodeDevDependencies);
       }
-      node.compileTask.reset();
       new TextFile(node, "exports.ts", {
         lines: ['export * from "./src/bindings.ts";', ""],
       });
@@ -606,10 +690,13 @@ export class DBXToolsRustWorkspace {
     project.addTask("rs:lint", { exec: "cargo clippy --workspace --all-targets --all-features" });
     project.addTask("rs:test", { exec: "cargo test --workspace" });
     project.addTask("rs:build", { exec: "cargo build --workspace" });
-    project.addTask("rs:bindings", {
+    const bindingsTask = project.addTask("rs:bindings", {
       exec: "bun node_modules/@dbx-tools/projen/tasks/rust.ts",
       description: "Generate language bindings for UniFFI-enabled Rust crates",
     });
+    if (this.bindingMappings.some((binding) => binding.node)) {
+      project.tasks.tryFind("pre-compile")?.spawn(bindingsTask);
+    }
     project.addTask("rs:bindings:demo", {
       description: "Generate and run UniFFI Node and Python example CLIs",
       exec: [
@@ -661,12 +748,20 @@ export class DBXToolsRustWorkspace {
       }));
     const publicCrates = this.packages
       .filter((pkg) => !pkg.packageOptions.private)
+      .sort((first, second) => {
+        const order = this.bindingMappings.map((binding) => binding.crate);
+        return order.indexOf(first.crateName) - order.indexOf(second.crateName);
+      })
       .map((pkg) => pkg.crateName);
     const targetMatrix = targets.map((target, index) => ({
       target: { ...target, facade: index === 0 },
     }));
     const hasNodeBindings = bindings.some((binding) => binding.node);
     const hasPythonBindings = bindings.some((binding) => binding.python);
+    const facadeCondition = "matrix.target.facade";
+    const facadeCacheMissCondition =
+      "matrix.target.facade && steps.ubrn_cache.outputs.cache-hit != 'true'";
+    const usePreinstalledWindowsRust = releaseRustVersion === "stable";
     const hasTargetOutputs =
       bindings.length > 0 || releaseBinaries.length > 0 || publicCrates.length > 0;
     if (hasTargetOutputs && targetMatrix.length === 0) {
@@ -766,6 +861,7 @@ export class DBXToolsRustWorkspace {
       "runs-on": "${{ matrix.target.runner }}",
       env: {
         ...RUST_CACHE_ENV,
+        BUN_VERSION,
         SCCACHE_GHA_VERSION: `release-\${{ matrix.target.cargo }}-rust-${releaseRustVersion}`,
       },
       strategy: {
@@ -774,27 +870,35 @@ export class DBXToolsRustWorkspace {
       },
       steps: [
         ...releaseSourceSteps(),
-        ...(hasNodeBindings
-          ? [
-              {
-                name: "Setup Bun",
-                uses: "oven-sh/setup-bun@v2",
-                with: { "bun-version": "1.3.14" },
-              },
-            ]
-          : []),
         ...(hasPythonBindings ? [{ name: "Setup uv", uses: "astral-sh/setup-uv@v7" }] : []),
         {
           name: "Setup Rust",
+          ...(usePreinstalledWindowsRust ? { if: "${{ matrix.target.os != 'win32' }}" } : {}),
           uses: `dtolnay/rust-toolchain@${releaseRustVersion}`,
           with: { targets: "${{ matrix.target.cargo }}" },
         },
+        ...(usePreinstalledWindowsRust
+          ? [
+              {
+                name: "Verify preinstalled Windows Rust",
+                if: "${{ matrix.target.os == 'win32' }}",
+                shell: "bash",
+                run: [
+                  "rustc --version --verbose",
+                  "cargo --version",
+                  'rustup target list --installed | grep -Fx "${{ matrix.target.cargo }}"',
+                  'test -f "$(rustc --print sysroot)/lib/rustlib/${{ matrix.target.cargo }}/bin/rust-lld.exe"',
+                ].join("\n"),
+              },
+            ]
+          : []),
         ...rustCacheSteps(`release-\${{ matrix.target.cargo }}-rust-${releaseRustVersion}`),
         ...(hasNodeBindings
           ? [
               {
                 name: "Restore UBRN executable",
                 id: "ubrn_cache",
+                if: "${{ matrix.target.facade }}",
                 uses: "actions/cache/restore@v5",
                 with: {
                   path: ".cache/ubrn",
@@ -803,6 +907,12 @@ export class DBXToolsRustWorkspace {
               },
             ]
           : []),
+        ...(hasNodeBindings
+          ? bunCacheRestoreSteps(project, {
+              setupCondition: facadeCondition,
+              condition: facadeCacheMissCondition,
+            })
+          : []),
         {
           name: "Log cache configuration",
           shell: "bash",
@@ -829,17 +939,20 @@ export class DBXToolsRustWorkspace {
           ? [
               {
                 name: "Install Node tooling",
-                if: "${{ steps.ubrn_cache.outputs.cache-hit != 'true' }}",
+                if: "${{ matrix.target.facade && steps.ubrn_cache.outputs.cache-hit != 'true' }}",
                 shell: "bash",
                 run: timedBash("node_tooling", "bun install"),
               },
+              bunCacheSaveStep({
+                condition: facadeCacheMissCondition,
+              }),
             ]
           : []),
         ...(hasNodeBindings
           ? [
               {
                 name: "Prepare UBRN generator",
-                if: "${{ steps.ubrn_cache.outputs.cache-hit != 'true' }}",
+                if: "${{ matrix.target.facade && steps.ubrn_cache.outputs.cache-hit != 'true' }}",
                 env: {
                   CARGO_TARGET_DIR: "${{ github.workspace }}/target/ubrn",
                   UBRN_EXECUTABLE: ubrnExecutable,
@@ -857,13 +970,14 @@ export class DBXToolsRustWorkspace {
               },
               {
                 name: "Verify UBRN executable",
+                if: "${{ matrix.target.facade }}",
                 env: { UBRN_EXECUTABLE: ubrnExecutable },
                 shell: "bash",
                 run: 'test -f "$UBRN_EXECUTABLE"',
               },
               {
                 name: "Save UBRN executable",
-                if: "${{ steps.ubrn_cache.outputs.cache-hit != 'true' }}",
+                if: "${{ matrix.target.facade && steps.ubrn_cache.outputs.cache-hit != 'true' }}",
                 uses: "actions/cache/save@v5",
                 with: {
                   path: ".cache/ubrn",
@@ -875,6 +989,10 @@ export class DBXToolsRustWorkspace {
         {
           name: "Build Rust outputs",
           shell: "bash",
+          env: {
+            CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER:
+              "${{ matrix.target.os == 'win32' && 'rust-lld' || '' }}",
+          },
           run: timedBash(
             "rust_workspace",
             'cargo build --release --workspace --target "${{ matrix.target.cargo }}"',
@@ -920,7 +1038,10 @@ export class DBXToolsRustWorkspace {
         `publish-${binding.crate}`,
         {
           if: "${{ github.event_name == 'repository_dispatch' }}",
-          needs: ["build"],
+          needs: [
+            "build",
+            ...(binding.dependencies ?? []).map((dependency) => `publish-${dependency}`),
+          ],
           "runs-on": "ubuntu-latest",
           permissions: {
             contents: "read",

package/src/release.ts

@@ -10,6 +10,7 @@ import { Component, YamlFile } from "projen";
 import { GithubWorkflow } from "projen/lib/github";
 import { JobPermission, type JobStep } from "projen/lib/github/workflows-model";
 import { object } from "@dbx-tools/shared-core";
+import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
 import { applyTasks, taskScript, type DBXToolsNodeProject } from "./project.ts";
 import {
   DOWNSTREAM_RELEASE_EVENT,
@@ -21,7 +22,6 @@ import {
 
 const NODE_VERSION = "lts/*";
 const NPM_REGISTRY_URL = "https://registry.npmjs.org";
-const BUN_VERSION = "1.3.14";
 
 /**
  * The `release` workflow's version-stamp + publish step, as a shell script.
@@ -73,10 +73,10 @@ interface PublishWorkflow {
 }
 
 /** Shared checkout and toolchain setup for every npm publish workflow. */
-function publishSetupSteps(): JobStep[] {
+function publishSetupSteps(project: DBXToolsNodeProject): JobStep[] {
   return [
     { name: "Checkout", uses: "actions/checkout@v6", with: { "fetch-depth": 0 } },
-    { name: "Setup Bun", uses: "oven-sh/setup-bun@v2", with: { "bun-version": BUN_VERSION } },
+    ...bunCacheRestoreSteps(project),
     {
       name: "Setup Node.js",
       uses: "actions/setup-node@v6",
@@ -88,6 +88,7 @@ function publishSetupSteps(): JobStep[] {
     },
     // Bun's install; the lockfile may be absent or stale in CI so it is not frozen.
     { name: "Install", run: "bun install" },
+    bunCacheSaveStep(),
   ];
 }
 
@@ -301,7 +302,7 @@ export class DBXToolsRelease extends Component {
     project: DBXToolsNodeProject,
     { name, tagPrefix, steps, workingDirectory, upstreamWorkflow }: PublishWorkflow,
   ): void {
-    const setupSteps = publishSetupSteps();
+    const setupSteps = publishSetupSteps(project);
     const branchDispatch = upstreamWorkflow === undefined;
     const workflow = new GithubWorkflow(project.github!, name, {
       // A newer release supersedes an older run even when publication has
@@ -369,6 +370,7 @@ export class DBXToolsRelease extends Component {
       // `DRY_RUN_INPUT` is `--dry-run` when the dispatch input is true, else empty;
       // the publish script also FORCES it on any `workflow_dispatch` run.
       env: {
+        BUN_VERSION,
         CI: "true",
         DRY_RUN_INPUT: "${{ github.event.inputs.dry_run == 'true' && '--dry-run' || '' }}",
       },

package/src/uniffi.ts

@@ -36,6 +36,14 @@ export interface TypeScriptBindingModule {
   readonly source: string;
 }
 
+/** Add source extensions to UBRN's generated relative binding imports. */
+export const addTypeScriptExtensionsToBindingImports = (source: string): string =>
+  source.replace(
+    /(["'])\.\/_bindings(-ffi)?\1/g,
+    (_specifier, quote: string, suffix: string | undefined) =>
+      `${quote}./_bindings${suffix ?? ""}.ts${quote}`,
+  );
+
 /** Add explicit type exports for interfaces that TypeScript misses through UBRN's star exports. */
 export const addExplicitInterfaceReexports = (
   facade: string,

package/tasks/rust.ts

@@ -8,6 +8,7 @@ import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import {
   discoverRustCrates,
   hasUniFFIBindings,
+  orderRustBindings,
   type RustBindingMapping,
   type RustWorkspaceMapping,
 } from "../src/project-rs.ts";
@@ -84,6 +85,19 @@ function generate(binding: RustBindingMapping): void {
   if (result.status !== 0) throw new Error(`binding generation exited with ${result.status}`);
 }
 
+export function affectedRustBindings(
+  bindings: readonly RustBindingMapping[],
+  changed: ReadonlySet<string>,
+): RustBindingMapping[] {
+  const affected = new Set(changed);
+  const ordered = orderRustBindings(bindings);
+  for (const binding of ordered) {
+    if (binding.dependencies?.some((dependency) => affected.has(dependency)))
+      affected.add(binding.crate);
+  }
+  return ordered.filter((binding) => affected.has(binding.crate));
+}
+
 const config = rustConfig();
 
 async function main(): Promise<void> {
@@ -92,7 +106,7 @@ async function main(): Promise<void> {
     throw new Error("Cargo is required because Rust projects were detected");
   }
   if (!process.argv.includes("--watch")) {
-    for (const binding of config.bindings) generate(binding);
+    for (const binding of orderRustBindings(config.bindings)) generate(binding);
     return;
   }
 
@@ -109,7 +123,7 @@ async function main(): Promise<void> {
         const binding = ownerBinding(path, refreshed.bindings);
         if (binding) targets.set(binding.crate, binding);
       }
-      for (const binding of targets.values()) {
+      for (const binding of affectedRustBindings(refreshed.bindings, new Set(targets.keys()))) {
         logger.start(`generating ${binding.crate} bindings`);
         generate(binding);
         logger.success(`generated ${binding.crate} bindings`);
@@ -121,7 +135,7 @@ async function main(): Promise<void> {
       const binding = ownerBinding(path, latest.bindings);
       if (binding) targets.set(binding.crate, binding);
     }
-    for (const binding of targets.values()) {
+    for (const binding of affectedRustBindings(latest.bindings, new Set(targets.keys()))) {
       logger.start(`generating ${binding.crate} bindings`);
       generate(binding);
       logger.success(`generated ${binding.crate} bindings`);