@dbx-tools/projen 0.9.12 → 0.9.18

package/src/release-plan.ts

@@ -47,13 +47,15 @@ export interface PlannedRustTarget {
   readonly runner: string;
   readonly python: string;
   readonly libc: string;
-  readonly cargoExcludes: string;
+  readonly glibcVersion: string;
   readonly packages: readonly string[];
+  readonly binaries: readonly string[];
+  readonly features: readonly string[];
 }
 
 /** Complete plan persisted as a workflow artifact and used for recovery. */
 export interface ReleasePlan {
-  readonly schemaVersion: 1;
+  readonly schemaVersion: 2;
   readonly units: readonly PlannedReleaseUnit[];
   readonly publishBatches: readonly (readonly string[])[];
   readonly nodePackages: readonly PlannedPackage[];
@@ -130,18 +132,52 @@ export function buildReleasePlan(
       ]);
     }
   }
-  const rustTargetsByKey = new Map<string, PlannedRustTarget>();
+  const rustTargets = new Map<string, PlannedRustTarget>();
   for (const artifact of artifacts) {
     const targets = artifact.data?.targets;
     if (!Array.isArray(targets)) continue;
+    const binary = artifact.kind === "github-binary";
     for (const value of targets) {
       if (!value || typeof value !== "object" || Array.isArray(value)) continue;
       const target = value as Record<string, unknown>;
       const required = ["os", "cpu", "node", "cargo", "runner", "python"] as const;
       if (!required.every((field) => typeof target[field] === "string")) continue;
       const key = String(target.node);
-      const currentTarget = rustTargetsByKey.get(key);
-      rustTargetsByKey.set(key, {
+      const currentTarget = rustTargets.get(key);
+      const packages = [
+        ...new Set([
+          ...(currentTarget?.packages ?? []),
+          ...(rustPackagesByUnit.get(artifact.unit) ?? []),
+        ]),
+      ].sort();
+      const binaries = binary
+        ? [
+            ...new Set([
+              ...(currentTarget?.binaries ?? []),
+              ...(typeof artifact.data?.binary === "string" ? [artifact.data.binary] : []),
+            ]),
+          ].sort()
+        : (currentTarget?.binaries ?? []);
+      const configuredFeatures = Array.isArray(artifact.data?.features)
+        ? artifact.data.features.filter((feature): feature is string => typeof feature === "string")
+        : [];
+      const crate = typeof artifact.data?.crate === "string" ? artifact.data.crate : undefined;
+      const features = binary
+        ? [
+            ...new Set([
+              ...(currentTarget?.features ?? []),
+              ...(crate
+                ? configuredFeatures.map((feature) => `${crate}/${feature}`)
+                : configuredFeatures),
+            ]),
+          ].sort()
+        : [
+            ...new Set([
+              ...(currentTarget?.features ?? []),
+              ...packages.map((pkg) => `${pkg}/uniffi-bindgen`),
+            ]),
+          ].sort();
+      rustTargets.set(key, {
         os: String(target.os),
         cpu: String(target.cpu),
         node: String(target.node),
@@ -149,17 +185,14 @@ export function buildReleasePlan(
         runner: String(target.runner),
         python: String(target.python),
         libc: typeof target.libc === "string" ? target.libc : "",
-        cargoExcludes: typeof target.cargoExcludes === "string" ? target.cargoExcludes : "",
-        packages: [
-          ...new Set([
-            ...(currentTarget?.packages ?? []),
-            ...(rustPackagesByUnit.get(artifact.unit) ?? []),
-          ]),
-        ].sort(),
+        glibcVersion: typeof target.glibcVersion === "string" ? target.glibcVersion : "",
+        packages,
+        binaries,
+        features,
       });
     }
   }
-  const rustTargets = [...rustTargetsByKey.values()].sort((a, b) => a.node.localeCompare(b.node));
+  const plannedRustTargets = [...rustTargets.values()].sort((a, b) => a.node.localeCompare(b.node));
   const publishBatches = current.publishBatches
     .map((batch) => batch.filter((unit) => selected.has(unit)))
     .filter((batch) => batch.length > 0);
@@ -179,14 +212,14 @@ export function buildReleasePlan(
     .filter(([, enabled]) => !enabled)
     .map(([name]) => name);
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     units,
     publishBatches,
     nodePackages,
     pythonPackages,
     rustPackages,
     artifacts,
-    rustTargets,
+    rustTargets: plannedRustTargets,
     stages,
     omittedStages,
   };

package/src/release.ts

@@ -117,6 +117,7 @@ export function releaseArtifactSteps(options: {
   readonly recoveredName: string;
   readonly pattern: string;
   readonly path: string;
+  readonly condition?: string;
 }): readonly JobStep[] {
   const shared = {
     pattern: options.pattern,
@@ -126,13 +127,13 @@ export function releaseArtifactSteps(options: {
   return [
     {
       name: options.currentName,
-      if: "${{ inputs.source_run_id == '' }}",
+      if: `\${{ ${options.condition ? `${options.condition} && ` : ""}inputs.source_run_id == '' }}`,
       uses: "actions/download-artifact@v8",
       with: shared,
     },
     {
       name: options.recoveredName,
-      if: "${{ inputs.source_run_id != '' }}",
+      if: `\${{ ${options.condition ? `${options.condition} && ` : ""}inputs.source_run_id != '' }}`,
       uses: "actions/download-artifact@v8",
       with: {
         ...shared,
@@ -179,6 +180,7 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
       release_tag: { stepId: "release", outputName: "release_tag" },
       expected_sha: { stepId: "release", outputName: "expected_sha" },
       release_version: { stepId: "release", outputName: "release_version" },
+      build_mode: { stepId: "release", outputName: "build_mode" },
     },
     steps: [
       {
@@ -186,7 +188,7 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
         uses: "actions/checkout@v6",
         with: {
           ref: "${{ github.event_name == 'push' && github.sha || inputs.expected_sha }}",
-          "fetch-depth": 2,
+          "fetch-depth": 0,
         },
       },
       {
@@ -205,6 +207,7 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
           EXPECTED_SHA:
             "${{ github.event_name == 'workflow_dispatch' && inputs.expected_sha || '' }}",
           DRY_RUN: "${{ github.event_name == 'workflow_dispatch' && inputs.dry_run || false }}",
+          GH_TOKEN: "${{ github.token }}",
         },
         // prettier-ignore
         run: stringUtils.dedent(
@@ -246,9 +249,15 @@ function verifyContextJob(tagPrefix: string, releaseBranch: string): Job {
               case "\${{ inputs.source_run_id }}" in *[!0-9]*|"") exit 1 ;; esac
             fi
           fi
+          BUILD_MODE="$(git log -1 --format=%B -- VERSION | sed -n 's/^Release-Build: //p' | tail -1)"
+          case "$BUILD_MODE" in local|remote) ;; *) BUILD_MODE="remote" ;; esac
+          if [ "$BUILD_MODE" = "local" ] && ! gh release view "$RELEASE_TAG" >/dev/null 2>&1; then
+            gh release create "$RELEASE_TAG" --draft --title "$RELEASE_TAG" --target "$RELEASE_SHA"
+          fi
           echo "release_tag=$RELEASE_TAG" >> "$GITHUB_OUTPUT"
           echo "expected_sha=$RELEASE_SHA" >> "$GITHUB_OUTPUT"
           echo "release_version=$RELEASE_VERSION" >> "$GITHUB_OUTPUT"
+          echo "build_mode=$BUILD_MODE" >> "$GITHUB_OUTPUT"
         `
           // ============================================================================
         ),
@@ -1021,6 +1030,11 @@ export class DBXToolsRelease extends Component {
               description:
                 "Prepare, validate, locally publish, and automatically merge a release PR",
             },
+            "release:assets": {
+              exec: taskScript(project, "release-assets.ts"),
+              receiveArgs: true,
+              description: "Build and upload native assets for an existing GitHub Release",
+            },
           }
         : {}),
     });

package/src/watch.ts

@@ -81,13 +81,28 @@ function ignoredPath(path: string): boolean {
  * (e.g. the projenrc watcher passes `{ dot: false }` so its lone dotfile target,
  * `.projenrc.ts`, isn't pruned by the default dotfile group and left with nothing to
  * watch - which would let the process exit immediately).
+ *
+ * `check` is forwarded to the workspace mutation lock so a watcher that can tell
+ * the batch is a no-op never waits on an unrelated holder.
  */
+export interface WatchLoopOptions {
+  ignoreOptions?: IgnoreGroupOptions;
+  check?: (changed: string[]) => boolean | Promise<boolean>;
+}
+
+function resolveWatchLoopOptions(config?: IgnoreGroupOptions | WatchLoopOptions): WatchLoopOptions {
+  if (!config) return {};
+  if ("check" in config || "ignoreOptions" in config) return config as WatchLoopOptions;
+  return { ignoreOptions: config as IgnoreGroupOptions };
+}
+
 export function watchLoop(
   tag: string,
   paths: string[],
   onBatch: (changed: string[]) => void | Promise<void>,
-  ignoreOptions?: IgnoreGroupOptions,
+  config?: IgnoreGroupOptions | WatchLoopOptions,
 ): void {
+  const { ignoreOptions, check } = resolveWatchLoopOptions(config);
   const pending = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | undefined;
   let running = false;
@@ -105,7 +120,9 @@ export function watchLoop(
     pending.clear();
     try {
       if (relevant.length) {
-        await withWorkspaceMutationLock(repoRoot, () => onBatch(relevant));
+        await withWorkspaceMutationLock(repoRoot, () => onBatch(relevant), {
+          check: check ? () => check(relevant) : undefined,
+        });
       }
     } catch (err) {
       logger.error(`${tag} cycle failed:`, err instanceof Error ? err.message : err);

package/src/workspace-lock.ts

@@ -6,17 +6,43 @@ import { log } from "@dbx-tools/shared-core";
 const MUTATION_LOCK_SCOPE = "dbx-tools-workspace-mutation";
 const logger = log.logger("projen:workspace-lock");
 
+export interface WorkspaceMutationLockOptions {
+  /**
+   * When this returns false, skip both the lock and the callback. After the
+   * lock is held it runs again so a completed holder can make the work a no-op
+   * without taking the critical section only to return.
+   */
+  check?: () => boolean | Promise<boolean>;
+}
+
 /**
  * Serialize synthesis, generated-file watchers, and release preparation for one
  * repository without coordinating unrelated worktrees or repositories.
+ *
+ * `check` is check-lock-check: a false result before acquire never waits, and a
+ * false result after acquire releases immediately without running `callback`.
  */
-export function withWorkspaceMutationLock<T>(
+export async function withWorkspaceMutationLock<T>(
   root: string,
   callback: () => T | Promise<T>,
-): Promise<T> {
+  options?: WorkspaceMutationLockOptions,
+): Promise<T | undefined> {
   const repository = resolve(root);
-  return fileLock.withFileLock([MUTATION_LOCK_SCOPE, repository], callback, {
-    backends: process.platform === "win32" ? ["file"] : ["flock", "file"],
-    onWait: () => logger.info("waiting for workspace mutation lock", { repository }),
-  });
+  const check = options?.check;
+  if (check && !(await check())) {
+    return undefined;
+  }
+  return fileLock.withFileLock(
+    [MUTATION_LOCK_SCOPE, repository],
+    async () => {
+      if (check && !(await check())) {
+        return undefined;
+      }
+      return callback();
+    },
+    {
+      backends: process.platform === "win32" ? ["file"] : ["flock", "file"],
+      onWait: () => logger.info("waiting for workspace mutation lock", { repository }),
+    },
+  );
 }

package/tasks/barrels.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 import { sep } from "node:path";
 import { parseArgs } from "node:util";
-import { log, stringUtils } from "@dbx-tools/shared-core";
+import { log, object, stringUtils } from "@dbx-tools/shared-core";
 import { generateBarrels } from "../src/barrels.ts";
 import { recordedPackages } from "../src/packages.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";
@@ -17,41 +17,58 @@ const { values } = parseArgs({
 });
 
 /** The recorded package dir that owns `abs`, if any (for a targeted barrel rebuild). */
-function ownerPackageDir(abs: string, pkgDirs: string[]): string | undefined {
-  return pkgDirs.find((dir) => abs === dir || abs.startsWith(dir + sep));
+function ownerPackageDir(
+  abs: string,
+  packages: readonly { readonly dir: string; readonly tags: readonly string[] }[],
+): string | undefined {
+  // The OpenAPI task rebuilds generated-client barrels after writing its files.
+  return packages.find(
+    ({ dir, tags }) => !tags.includes("openapi") && (abs === dir || abs.startsWith(dir + sep)),
+  )?.dir;
+}
+
+function changedBarrelTargets(changed: readonly string[]): object.Sequence<string> {
+  const packages = recordedPackages();
+  return object
+    .sequence(changed)
+    .map((path) => ownerPackageDir(path, packages))
+    .nonNull()
+    .distinct();
+}
+
+function warnUnownedChanges(changed: readonly string[]): void {
+  if (changed.length) {
+    logger.warn(
+      `no recorded package owns ${stringUtils.pluralize(changed.length, "change")}; ` +
+        "run `bun run default` (or touch .projenrc.ts) to pick up a new package folder",
+    );
+  }
 }
 
 if (values.watch) {
   // Watch the package roots; a source edit inside a package rebuilds just that
   // package's `index.ts` barrel (no re-synth - the projenrc watcher owns that).
   // watchLoop already drops generated paths, so a barrel write never re-triggers us.
-  watchLoop("barrels", watchRoots(), (changed) => {
-    const pkgDirs = recordedPackages().map((p) => p.dir);
-    const dirs = new Set<string>();
-    const unowned: string[] = [];
-    for (const p of changed) {
-      const owner = ownerPackageDir(p, pkgDirs);
-      if (owner) dirs.add(owner);
-      else unowned.push(p);
-    }
-    // A change under a package root that no RECORDED package owns is almost always a
-    // NEW package folder: it has no `pnpm-workspace.yaml` member yet, so there is no
-    // barrel for this watcher to target and only a re-synth can create one. Say so,
-    // rather than rebuilding every barrel in the repo - the previous fallback, which
-    // did a full-repo sweep on behalf of a file it could not barrel anyway, and in
-    // doing so raced the projenrc watcher's own post-synth sweep.
-    if (dirs.size === 0) {
-      if (unowned.length) {
-        logger.warn(
-          `no recorded package owns ${stringUtils.pluralize(unowned.length, "change")}; ` +
-            "run `bun run default` (or touch .projenrc.ts) to pick up a new package folder",
-        );
-      }
-      return;
-    }
-    const n = generateBarrels({ dirs: [...dirs] });
-    if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
-  });
+  watchLoop(
+    "barrels",
+    watchRoots(),
+    (changed) => {
+      const n = generateBarrels({ dirs: [...changedBarrelTargets(changed)] });
+      if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
+    },
+    {
+      check: (changed) => {
+        const targets = changedBarrelTargets(changed);
+        // A change under a package root that no recorded package owns is a new
+        // folder: only a re-synth can create its barrel, so this watcher skips.
+        if (!targets.some(() => true)) {
+          warnUnownedChanges(changed);
+          return false;
+        }
+        return true;
+      },
+    },
+  );
 } else {
   const dirs = Array.isArray(values.dir)
     ? values.dir.filter((value): value is string => typeof value === "string")

package/tasks/compile-workspace.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env -S bun
+/** Compile source-first workspace packages in a few TypeScript processes. */
+import { existsSync, readFileSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import { join, resolve } from "node:path";
+import * as exec from "@dbx-tools/core/exec";
+
+interface PackageManifest {
+  readonly name?: string;
+  readonly scripts?: Record<string, string>;
+  readonly workspaces?: string[];
+}
+
+interface TaskManifest {
+  readonly tasks?: {
+    readonly compile?: {
+      readonly steps?: Array<{ readonly execArgs?: string[] }>;
+    };
+  };
+}
+
+export interface CompilePlan {
+  readonly typescriptConfigs: string[];
+  readonly customPackages: Array<{ readonly name: string; readonly directory: string }>;
+}
+
+function readJson<T>(path: string): T {
+  return JSON.parse(readFileSync(path, "utf8")) as T;
+}
+
+function plainTypeScriptBuild(steps: unknown): boolean {
+  if (!Array.isArray(steps) || steps.length !== 1) return false;
+  const step = steps[0] as { execArgs?: string[] };
+  if (!step || typeof step !== "object") return false;
+  return (
+    Object.keys(step).length === 1 &&
+    step.execArgs?.length === 2 &&
+    step.execArgs[0] === "tsc" &&
+    step.execArgs[1] === "--build"
+  );
+}
+
+/** Read the root's concrete workspace paths on every run, including newly added members. */
+export function compilePlan(root: string): CompilePlan {
+  const workspace = readJson<PackageManifest>(join(root, "package.json"));
+  const typescriptConfigs: string[] = [];
+  const customPackages: CompilePlan["customPackages"] = [];
+  for (const member of workspace.workspaces ?? []) {
+    const directory = resolve(root, member);
+    const manifest = readJson<PackageManifest>(join(directory, "package.json"));
+    const script = manifest.scripts?.compile;
+    if (!script) continue;
+    const taskPath = join(directory, ".projen", "tasks.json");
+    const steps = existsSync(taskPath)
+      ? readJson<TaskManifest>(taskPath).tasks?.compile?.steps
+      : undefined;
+    if (
+      script === "projen compile" &&
+      !manifest.scripts?.precompile &&
+      !manifest.scripts?.postcompile &&
+      plainTypeScriptBuild(steps)
+    ) {
+      typescriptConfigs.push(join(directory, "tsconfig.json"));
+    } else {
+      customPackages.push({ name: manifest.name ?? member, directory });
+    }
+  }
+  return { typescriptConfigs, customPackages };
+}
+
+const emoji = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
+
+async function main(): Promise<void> {
+  const root = process.cwd();
+  const plan = compilePlan(root);
+  const jobs: Array<{ name: string; result: Promise<exec.ExecResult> }> = [];
+  if (plan.typescriptConfigs.length > 0) {
+    const batchCount = Math.min(4, availableParallelism(), plan.typescriptConfigs.length);
+    const batches = Array.from({ length: batchCount }, () => [] as string[]);
+    plan.typescriptConfigs.forEach((config, index) => batches[index % batchCount]!.push(config));
+    console.log(
+      `Type-checking ${plan.typescriptConfigs.length} workspaces in ${batchCount} batches`,
+    );
+    for (const [index, batch] of batches.entries()) {
+      jobs.push({
+        name: `TypeScript batch ${index + 1}`,
+        result: exec.spawn("bunx", ["tsc", "--build", ...batch], {
+          cwd: root,
+          stdin: "ignore",
+          stdout: "inherit",
+          stderr: "inherit",
+        }),
+      });
+    }
+  }
+  for (const pkg of plan.customPackages) {
+    jobs.push({
+      name: pkg.name,
+      result: exec.spawn("bun", ["run", "compile"], {
+        cwd: pkg.directory,
+        stdin: "ignore",
+        stdout: (line) => console.log(`${pkg.name}: ${line.replace(emoji, "")}`),
+        stderr: (line) => console.error(`${pkg.name}: ${line.replace(emoji, "")}`),
+      }),
+    });
+  }
+  const results = await Promise.allSettled(jobs.map((job) => job.result));
+  let failed = false;
+  for (const [index, result] of results.entries()) {
+    if (result.status === "rejected") {
+      console.error(`${jobs[index]!.name} compile failed:`, result.reason);
+      failed = true;
+    } else if (result.value.exitCode !== 0) {
+      console.error(`${jobs[index]!.name} compile exited with ${result.value.exitCode}`);
+      failed = true;
+    }
+  }
+  if (failed) process.exitCode = 1;
+}
+
+if (import.meta.main) await main();

package/tasks/openapi.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
-import { log, stringUtils } from "@dbx-tools/shared-core";
+import { log, object, stringUtils } from "@dbx-tools/shared-core";
 import { generateBarrels } from "../src/barrels.ts";
-import { generateOpenapi, isTsoaController } from "../src/openapi.ts";
+import { generateOpenapi, isOpenapiSource, openapiWatchRoots } from "../src/openapi.ts";
 import { runSynth } from "../src/scaffold.ts";
-import { watchLoop, watchRoots } from "../src/watch.ts";
+import { watchLoop } from "../src/watch.ts";
 
 const logger = log.logger("projen:openapi");
 
@@ -11,14 +11,18 @@ if (process.argv.includes("--watch")) {
   // Watch the package roots; a changed tsoa controller regenerates the openapi
   // packages (spec + client) and rebuilds just their barrels. The projenrc watcher
   // (alongside under `concurrently`) owns full re-synth, so no re-synth here.
-  watchLoop("openapi", watchRoots(), async (changed) => {
-    if (!changed.some(isTsoaController)) return;
-    const dirs = await generateOpenapi();
-    if (dirs.length) {
-      generateBarrels({ dirs });
-      logger.success(`regenerated openapi (${stringUtils.pluralize(dirs.length, "package")})`);
-    }
-  });
+  watchLoop(
+    "openapi",
+    openapiWatchRoots(),
+    async () => {
+      const dirs = await generateOpenapi();
+      if (dirs.length) {
+        generateBarrels({ dirs });
+        logger.success(`regenerated openapi (${stringUtils.pluralize(dirs.length, "package")})`);
+      }
+    },
+    { check: (changed) => object.sequence(changed).some(isOpenapiSource) },
+  );
 } else {
   // One-shot: regenerate, then re-synth so any newly created openapi folder becomes a
   // workspace member (a new package needs install + linking, which the watch path skips).