@dbx-tools/projen 0.6.148 → 0.6.150

package/index.ts

@@ -45,8 +45,8 @@ export { PackageIdentifier, PROJEN_VERSION, DBXToolsNodeProject, ROOT_INSTALL_ON
 export type { DBXToolsJavaScriptProject, DBXToolsJavaScriptProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
 export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
 export type { PythonRepositoryOptions, PythonPackageOptions, PythonTrustedPublisherOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
-export { UNIFFI_RELEASE_TARGETS, DBXToolsRustProject, DBXToolsRustWorkspace } from "./src/project-rs.ts";
-export type { CargoDependencyOptions, CargoDependency, RustPackageOptions, DBXToolsRustWorkspaceOptions, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping } from "./src/project-rs.ts";
+export { RustReleaseOs, RustReleaseCpu, UNIFFI_RELEASE_TARGETS, DBXToolsRustProject, DBXToolsRustWorkspace } from "./src/project-rs.ts";
+export type { CargoDependencyOptions, CargoDependency, RustPackageOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping } from "./src/project-rs.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
 export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release.ts";

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.148",
-    "@dbx-tools/path": "0.6.148",
-    "@dbx-tools/shared-core": "0.6.148",
+    "@dbx-tools/core": "0.6.150",
+    "@dbx-tools/path": "0.6.150",
+    "@dbx-tools/shared-core": "0.6.150",
     "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.148",
+  "version": "0.6.150",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/project-rs.ts

@@ -32,6 +32,7 @@ export interface RustPackageOptions {
   readonly devDependencies?: Readonly<Record<string, CargoDependency>>;
   readonly features?: Readonly<Record<string, readonly string[]>>;
   readonly defaultFeatures?: readonly string[];
+  /** Cargo and release executable name. Defaults to the generated package name. */
   readonly binaryName?: string;
   readonly bindings?: readonly ("node" | "python")[];
   readonly nodeDependencies?: readonly string[];
@@ -56,17 +57,35 @@ export interface DBXToolsRustWorkspaceOptions {
   readonly release?: boolean;
   /** Native release targets; defaults to the maintained GitHub-hosted matrix. */
   readonly releaseTargets?: readonly UniFFIReleaseTarget[];
+  /** Maintained OS/CPU combinations to release. Defaults to every supported target. */
+  readonly releasePlatforms?: readonly RustReleasePlatform[];
   /** Workflow name used by downstream release stages. Defaults to `rust-release`. */
   readonly releaseWorkflowName?: string;
 }
 
+export enum RustReleaseOs {
+  DARWIN = "darwin",
+  LINUX = "linux",
+  WINDOWS = "win32",
+}
+
+export enum RustReleaseCpu {
+  ARM64 = "arm64",
+  X64 = "x64",
+}
+
+export interface RustReleasePlatform {
+  readonly os: RustReleaseOs;
+  readonly cpu: RustReleaseCpu;
+}
+
 export interface UniFFIReleaseTarget {
   readonly runner: string;
   readonly cargo: string;
   readonly node: string;
   readonly python: string;
-  readonly os: "darwin" | "linux" | "win32";
-  readonly cpu: "arm64" | "x64";
+  readonly os: RustReleaseOs;
+  readonly cpu: RustReleaseCpu;
   readonly libc?: "glibc";
 }
 
@@ -77,8 +96,8 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
     cargo: "x86_64-unknown-linux-gnu",
     node: "linux-x64-gnu",
     python: "manylinux_2_35_x86_64",
-    os: "linux",
-    cpu: "x64",
+    os: RustReleaseOs.LINUX,
+    cpu: RustReleaseCpu.X64,
     libc: "glibc",
   },
   {
@@ -86,8 +105,8 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
     cargo: "aarch64-unknown-linux-gnu",
     node: "linux-arm64-gnu",
     python: "manylinux_2_39_aarch64",
-    os: "linux",
-    cpu: "arm64",
+    os: RustReleaseOs.LINUX,
+    cpu: RustReleaseCpu.ARM64,
     libc: "glibc",
   },
   {
@@ -95,27 +114,64 @@ export const UNIFFI_RELEASE_TARGETS: readonly UniFFIReleaseTarget[] = [
     cargo: "x86_64-apple-darwin",
     node: "darwin-x64",
     python: "macosx_13_0_x86_64",
-    os: "darwin",
-    cpu: "x64",
+    os: RustReleaseOs.DARWIN,
+    cpu: RustReleaseCpu.X64,
   },
   {
     runner: "macos-14",
     cargo: "aarch64-apple-darwin",
     node: "darwin-arm64",
     python: "macosx_11_0_arm64",
-    os: "darwin",
-    cpu: "arm64",
+    os: RustReleaseOs.DARWIN,
+    cpu: RustReleaseCpu.ARM64,
   },
   {
     runner: "windows-latest",
     cargo: "x86_64-pc-windows-msvc",
     node: "win32-x64-msvc",
     python: "win_amd64",
-    os: "win32",
-    cpu: "x64",
+    os: RustReleaseOs.WINDOWS,
+    cpu: RustReleaseCpu.X64,
   },
 ] as const;
 
+const RUST_CACHE_ENV = {
+  RUSTC_WRAPPER: "sccache",
+  SCCACHE_GHA_ENABLED: "true",
+} as const;
+
+function rustCacheSteps(sharedKey: string): readonly Record<string, unknown>[] {
+  return [
+    { name: "Setup sccache", uses: "mozilla-actions/sccache-action@v0.0.11" },
+    {
+      name: "Cache Cargo registry",
+      uses: "Swatinem/rust-cache@v2.9.2",
+      with: {
+        "cache-targets": false,
+        "add-job-id-key": false,
+        "add-rust-environment-hash-key": false,
+        "shared-key": sharedKey,
+      },
+    },
+  ];
+}
+
+function releaseTargets(options: DBXToolsRustWorkspaceOptions): readonly UniFFIReleaseTarget[] {
+  if (options.releaseTargets && options.releasePlatforms) {
+    throw new Error("releaseTargets and releasePlatforms are mutually exclusive");
+  }
+  if (options.releaseTargets) return options.releaseTargets;
+  if (!options.releasePlatforms) return UNIFFI_RELEASE_TARGETS;
+  return options.releasePlatforms.map((platform) => {
+    const target = UNIFFI_RELEASE_TARGETS.find(
+      (candidate) => candidate.os === platform.os && candidate.cpu === platform.cpu,
+    );
+    if (!target)
+      throw new Error(`Unsupported Rust release platform: ${platform.os}-${platform.cpu}`);
+    return target;
+  });
+}
+
 /** Persisted mapping consumed by the focused Rust source watcher. */
 export interface RustBindingMapping {
   readonly crate: string;
@@ -218,6 +274,8 @@ export class DBXToolsRustProject extends Project implements DBXToolsProject {
     this.packageOptions = options;
     this.uniffi = hasUniFFIBindings(this.outdir);
     const library = existsSync(join(this.outdir, "src/lib.rs"));
+    const binary = existsSync(join(this.outdir, "src/main.rs"));
+    const binaryName = options.binaryName ?? crateName;
     const manifest: Record<string, unknown> = {
       package: {
         name: crateName,
@@ -238,11 +296,11 @@ export class DBXToolsRustProject extends Project implements DBXToolsProject {
             },
           }
         : {}),
-      ...(this.uniffi || options.binaryName
+      ...(this.uniffi || binary
         ? {
             bin: this.uniffi
               ? { name: "uniffi-bindgen", path: "uniffi-bindgen.rs" }
-              : { name: options.binaryName, path: "src/main.rs" },
+              : { name: binaryName, path: "src/main.rs" },
           }
         : {}),
       ...(options.features || options.defaultFeatures
@@ -356,9 +414,7 @@ export class DBXToolsRustWorkspace {
         trustedPublisher: {
           workflowName: options.releaseWorkflowName ?? "rust-release",
           environment: `native-${pkg.crateName}`,
-          artifacts: `platform-specific wheels for ${(
-            options.releaseTargets ?? UNIFFI_RELEASE_TARGETS
-          )
+          artifacts: `platform-specific wheels for ${releaseTargets(options)
             .map((target) => `${target.os}-${target.cpu}`)
             .join(", ")}; all architectures publish to this one PyPI project`,
         },
@@ -390,12 +446,12 @@ export class DBXToolsRustWorkspace {
       node.package.addField("private", true);
       node.package.file.addDeletionOverride("publishConfig");
       node.package.addField("description", `Node bindings for ${binding.crateName}`);
-      const releaseTargets = options.releaseTargets ?? UNIFFI_RELEASE_TARGETS;
+      const nativeTargets = releaseTargets(options);
       if (options.release ?? true) {
         node.package.addField(
           "optionalDependencies",
           Object.fromEntries(
-            releaseTargets.map((target) => [
+            nativeTargets.map((target) => [
               `@${string.toSlug(options.scope)}/${directory}-${target.node}`,
               readWorkspaceVersion(project.outdir),
             ]),
@@ -471,7 +527,7 @@ export class DBXToolsRustWorkspace {
       (options.release ?? true) &&
       (this.bindingMappings.length > 0 || this.packages.some((pkg) => pkg.packageOptions.release))
     ) {
-      this.addReleaseWorkflow(project, options, options.releaseTargets ?? UNIFFI_RELEASE_TARGETS);
+      this.addReleaseWorkflow(project, options, releaseTargets(options));
     }
   }
 
@@ -506,6 +562,7 @@ export class DBXToolsRustWorkspace {
     const buildJob = {
       name: "${{ matrix.binding.crate }} / ${{ matrix.target.node }}",
       "runs-on": "${{ matrix.target.runner }}",
+      env: RUST_CACHE_ENV,
       strategy: {
         "fail-fast": false,
         matrix: { include: matrix },
@@ -523,6 +580,7 @@ export class DBXToolsRustWorkspace {
           uses: "dtolnay/rust-toolchain@stable",
           with: { targets: "${{ matrix.target.cargo }}" },
         },
+        ...rustCacheSteps("release-${{ matrix.target.cargo }}"),
         {
           name: "Install Linux native dependencies",
           if: "${{ matrix.target.os == 'linux' }}",
@@ -554,6 +612,7 @@ export class DBXToolsRustWorkspace {
     const binaryBuildJob = {
       name: "${{ matrix.package.crate }} / ${{ matrix.target.node }}",
       "runs-on": "${{ matrix.target.runner }}",
+      env: RUST_CACHE_ENV,
       strategy: { "fail-fast": false, matrix: { include: binaryMatrix } },
       steps: [
         { name: "Checkout", uses: "actions/checkout@v6" },
@@ -562,6 +621,7 @@ export class DBXToolsRustWorkspace {
           uses: "dtolnay/rust-toolchain@stable",
           with: { targets: "${{ matrix.target.cargo }}" },
         },
+        ...rustCacheSteps("release-${{ matrix.target.cargo }}"),
         {
           name: "Install Linux native dependencies",
           if: "${{ matrix.target.os == 'linux' }}",
@@ -572,10 +632,18 @@ export class DBXToolsRustWorkspace {
           shell: "bash",
           run: [
             'cargo build --release --package "${{ matrix.package.crate }}" --bin "${{ matrix.package.binary }}" --target "${{ matrix.target.cargo }}"',
-            "mkdir -p dist/rust-release",
+            "mkdir -p dist/rust-release/stage",
             "SOURCE=\"target/${{ matrix.target.cargo }}/release/${{ matrix.package.binary }}${{ matrix.target.os == 'win32' && '.exe' || '' }}\"",
-            "DESTINATION=\"dist/rust-release/${{ matrix.package.binary }}-${{ matrix.target.node }}${{ matrix.target.os == 'win32' && '.exe' || '' }}\"",
+            "DESTINATION=\"dist/rust-release/stage/${{ matrix.package.binary }}${{ matrix.target.os == 'win32' && '.exe' || '' }}\"",
             'cp "$SOURCE" "$DESTINATION"',
+            'if [ "${{ matrix.target.os }}" = "win32" ]; then',
+            '  ARCHIVE="dist/rust-release/${{ matrix.package.binary }}-${{ matrix.target.node }}.zip"',
+            '  7z a "$ARCHIVE" "$DESTINATION"',
+            "else",
+            '  ARCHIVE="dist/rust-release/${{ matrix.package.binary }}-${{ matrix.target.node }}.tar.gz"',
+            '  tar -C dist/rust-release/stage -czf "$ARCHIVE" "${{ matrix.package.binary }}"',
+            "fi",
+            "rm -rf dist/rust-release/stage",
           ].join("\n"),
         },
         {
@@ -665,9 +733,15 @@ export class DBXToolsRustWorkspace {
             needs: [matrix.length ? "build" : "build-binaries"],
             "runs-on": "ubuntu-latest",
             permissions: { contents: "read" },
+            env: RUST_CACHE_ENV,
             steps: [
               { name: "Checkout", uses: "actions/checkout@v6" },
               { name: "Setup Rust", uses: "dtolnay/rust-toolchain@stable" },
+              ...rustCacheSteps("cargo-publish"),
+              {
+                name: "Install Linux native dependencies",
+                run: "sudo apt-get update && sudo apt-get install --yes libdbus-1-dev pkg-config",
+              },
               {
                 name: "Publish public crates",
                 env: { CARGO_REGISTRY_TOKEN: "${{ secrets.CARGO_REGISTRY_TOKEN }}" },
@@ -679,6 +753,7 @@ export class DBXToolsRustWorkspace {
             if: "${{ github.event_name == 'push' && vars.LOCAL_REPOSITORIES == 'true' }}",
             "runs-on": ["self-hosted"],
             permissions: { contents: "read" },
+            env: RUST_CACHE_ENV,
             steps: [
               { name: "Checkout", uses: "actions/checkout@v6" },
               {
@@ -688,6 +763,7 @@ export class DBXToolsRustWorkspace {
               },
               { name: "Setup uv", uses: "astral-sh/setup-uv@v7" },
               { name: "Setup Rust", uses: "dtolnay/rust-toolchain@stable" },
+              ...rustCacheSteps("local-${{ runner.os }}-${{ runner.arch }}"),
               { name: "Install", run: "bun install" },
               {
                 name: "Build and publish host-native packages",

package/tasks/bump.ts

@@ -67,7 +67,11 @@ import {
 
 const logger = log.logger("projen:bump");
 const LEVELS = ["patch", "minor", "major"] as const;
+const RELEASE_OSES = ["darwin", "linux", "win32"] as const;
+const RELEASE_ARCHES = ["arm64", "x64"] as const;
 type Level = (typeof LEVELS)[number];
+type ReleaseOs = (typeof RELEASE_OSES)[number];
+type ReleaseArch = (typeof RELEASE_ARCHES)[number];
 
 /** A standalone in-repo project released alongside the root, on its own tag prefix. */
 interface Sibling {
@@ -89,6 +93,10 @@ function parseSibling(value: string, previous: Sibling[]): Sibling[] {
   return [...previous, { dir: value.slice(0, at), prefix: value.slice(at + 1) }];
 }
 
+function collectValue<T extends string>(value: T, previous: T[]): T[] {
+  return [...previous, value];
+}
+
 function increment(v: Semver, level: Level): Semver {
   if (level === "major") return [v[0] + 1, 0, 0];
   if (level === "minor") return [v[0], v[1] + 1, 0];
@@ -174,6 +182,18 @@ program
     parseSibling,
     [] as Sibling[],
   )
+  .addOption(
+    new Option("--os <os>", "release operating system, repeatable; crossed with every --arch")
+      .choices([...RELEASE_OSES])
+      .argParser((value, previous: ReleaseOs[]) => collectValue(value as ReleaseOs, previous))
+      .default([] as ReleaseOs[]),
+  )
+  .addOption(
+    new Option("--arch <arch>", "release CPU architecture, repeatable; crossed with every --os")
+      .choices([...RELEASE_ARCHES])
+      .argParser((value, previous: ReleaseArch[]) => collectValue(value as ReleaseArch, previous))
+      .default([] as ReleaseArch[]),
+  )
   // Declared in the `--no-` form so commander creates a boolean that defaults to
   // `true` and is turned off by `--no-synth` / `--no-version` / ... (the
   // positive `--synth` etc. also work and are no-ops on the default).
@@ -200,6 +220,8 @@ program
       level: Level;
       prefix: string;
       sibling: Sibling[];
+      os: ReleaseOs[];
+      arch: ReleaseArch[];
       synth: boolean;
       version: boolean;
       commit: boolean;
@@ -212,6 +234,9 @@ program
     }) => {
       const pkgPath = resolve(process.cwd(), "package.json");
       if (!existsSync(pkgPath)) throw new Error(`no package.json in ${process.cwd()}`);
+      if ((opts.os.length === 0) !== (opts.arch.length === 0)) {
+        throw new Error("--os and --arch must be used together");
+      }
 
       const siblings = opts.sibling.map((s) => ({ ...s, pkgPath: resolve(s.dir, "package.json") }));
       for (const s of siblings) {
@@ -260,12 +285,19 @@ program
 
       if (opts.synth) {
         logger.info("synthesizing (projen)");
+        const releasePlatforms = opts.os
+          .flatMap((os) => opts.arch.map((arch) => `${os}:${arch}`))
+          .join(",");
         exec.spawnSync("bun", [".projenrc.ts"], {
           cwd: process.cwd(),
           stdout: "inherit",
           stderr: "inherit",
           stdin: "ignore",
           check: true,
+          env: {
+            ...process.env,
+            ...(releasePlatforms ? { DBX_TOOLS_RELEASE_PLATFORMS: releasePlatforms } : {}),
+          },
         });
       }