@dbx-tools/projen 0.9.12 → 0.9.17

package/README.md

@@ -184,8 +184,10 @@ Foreign callback adapters must first be wrapped in an object created by their
 own native library (`createStorageHandle` for auth), because callback registries
 are library-local. Release wheels replace sibling Git requirements with matching
 native-wheel versions, and dependent publishers wait for their dependencies.
-Each crate builds its own `<crate>-uniffi-bindgen` executable so a workspace
-build has no colliding binary outputs. Packaging runs that prebuilt executable.
+Each crate builds its own `<crate>-uniffi-bindgen` executable so one target row
+has no colliding binary outputs. The executable requires the generated
+`uniffi-bindgen` feature, which enables `uniffi/cli` only in the UniFFI matrix.
+Packaging runs that prebuilt executable.
 Cargo manifests, target config, and UniFFI config are generated from structured
 Projen `TomlFile` objects. Local and release Python generation share one
 dependency-free helper for generator arguments, target-specific executable
@@ -231,13 +233,16 @@ branch that already contains released `main`, and merges `main` into a diverged
 branch when the merge is conflict-free. Missing branches and conflicted merges
 are left untouched.
 
-The Rust matrix has one row per target. Each row installs native dependencies,
-builds the Cargo workspace once, then packages every discovered output from
-that shared build. Set a source-only crate's or
+Rust release generation creates separate UniFFI and binary matrices with one row
+per target. A UniFFI row builds all discovered binding packages together. A
+binary row builds all selected release binaries in one Cargo invocation with
+the union of their required features, so a feature-gated companion does not
+trigger a second compile graph. Each matrix has its own source-scoped
+fingerprint, raw bundle, and Cargo cache namespace. Set a source-only crate's or
 release-enabled binary's `releaseExcludeOs` package option to omit it from
-incompatible rows through Cargo `--exclude`. Release binary packaging and
-artifact upload are skipped in those rows. UniFFI crates cannot use this option
-because every configured target must produce their artifacts.
+incompatible binary rows. Release binary packaging and artifact upload are
+skipped in those rows. UniFFI crates cannot use this option because every
+configured target must produce their artifacts.
 Set a release binary's `cli` package option and the workspace
 `cliRegistryPath` to generate a typed `dbx` command registry from the same
 selected targets. The generated entries carry only the archives that the
@@ -250,17 +255,17 @@ Node facades. A binary-only row therefore installs no language package tool.
 `rustVersion` remains the MSRV recorded in package manifests, while
 `releaseRustVersion` independently defaults release compilation to `stable`.
 Stable Windows rows verify and use the hosted runner's installed Rust toolchain
-and select `rust-lld` for the workspace build. Rust release rows restore and
-update dependency-only Cargo caches in the release branch's cache scope. The
-cache key excludes workspace version changes, and manual tag recovery restores
-without saving a tag-scoped copy. There is no separate cache workflow or
-sccache layer. After publishing the current raw Rust bundles and build manifests,
+and select `rust-lld` for compilation. Rust release rows restore and update
+dependency-only Cargo caches in the release branch's category-and-target cache
+scope. The cache key excludes workspace version changes, and manual tag recovery
+restores without saving a tag-scoped copy. There is no separate cache workflow
+or sccache layer. After publishing the current raw Rust bundles and build manifests,
 the GitHub release job deletes those internal assets from published
 `vMAJOR.MINOR.PATCH` releases strictly lower than the current version while
 leaving versioned consumer binaries in place. Phase timings are written to each
 build log. Python generation executes the already-built
-`target/<triple>/release/<crate>-uniffi-bindgen` directly. Artifact packaging therefore
-does no Rust compilation after the main workspace build.
+`target/<triple>/release/<crate>-uniffi-bindgen` directly. Artifact packaging
+therefore does no Rust compilation after the UniFFI build.
 
 Artifacts identify their crate, target, and type. Rust jobs publish non-private
 Cargo crates with `cargo publish --no-verify` and upload requested binary assets

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.9.12";
+export const PACKAGE_VERSION = "0.9.17";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -57,7 +57,7 @@ export type { DBXToolsJavaScriptProject, DBXToolsReleaseMode, PullRequestTitlePo
 export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
 export type { PythonRepositoryOptions, PythonPackageOptions, PythonTrustedPublisherOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
 export { DBXToolsRustProject, RustReleaseOs, RustReleaseCpu, UNIFFI_RELEASE_TARGETS, DBXToolsRustWorkspace } from "./src/project-rs.ts";
-export type { CargoDependency, CargoDependencyOptions, CargoExampleOptions, DBXToolsRustProjectOptions, RustCrateOptions, RustCliOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
+export type { CargoDependency, CargoDependencyOptions, CargoExampleOptions, DBXToolsRustProjectOptions, RustCrateOptions, RustCliOptions, RustOpenApiOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustOpenApiMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
 export { PROJEN_VERSION } from "./src/projen-version.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
@@ -76,6 +76,7 @@ export { DBXToolsRootTsconfig } from "./src/tsconfig.ts";
 export { makeDefaultedInterfaceParametersOptional, removeObsoleteInterfaceAliases, addTypeScriptExtensionsToBindingImports, addExplicitInterfaceReexports } from "./src/uniffi.ts";
 export type { TypeScriptBindingModule } from "./src/uniffi.ts";
 export { DBXToolsVsCode } from "./src/vscode.ts";
-export type { IgnoreGroupOptions } from "./src/watch.ts";
+export type { IgnoreGroupOptions, WatchLoopOptions } from "./src/watch.ts";
+export type { WorkspaceMutationLockOptions } from "./src/workspace-lock.ts";
 export { VERSION_FILE, DEFAULT_VERSION } from "./src/workspace-version.ts";
 export type { Semver, VersionLevel } from "./src/workspace-version.ts";

package/package.json

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

package/src/_rust-project.ts

@@ -2,13 +2,15 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import * as projectUtils from "@dbx-tools/core/project-utils";
-import { stringUtils } from "@dbx-tools/shared-core";
+import { object, stringUtils } from "@dbx-tools/shared-core";
 import { License, Project, TextFile, TomlFile, javascript, type Task } from "projen";
 import { DBX_TOOLS_LICENSE, projectRepositoryUrl } from "./project-js.ts";
 import type { RustReleaseOs } from "./project-rs.ts";
 import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
 
+export const UNIFFI_BINDGEN_FEATURE = "uniffi-bindgen";
+
 export interface CargoDependencyOptions {
   readonly version?: string;
   readonly workspace?: boolean;
@@ -50,6 +52,16 @@ export interface CargoExampleOptions {
   readonly requiredFeatures?: readonly string[];
 }
 
+/** Rust code-first OpenAPI producer consumed by the shared generator. */
+export interface RustOpenApiOptions {
+  /** Cargo binary that handles `--generate-spec` when the package has multiple binaries. */
+  readonly binary?: string;
+  /** Features enabled while running the OpenAPI export command. */
+  readonly features?: readonly string[];
+  /** Disable the crate's default features while running the export command. */
+  readonly noDefaultFeatures?: boolean;
+}
+
 /** Cargo package, target, binding, and release behavior shared by every Rust project. */
 export interface RustCrateOptions {
   readonly description?: string;
@@ -67,6 +79,8 @@ export interface RustCrateOptions {
   readonly defaultFeatures?: readonly string[];
   /** Explicit example targets, including optional Cargo feature gates. */
   readonly examples?: readonly CargoExampleOptions[];
+  /** Generate an OpenAPI client package from this crate's aide document. */
+  readonly openapi?: boolean | RustOpenApiOptions;
   /** Cargo and release executable name. Defaults to the generated package name. */
   readonly binaryName?: string;
   /** Additional Cargo binary targets owned by this crate. */
@@ -106,29 +120,31 @@ export interface DBXToolsRustProjectOptions extends DBXToolsProjectOptions, Rust
   readonly repository?: string;
 }
 
-function rustSources(directory: string): string[] {
-  if (!existsSync(directory)) return [];
-  const files: string[] = [];
+function* rustSources(directory: string): Generator<string> {
+  if (!existsSync(directory)) return;
   for (const entry of readdirSync(directory, { withFileTypes: true })) {
     const path = join(directory, entry.name);
-    if (entry.isDirectory()) files.push(...rustSources(path));
-    else if (entry.isFile() && entry.name.endsWith(".rs")) files.push(path);
+    if (entry.isDirectory()) yield* rustSources(path);
+    else if (entry.isFile() && entry.name.endsWith(".rs")) yield path;
   }
-  return files;
 }
 
 /** Whether a Rust crate embeds the UniFFI proc-macro scaffolding marker. */
 export function hasUniFFIBindings(directory: string): boolean {
-  return rustSources(join(directory, "src")).some((path) =>
-    /\buniffi\s*::\s*setup_scaffolding\s*!\s*\(/.test(readFileSync(path, "utf8")),
-  );
+  return object
+    .sequence(rustSources(join(directory, "src")))
+    .some((path) => /\buniffi\s*::\s*setup_scaffolding\s*!\s*\(/.test(readFileSync(path, "utf8")));
+}
+
+function hasRustSources(directory: string): boolean {
+  return object.sequence(rustSources(directory)).some(() => true);
 }
 
 export function discoverRustCrates(root: string): string[] {
   if (!existsSync(root)) return [];
   return readdirSync(root, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
-    .filter((entry) => rustSources(join(root, entry.name, "src")).length > 0)
+    .filter((entry) => hasRustSources(join(root, entry.name, "src")))
     .map((entry) => entry.name)
     .sort();
 }
@@ -210,6 +226,7 @@ function packageOptions(
     ...(options.devDependencies ? { devDependencies: options.devDependencies } : {}),
     ...(options.features ? { features: options.features } : {}),
     ...(options.defaultFeatures ? { defaultFeatures: options.defaultFeatures } : {}),
+    ...(options.openapi !== undefined ? { openapi: options.openapi } : {}),
     ...(options.binaryName ? { binaryName: options.binaryName } : {}),
     ...(options.binaries ? { binaries: options.binaries } : {}),
     ...(options.cli !== undefined ? { cli: options.cli } : {}),
@@ -291,7 +308,13 @@ export class RustProject extends Project implements DBXToolsProject {
         ? {
             bin: [
               ...(this.uniffi
-                ? [{ name: `${this.crateName}-uniffi-bindgen`, path: "uniffi-bindgen.rs" }]
+                ? [
+                    {
+                      name: `${this.crateName}-uniffi-bindgen`,
+                      path: "uniffi-bindgen.rs",
+                      "required-features": [UNIFFI_BINDGEN_FEATURE],
+                    },
+                  ]
                 : []),
               ...(binary ? [{ name: binaryName, path: "src/main.rs" }] : []),
               ...(options.binaries ?? []).map((target) => ({
@@ -304,11 +327,12 @@ export class RustProject extends Project implements DBXToolsProject {
             ],
           }
         : {}),
-      ...(options.features || options.defaultFeatures
+      ...(this.uniffi || options.features || options.defaultFeatures
         ? {
             features: {
               ...(options.defaultFeatures ? { default: [...options.defaultFeatures] } : {}),
               ...options.features,
+              ...(this.uniffi ? { [UNIFFI_BINDGEN_FEATURE]: ["uniffi/cli"] } : {}),
             },
           }
         : {}),