@dbx-tools/projen 0.9.138 → 0.9.139

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.138";
+export const PACKAGE_VERSION = "0.9.139";
 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

@@ -30,10 +30,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/cli-args": "^0.9.138",
-    "@dbx-tools/core": "^0.9.138",
-    "@dbx-tools/path": "^0.9.138",
-    "@dbx-tools/shared-core": "^0.9.138",
+    "@dbx-tools/cli-args": "^0.9.139",
+    "@dbx-tools/core": "^0.9.139",
+    "@dbx-tools/path": "^0.9.139",
+    "@dbx-tools/shared-core": "^0.9.139",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -55,7 +55,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.138",
+  "version": "0.9.139",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/tasks/compile-workspace.ts

@@ -5,6 +5,7 @@ import { availableParallelism } from "node:os";
 import { join, resolve } from "node:path";
 import * as exec from "@dbx-tools/core/exec";
 import { errorUtils, log } from "@dbx-tools/shared-core";
+import type { TaskSpec, TasksManifest } from "projen";
 import { runTaskMain } from "./cli.ts";
 
 const logger = log.logger("projen:compile");
@@ -15,20 +16,6 @@ interface PackageManifest {
   readonly workspaces?: string[];
 }
 
-interface TaskManifest {
-  readonly tasks?: {
-    readonly "pre-compile"?: {
-      readonly steps?: Array<{ readonly exec?: string; readonly execArgs?: string[] }>;
-    };
-    readonly compile?: {
-      readonly steps?: Array<{ readonly exec?: string; readonly execArgs?: string[] }>;
-    };
-    readonly "post-compile"?: {
-      readonly steps?: Array<{ readonly exec?: string; readonly execArgs?: string[] }>;
-    };
-  };
-}
-
 export interface CompilePlan {
   readonly typescriptConfigs: string[];
   readonly customPackages: Array<{ readonly name: string; readonly directory: string }>;
@@ -38,9 +25,15 @@ function readJson<T>(path: string): T {
   return JSON.parse(readFileSync(path, "utf8")) as T;
 }
 
-function plainTypeScriptBuild(steps: unknown): boolean {
+function hasTaskOptions(task: TaskSpec | undefined): boolean {
+  return Object.keys(task ?? {}).some((key) => !["name", "description", "steps"].includes(key));
+}
+
+function plainTypeScriptBuild(task: TaskSpec | undefined): boolean {
+  if (hasTaskOptions(task)) return false;
+  const steps = task?.steps;
   if (!Array.isArray(steps) || steps.length !== 1) return false;
-  const step = steps[0] as { execArgs?: string[] };
+  const step = steps[0];
   if (!step || typeof step !== "object") return false;
   return (
     Object.keys(step).length === 1 &&
@@ -50,8 +43,8 @@ function plainTypeScriptBuild(steps: unknown): boolean {
   );
 }
 
-function hasSteps(steps: unknown): boolean {
-  return Array.isArray(steps) && steps.length > 0;
+function hasLifecycle(task: TaskSpec | undefined): boolean {
+  return hasTaskOptions(task) || (task?.steps?.length ?? 0) > 0;
 }
 
 /** Read the root's concrete workspace paths on every run, including newly added members. */
@@ -65,13 +58,13 @@ export function compilePlan(root: string): CompilePlan {
     const script = manifest.scripts?.compile;
     if (!script) continue;
     const taskPath = join(directory, ".projen", "tasks.json");
-    const tasks = existsSync(taskPath) ? readJson<TaskManifest>(taskPath).tasks : undefined;
-    const plainCompile = plainTypeScriptBuild(tasks?.compile?.steps);
+    const tasks = existsSync(taskPath) ? readJson<TasksManifest>(taskPath).tasks : undefined;
+    const plainCompile = plainTypeScriptBuild(tasks?.compile);
     if (
       script === "projen compile" &&
       plainCompile &&
-      !hasSteps(tasks?.["pre-compile"]?.steps) &&
-      !hasSteps(tasks?.["post-compile"]?.steps)
+      !hasLifecycle(tasks?.["pre-compile"]) &&
+      !hasLifecycle(tasks?.["post-compile"])
     ) {
       typescriptConfigs.push(join(directory, "tsconfig.json"));
     } else {

package/tasks/publish-npm.ts

@@ -15,13 +15,14 @@ import { tmpdir } from "node:os";
 import { join, relative, resolve } from "node:path";
 import * as exec from "@dbx-tools/core/exec";
 import * as projectUtils from "@dbx-tools/core/project-utils";
-import { log } from "@dbx-tools/shared-core";
+import { asyncUtils, log } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
-import { TaskDryRunOptionSchema } from "./options.ts";
-import { runTaskCommand } from "../src/_task-command.ts";
+import { TaskConcurrencyOptionSchema, TaskDryRunOptionSchema } from "./options.ts";
+import { runTaskCommandAsync } from "../src/_task-command.ts";
 
 const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const DEFAULT_PUBLISH_CONCURRENCY = 4;
 const logger = log.logger("projen:publish-npm");
 
 /** Registry and archive identity used to verify idempotent npm publication. */
@@ -258,7 +259,8 @@ export function readNpmArchiveIdentity(path: string): NpmReleaseIdentity {
   };
 }
 
-function orderNpmArchives(archives: readonly string[]): string[] {
+/** Group npm archives into dependency-ordered layers that can publish concurrently. */
+function npmArchiveLayers(archives: readonly string[]): string[][] {
   const byName = new Map(
     archives.map((archive) => {
       const manifest = readNpmArchiveManifest(archive);
@@ -278,7 +280,7 @@ function orderNpmArchives(archives: readonly string[]): string[] {
       ),
     ]),
   );
-  const ordered: string[] = [];
+  const layers: string[][] = [];
   while (remaining.size > 0) {
     const ready = [...remaining]
       .filter(([, dependencies]) => dependencies.size === 0)
@@ -289,15 +291,15 @@ function orderNpmArchives(archives: readonly string[]): string[] {
         `Cyclic npm release dependencies: ${[...remaining.keys()].sort().join(", ")}`,
       );
     }
+    layers.push(ready.map((name) => byName.get(name)!.archive));
     for (const name of ready) {
-      ordered.push(byName.get(name)!.archive);
       remaining.delete(name);
     }
     for (const dependencies of remaining.values()) {
       for (const name of ready) dependencies.delete(name);
     }
   }
-  return ordered;
+  return layers;
 }
 
 /** Hash paths, executable bits, symlink targets, and bytes while ignoring tar metadata. */
@@ -414,41 +416,51 @@ export function packNpmPackage(
 
 /** Publish dependency-ordered npm archives, skipping only exact registry matches. */
 export async function publishNpmArchives(options: {
+  readonly concurrency?: number;
   readonly directory: string;
   readonly dryRun?: boolean;
   readonly registry?: string;
   readonly version?: string;
 }): Promise<void> {
   const directory = resolve(options.directory);
-  const archives = orderNpmArchives(
+  const layers = npmArchiveLayers(
     readdirSync(directory)
       .filter((file) => file.endsWith(".tgz"))
       .sort()
       .map((file) => join(directory, file)),
   );
-  if (archives.length === 0) throw new Error(`No npm archives found in ${directory}`);
+  if (layers.length === 0) throw new Error(`No npm archives found in ${directory}`);
 
-  for (const archive of archives) {
-    const local = readNpmArchiveIdentity(archive);
-    if (options.version && local.version !== options.version) {
-      throw new Error(
-        `npm archive ${archive} carries ${local.version}, expected ${options.version}`,
-      );
-    }
-    if (!options.dryRun) {
-      const published = await publishedNpmRelease(local.name, local.version, options.registry);
-      if (npmReleaseMatches(local, published)) {
-        logger.info(`skip published ${local.name}@${local.version}`);
-        continue;
-      }
-    }
-    runTaskCommand(process.cwd(), "npm", [
-      "publish",
-      archive,
-      ...(local.access ? ["--access", local.access] : []),
-      ...(options.registry ? ["--registry", options.registry] : []),
-      ...(options.dryRun ? ["--dry-run"] : []),
-    ]);
+  for (const archives of layers) {
+    await asyncUtils.mapConcurrent(
+      archives,
+      async (archive) => {
+        const local = readNpmArchiveIdentity(archive);
+        if (options.version && local.version !== options.version) {
+          throw new Error(
+            `npm archive ${archive} carries ${local.version}, expected ${options.version}`,
+          );
+        }
+        if (!options.dryRun) {
+          const published = await publishedNpmRelease(local.name, local.version, options.registry);
+          if (npmReleaseMatches(local, published)) {
+            logger.info(`skip published ${local.name}@${local.version}`);
+            return;
+          }
+        }
+        await runTaskCommandAsync(process.cwd(), "npm", [
+          "publish",
+          archive,
+          ...(local.access ? ["--access", local.access] : []),
+          ...(options.registry ? ["--registry", options.registry] : []),
+          ...(options.dryRun ? ["--dry-run"] : []),
+        ]);
+      },
+      {
+        concurrency: options.concurrency ?? DEFAULT_PUBLISH_CONCURRENCY,
+        errorMode: "settle",
+      },
+    );
   }
 }
 
@@ -464,6 +476,7 @@ export const PublishNpmOptionsSchema = z.object({
     .describe("npm registry URL")
     .meta({ env: "NPM_CONFIG_REGISTRY" }),
   dryRun: TaskDryRunOptionSchema,
+  concurrency: TaskConcurrencyOptionSchema.default(DEFAULT_PUBLISH_CONCURRENCY),
 });
 
 /** Parse task options and publish validated npm release archives. */

package/tasks/test-workspace.ts

@@ -1,6 +1,7 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
 import * as exec from "@dbx-tools/core/exec";
+import { findFilesSync } from "@dbx-tools/path/find";
 import { log, object } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions, taskPositionals, taskRoot } from "./cli.ts";
@@ -90,17 +91,14 @@ function writeGraph(root: string, graph: WorkspaceGraph): void {
 }
 
 function testFiles(directory: string): string[] {
-  if (!existsSync(directory)) return [];
-  const files: string[] = [];
-  const visit = (current: string): void => {
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const path = join(current, entry.name);
-      if (entry.isDirectory()) visit(path);
-      else if (/\.(?:test|spec)\.tsx?$/.test(entry.name)) files.push(path);
-    }
-  };
-  visit(directory);
-  return files.sort();
+  return [
+    ...findFilesSync("**/*.{test,spec}.{js,jsx,ts,tsx,mjs,cjs,mts,cts}", {
+      cwd: directory,
+      absolute: true,
+      nodir: true,
+      ignoreOptions: { test: false },
+    }),
+  ].sort();
 }
 
 function integrationTest(path: string): boolean {
@@ -117,13 +115,13 @@ function packageForPath(graph: WorkspaceGraph, path: string): WorkspaceGraphPack
     .find((pkg) => normalized === pkg.path || normalized.startsWith(`${pkg.path}/`));
 }
 
-function affectedPackages(graph: WorkspaceGraph, changed: readonly string[]): Set<string> {
+function affectedPackages(graph: WorkspaceGraph, changed: readonly string[]): Set<string> | "all" {
   const byName = new Map(graph.packages.map((pkg) => [pkg.name, pkg]));
   const affected = new Set<string>();
   const pending: string[] = [];
   for (const path of changed) {
     const pkg = packageForPath(graph, path);
-    if (!pkg) return new Set(graph.packages.map((entry) => entry.name));
+    if (!pkg) return "all";
     if (!affected.has(pkg.name)) pending.push(pkg.name);
   }
   while (pending.length > 0) {
@@ -175,7 +173,7 @@ function selectedTests(
   if (mode === "integration") return all.filter(integrationTest);
   if (mode === "all") return all;
 
-  let names: Set<string>;
+  let names: Set<string> | "all";
   if (mode === "changed") {
     const changed = changedFiles(root, base);
     if (changed.length === 0) return [];
@@ -190,6 +188,7 @@ function selectedTests(
       names.add(byPath.name);
     }
   }
+  if (names === "all") return all;
   const paths = new Set(graph.packages.filter((pkg) => names.has(pkg.name)).map((pkg) => pkg.path));
   return all.filter((path) => {
     const relativePath = toPosix(relative(root, path));