@dbx-tools/projen 0.6.161 → 0.6.163

package/README.md

@@ -122,13 +122,18 @@ MSRV recorded in package manifests, while `releaseRustVersion` independently
 defaults release compilation to `stable`. UBRN uses that same release toolchain
 unless `ubrnRustVersion` explicitly selects another one.
 
+Generated build and release workflows share the Bun cache helpers from
+`bun-workflow.ts`. One `BUN_VERSION` value drives setup and cache keys, while a
+generated dependency-only fingerprint keeps release version bumps from
+invalidating Bun's global package cache. `node_modules` remains uncached.
+
 The final host UBRN executable is cached by pinned UBRN version, Rust toolchain,
 runner OS, and runner architecture. A hit skips both the workspace `bun install`
 and the UBRN Cargo build. Release packaging passes the cached executable directly
 to the Node binding generator and keeps the package barrel copied from source,
 so it does not need the installed projen dependency graph. A miss saves the
 validated executable immediately, before workspace build and packaging can fail.
-Cargo registry caches
+Bun runtime setup still runs because the binding generator is TypeScript. Cargo registry caches
 and the `SCCACHE_GHA_VERSION` namespace stay stable per target/toolchain across
 version tags. Cache keys, restore results, sccache statistics, and phase timings
 are written to each build log. Python generation executes the already-built

package/index.ts

@@ -5,6 +5,7 @@
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
+export * as bunWorkflow from "./src/bun-workflow.ts";
 export * as clean from "./src/clean.ts";
 export * as codegen from "./src/codegen.ts";
 export * as dbxToolsConfig from "./src/dbx-tools-config.ts";
@@ -31,6 +32,8 @@ export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
 export * as workspaceVersion from "./src/workspace-version.ts";
 export { BUN_DEV_OVERRIDE, BUN_BUILD_OVERRIDE, BUN_APP_OVERRIDES, RootBunfigFile, BunfigFile, BunDevServerFile, BunBuildFile } from "./src/bun-app.ts";
+export { BUN_VERSION } from "./src/bun-workflow.ts";
+export type { BunWorkflowCacheOptions } from "./src/bun-workflow.ts";
 export { DBXToolsConfig } from "./src/dbx-tools-config.ts";
 export type { DBXToolsConfigOptions } from "./src/dbx-tools-config.ts";
 export { resolvePkgRoot } from "./src/engine-root.ts";

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.161",
-    "@dbx-tools/path": "0.6.161",
-    "@dbx-tools/shared-core": "0.6.161",
+    "@dbx-tools/core": "0.6.163",
+    "@dbx-tools/path": "0.6.163",
+    "@dbx-tools/shared-core": "0.6.163",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -48,7 +48,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.161",
+  "version": "0.6.163",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/bun-workflow.ts

@@ -0,0 +1,145 @@
+/** Shared Bun setup and package-cache steps for generated workflows. */
+import { TextFile, javascript } from "projen";
+
+export const BUN_VERSION = "1.3.14";
+
+const cacheKeyScript = `#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const root = process.cwd();
+const ignored = new Set([
+  ".git",
+  ".docs-build",
+  ".venv",
+  ".worktrees",
+  "coverage",
+  "dist",
+  "lib",
+  "node_modules",
+  "target",
+]);
+const manifests = [];
+const walk = (directory) => {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (ignored.has(entry.name)) continue;
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) walk(path);
+    else if (entry.name === "package.json") manifests.push(path);
+  }
+};
+walk(root);
+
+const dependencyFields = [
+  "catalog",
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "overrides",
+  "peerDependencies",
+  "peerDependenciesMeta",
+  "resolutions",
+  "trustedDependencies",
+];
+const canonical = (value) => {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, child]) => [key, canonical(child)]),
+  );
+};
+const dependencies = manifests
+  .sort()
+  .map((path) => {
+    const manifest = JSON.parse(readFileSync(path, "utf8"));
+    return [
+      path.slice(root.length + 1),
+      Object.fromEntries(
+        dependencyFields
+          .filter((field) => manifest[field] !== undefined)
+          .map((field) => [field, canonical(manifest[field])]),
+      ),
+    ];
+  });
+process.stdout.write(createHash("sha256").update(JSON.stringify(dependencies)).digest("hex"));
+`;
+
+const configured = new WeakSet<javascript.NodeProject>();
+
+function ensureCacheKeyScript(project: javascript.NodeProject): void {
+  if (configured.has(project)) return;
+  new TextFile(project.root, ".projen/bun-cache-key.mjs", {
+    lines: cacheKeyScript.trimEnd().split("\n"),
+  });
+  configured.add(project);
+}
+
+function stepCondition(condition: string | undefined, cacheMiss = false): string | undefined {
+  const expressions = [
+    condition,
+    ...(cacheMiss ? ["steps.bun_cache.outputs.cache-hit != 'true'"] : []),
+  ].filter(Boolean);
+  return expressions.length ? `\${{ ${expressions.join(" && ")} }}` : undefined;
+}
+
+export interface BunWorkflowCacheOptions {
+  readonly setupCondition?: string;
+  readonly condition?: string;
+}
+
+/** Set up Bun and restore its global package cache. */
+export function bunCacheRestoreSteps(
+  project: javascript.NodeProject,
+  options: BunWorkflowCacheOptions = {},
+): readonly Record<string, unknown>[] {
+  ensureCacheKeyScript(project);
+  const condition = stepCondition(options.condition);
+  const setupCondition = stepCondition(options.setupCondition);
+  return [
+    {
+      name: "Setup Bun",
+      ...(setupCondition ? { if: setupCondition } : {}),
+      uses: "oven-sh/setup-bun@v2",
+      with: { "bun-version": "${{ env.BUN_VERSION }}" },
+    },
+    {
+      name: "Resolve Bun cache",
+      id: "bun_cache_metadata",
+      ...(condition ? { if: condition } : {}),
+      shell: "bash",
+      run: [
+        'echo "path=$(bun pm cache)" >> "$GITHUB_OUTPUT"',
+        'echo "dependency_hash=$(node .projen/bun-cache-key.mjs)" >> "$GITHUB_OUTPUT"',
+      ].join("\n"),
+    },
+    {
+      name: "Restore Bun cache",
+      id: "bun_cache",
+      ...(condition ? { if: condition } : {}),
+      uses: "actions/cache/restore@v5",
+      with: {
+        path: "${{ steps.bun_cache_metadata.outputs.path }}",
+        key: `bun-\${{ runner.os }}-\${{ runner.arch }}-\${{ env.BUN_VERSION }}-\${{ steps.bun_cache_metadata.outputs.dependency_hash }}`,
+        "restore-keys": `bun-\${{ runner.os }}-\${{ runner.arch }}-\${{ env.BUN_VERSION }}-`,
+      },
+    },
+  ];
+}
+
+/** Save Bun's global package cache immediately after installation. */
+export function bunCacheSaveStep(
+  options: BunWorkflowCacheOptions = {},
+): Readonly<Record<string, unknown>> {
+  return {
+    name: "Save Bun cache",
+    if: stepCondition(options.condition, true),
+    uses: "actions/cache/save@v5",
+    with: {
+      path: "${{ steps.bun_cache_metadata.outputs.path }}",
+      key: "${{ steps.bun_cache.outputs.cache-primary-key }}",
+    },
+  };
+}

package/src/project-js.ts

@@ -13,6 +13,7 @@ import { ignore, match } from "@dbx-tools/path";
 import { object, string, type OneOrMany } from "@dbx-tools/shared-core";
 import { type IConstruct } from "constructs";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
+import type { JobStep } from "projen/lib/github/workflows-model";
 import { ReleaseTrigger } from "projen/lib/release";
 import { mixin } from "..";
 import { generateBarrels } from "./barrels.ts";
@@ -23,6 +24,7 @@ import {
   BunfigFile,
   RootBunfigFile,
 } from "./bun-app.ts";
+import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
 import { codegenModulePaths, generateCodegen } from "./codegen.ts";
 import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
 import { resolvePkgRoot } from "./engine-root.ts";
@@ -642,6 +644,24 @@ export class DBXToolsNodeProject
     initProject(this, options);
   }
 
+  public override renderWorkflowSetup(options?: javascript.RenderWorkflowSetupOptions): JobStep[] {
+    const steps = super.renderWorkflowSetup(options);
+    if (this.parent) return steps;
+    return steps.flatMap((step) => {
+      if (step.uses === "oven-sh/setup-bun@v2") return [...bunCacheRestoreSteps(this)];
+      if (step.run === "bun install") {
+        return [
+          step,
+          bunCacheSaveStep({
+            condition:
+              "github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository",
+          }),
+        ];
+      }
+      return [step];
+    }) as JobStep[];
+  }
+
   public override preSynthesize(): void {
     if (this.rootInstallOnly) this.with(ROOT_INSTALL_ONLY_MIXIN);
     super.preSynthesize();
@@ -1066,6 +1086,7 @@ function initProject(
   // a plain `bun` exec rather than any wrapper: the default task is spawned by
   // nested installs/synths, and a wrapper that exported `npm_config_*` broke them.
   project.defaultTask?.reset("bun .projenrc.ts");
+  project.buildWorkflow?.workflow.file?.addOverride("jobs.build.env.BUN_VERSION", BUN_VERSION);
 
   // Pin bun's hoisted linker workspace-wide (see RootBunfigFile) so a peer dep
   // resolves to one copy and singletons/types stay coherent.

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,
@@ -766,6 +767,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,15 +776,6 @@ 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",
@@ -803,6 +796,11 @@ export class DBXToolsRustWorkspace {
               },
             ]
           : []),
+        ...(hasNodeBindings
+          ? bunCacheRestoreSteps(project, {
+              condition: "steps.ubrn_cache.outputs.cache-hit != 'true'",
+            })
+          : []),
         {
           name: "Log cache configuration",
           shell: "bash",
@@ -833,6 +831,9 @@ export class DBXToolsRustWorkspace {
                 shell: "bash",
                 run: timedBash("node_tooling", "bun install"),
               },
+              bunCacheSaveStep({
+                condition: "steps.ubrn_cache.outputs.cache-hit != 'true'",
+              }),
             ]
           : []),
         ...(hasNodeBindings

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/tasks/uniffi-release.mjs

@@ -150,10 +150,8 @@ 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);