@dbx-tools/projen 0.6.182 → 0.6.185

package/README.md

@@ -153,7 +153,11 @@ skips matching files and fails when an existing filename has different content.
 
 The Rust matrix has one row per target. Each row installs native dependencies,
 restores Cargo and sccache once, builds the Cargo workspace once, then packages
-every discovered output from that shared build. Rust rows prepare native npm
+every discovered output from that shared build. Set a source-only crate's
+`releaseExcludeOs` package option to omit it from incompatible rows through
+Cargo `--exclude`; crates that produce UniFFI or release-binary artifacts cannot
+use this option because every configured target must produce their artifacts.
+Rust rows prepare native npm
 archives and Python wheels; they do not install Bun or UBRN and do not build
 Node facades. A binary-only row therefore installs no language package tool.
 `rustVersion` remains the MSRV recorded in package manifests, while

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.6.181";
+export const PACKAGE_VERSION = "0.6.184";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";

package/package.json

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

package/src/project-rs.ts

@@ -46,6 +46,8 @@ export interface RustPackageOptions {
   readonly private?: boolean;
   /** Build this crate's binary for each target and attach it to the GitHub release. */
   readonly release?: boolean;
+  /** Omit this source-only crate from release workspace builds on these operating systems. */
+  readonly releaseExcludeOs?: readonly RustReleaseOs[];
   readonly dependencies?: Readonly<Record<string, CargoDependency>>;
   readonly devDependencies?: Readonly<Record<string, CargoDependency>>;
   readonly features?: Readonly<Record<string, readonly string[]>>;
@@ -444,6 +446,34 @@ export class DBXToolsRustProject extends Project implements DBXToolsProject {
   }
 }
 
+function rustPackageDependencies(
+  packages: readonly DBXToolsRustProject[],
+  pkg: DBXToolsRustProject,
+  root: string,
+  workspaceDependencies: Readonly<Record<string, CargoDependency>> | undefined,
+): DBXToolsRustProject[] {
+  return packages.filter(
+    (dependency) =>
+      dependency !== pkg &&
+      Object.entries(pkg.packageOptions.dependencies ?? {}).some(([name, value]) => {
+        const resolved =
+          typeof value === "object" && value.workspace
+            ? (workspaceDependencies?.[name] ?? value)
+            : value;
+        return (
+          name === dependency.crateName ||
+          (typeof resolved === "object" &&
+            (resolved.package === dependency.crateName ||
+              (resolved.path !== undefined &&
+                resolve(
+                  typeof value === "object" && value.workspace ? root : pkg.outdir,
+                  resolved.path,
+                ) === dependency.outdir)))
+        );
+      }),
+  );
+}
+
 /** Generated Rust workspace plus convention-derived UniFFI facade packages. */
 export class DBXToolsRustWorkspace {
   readonly packages: readonly DBXToolsRustProject[];
@@ -473,27 +503,30 @@ export class DBXToolsRustWorkspace {
     );
 
     const bindings = this.packages.filter((pkg) => pkg.uniffi);
+    const packageDependencies = (pkg: DBXToolsRustProject) =>
+      rustPackageDependencies(this.packages, pkg, project.outdir, options.workspaceDependencies);
+    for (const pkg of this.packages) {
+      const excludedOs = new Set(pkg.packageOptions.releaseExcludeOs ?? []);
+      if (excludedOs.size && (pkg.uniffi || pkg.packageOptions.release)) {
+        throw new Error(
+          `${pkg.crateName} cannot set releaseExcludeOs because it produces target-specific release artifacts`,
+        );
+      }
+      for (const dependency of packageDependencies(pkg)) {
+        for (const os of dependency.packageOptions.releaseExcludeOs ?? []) {
+          if (!excludedOs.has(os)) {
+            throw new Error(
+              `${pkg.crateName} must exclude ${os} release builds because it depends on ${dependency.crateName}`,
+            );
+          }
+        }
+      }
+    }
     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)))
-            );
-          }),
+          packageDependencies(pkg).includes(dependency),
       );
     this.bindingMappings = orderRustBindings(
       bindings.map((pkg) => {
@@ -732,19 +765,30 @@ export class DBXToolsRustWorkspace {
         crate: pkg.crateName,
         binary: pkg.packageOptions.binaryName ?? pkg.crateName,
       }));
-    const orderedBindingCrates = this.bindingMappings.map((binding) => binding.crate);
-    const publicCrates = this.packages
-      .filter((pkg) => !pkg.packageOptions.private)
-      .sort((first, second) => {
-        // Binding crates publish in topological order before release-only crates that may consume them.
-        const firstIndex = orderedBindingCrates.indexOf(first.crateName);
-        const secondIndex = orderedBindingCrates.indexOf(second.crateName);
-        if (firstIndex < 0) return secondIndex < 0 ? 0 : 1;
-        if (secondIndex < 0) return -1;
-        return firstIndex - secondIndex;
-      })
-      .map((pkg) => pkg.crateName);
-    const targetMatrix = targets.map((target) => ({ ...target }));
+    const publicCrates = orderRustBindings(
+      this.packages
+        .filter((pkg) => !pkg.packageOptions.private)
+        .map((pkg) => ({
+          crate: pkg.crateName,
+          rust: pkg.outdir,
+          dependencies: rustPackageDependencies(
+            this.packages,
+            pkg,
+            project.outdir,
+            options.workspaceDependencies,
+          ).map((dependency) => dependency.crateName),
+        })),
+    ).map((pkg) => pkg.crate);
+    const hasReleaseExclusions = this.packages.some(
+      (pkg) => pkg.packageOptions.releaseExcludeOs?.length,
+    );
+    const targetMatrix = targets.map((target) => {
+      const cargoExcludes = this.packages
+        .filter((pkg) => pkg.packageOptions.releaseExcludeOs?.includes(target.os))
+        .map((pkg) => `--exclude ${pkg.crateName}`)
+        .join(" ");
+      return { ...target, ...(hasReleaseExclusions ? { cargoExcludes } : {}) };
+    });
     const hasPythonBindings = bindings.some((binding) => binding.python);
     const usePreinstalledWindowsRust = releaseRustVersion === "stable";
     const hasTargetOutputs =
@@ -893,7 +937,9 @@ export class DBXToolsRustWorkspace {
           },
           run: timedBash(
             "rust_workspace",
-            'cargo build --release --workspace --target "${{ matrix.cargo }}"',
+            `cargo build --release --workspace --target "\${{ matrix.cargo }}"${
+              hasReleaseExclusions ? " ${{ matrix.cargoExcludes }}" : ""
+            }`,
           ),
         },
         ...(bindingCommands.length