@dbx-tools/projen 0.9.161 → 0.9.165

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.161";
+export const PACKAGE_VERSION = "0.9.165";
 export * as appkitWorkspace from "./src/appkit-workspace.ts";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
@@ -85,7 +85,7 @@ export { PYTHON_NODE_RUNTIME_DISTRIBUTION, PYTHON_NODE_RUNTIME_MODULE, PYTHON_NO
 export type { PythonNodeRuntimeOptions } from "./src/python-node-runtime.ts";
 export { pythonDistributionPaths, publishPythonProjects, buildPythonProjects } from "./src/python-packaging.ts";
 export { pythonProjectInfo, preparePythonProjectForPublication } from "./src/python-release.ts";
-export { RELEASE_VERSION, RELEASE_WORKFLOW_FILE, PUBLIC_NPM_REGISTRY_URL, PUBLIC_PYPI_REGISTRY_URL, PUBLICATION_WAIT_TIMEOUT_SECONDS, PUBLICATION_WAIT_INTERVAL_SECONDS } from "./src/release-context.ts";
+export { RELEASE_VERSION, RELEASE_WORKFLOW_FILE, RELEASE_INSTALL_ENV, PUBLIC_NPM_REGISTRY_URL, PUBLIC_PYPI_REGISTRY_URL, PUBLICATION_WAIT_TIMEOUT_SECONDS, PUBLICATION_WAIT_INTERVAL_SECONDS, PUBLICATION_REQUEST_TIMEOUT_SECONDS } from "./src/release-context.ts";
 export { RELEASE_PUBLISH_TARGETS, RELEASE_INSTALL_MODES, ReleaseStepSelectionSchema, releaseStepSelection, releaseTagAnnotation, parseReleaseTagAnnotation, releasePublishesLocally } from "./src/release-options.ts";
 export type { ReleasePublishTarget, ReleaseInstallMode, ReleaseStepSelection, ReleaseSelectionOptions } from "./src/release-options.ts";
 export { tryReleaseWorkflow, releaseTagPattern, releaseCondition, releaseBuildSteps, nodeReleaseSetupSteps, uvSetupStep, refreshReleaseDocsDependencies, refreshPublicationVerification, DBXToolsRelease } from "./src/release.ts";

package/package.json

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

package/src/npm-release.ts

@@ -12,9 +12,10 @@ import {
 import { tmpdir } from "node:os";
 import { join, relative } from "node:path";
 import { spawn, spawnSync } from "@dbx-tools/core";
-import { log, poll, toError } from "@dbx-tools/shared-core";
+import { combineAbortSignals, log, poll, toError } from "@dbx-tools/shared-core";
 import {
   PUBLIC_NPM_REGISTRY_URL,
+  PUBLICATION_REQUEST_TIMEOUT_SECONDS,
   PUBLICATION_WAIT_INTERVAL_SECONDS,
   PUBLICATION_WAIT_TIMEOUT_SECONDS,
 } from "./release-context.ts";
@@ -79,11 +80,15 @@ export async function publishedNpmRelease(
   version: string,
   registry = process.env.NPM_CONFIG_REGISTRY ?? PUBLIC_NPM_REGISTRY_URL,
   signal?: AbortSignal,
-  options: { readonly content?: boolean } = {},
+  options: { readonly content?: boolean; readonly timeoutMs?: number } = {},
 ): Promise<NpmReleaseIdentity | undefined> {
+  const requestSignal = combineAbortSignals(
+    signal,
+    AbortSignal.timeout(options.timeoutMs ?? PUBLICATION_REQUEST_TIMEOUT_SECONDS * 1_000),
+  );
   const response = await fetch(registryUrl(registry, name, version), {
     headers: { accept: "application/json" },
-    signal,
+    signal: requestSignal,
   });
   if (response.status === 404) return undefined;
   if (!response.ok) {
@@ -100,7 +105,8 @@ export async function publishedNpmRelease(
   }
   let contentDigest: string | undefined;
   if (options.content !== false && metadata.dist?.tarball) {
-    const archive = await fetch(metadata.dist.tarball, { signal });
+    const archive = await fetch(metadata.dist.tarball, { signal: requestSignal });
+    if (archive.status === 404) return undefined;
     if (!archive.ok) {
       throw new Error(`npm tarball lookup failed for ${name}@${version}: ${archive.status}`);
     }
@@ -132,24 +138,47 @@ export function isNpmStagedVersionConflict(error: unknown): boolean {
 export async function waitForMatchingNpmRelease(
   local: NpmReleaseIdentity,
   registry?: string,
-  options: { readonly intervalMs?: number; readonly timeoutMs?: number } = {},
+  options: {
+    readonly intervalMs?: number;
+    readonly requestTimeoutMs?: number;
+    readonly timeoutMs?: number;
+  } = {},
 ): Promise<void> {
   const selectedRegistry = registry ?? process.env.NPM_CONFIG_REGISTRY ?? PUBLIC_NPM_REGISTRY_URL;
+  let lastError: Error | undefined;
   try {
     for await (const _available of poll(
       async ({ signal }) => {
-        const published = await publishedNpmRelease(
-          local.name,
-          local.version,
-          selectedRegistry,
-          signal,
-          { content: false },
-        );
+        let published: NpmReleaseIdentity | undefined;
+        try {
+          published = await publishedNpmRelease(
+            local.name,
+            local.version,
+            selectedRegistry,
+            signal,
+            { content: false, timeoutMs: options.requestTimeoutMs },
+          );
+        } catch (error) {
+          lastError = toError(error);
+          return false;
+        }
         if (!published) return false;
-        return npmReleaseMatches(
-          local,
-          await publishedNpmRelease(local.name, local.version, selectedRegistry, signal),
-        );
+        let complete: NpmReleaseIdentity | undefined;
+        try {
+          complete = await publishedNpmRelease(
+            local.name,
+            local.version,
+            selectedRegistry,
+            signal,
+            { timeoutMs: options.requestTimeoutMs },
+          );
+        } catch (error) {
+          lastError = toError(error);
+          return false;
+        }
+        if (!complete) return false;
+        lastError = undefined;
+        return npmReleaseMatches(local, complete);
       },
       {
         intervalMs: options.intervalMs ?? PUBLICATION_WAIT_INTERVAL_SECONDS * 1_000,
@@ -160,10 +189,9 @@ export async function waitForMatchingNpmRelease(
       void _available;
     }
   } catch (error) {
-    throw new Error(
-      `Staged npm version ${local.name}@${local.version} did not become available`,
-      { cause: error },
-    );
+    throw new Error(`Staged npm version ${local.name}@${local.version} did not become available`, {
+      cause: lastError ?? error,
+    });
   }
 }
 
@@ -178,6 +206,7 @@ export async function publishNpmArchive(options: {
   readonly dryRun?: boolean;
   readonly env?: NodeJS.ProcessEnv;
   readonly intervalMs?: number;
+  readonly requestTimeoutMs?: number;
   readonly registry?: string;
   readonly timeoutMs?: number;
 }): Promise<NpmPublishOutcome> {
@@ -205,7 +234,9 @@ export async function publishNpmArchive(options: {
       check: false,
     },
   );
-  if (result.stderr) process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+  if (result.stderr) {
+    process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+  }
   if (result.exitCode === 0) return "published";
   const error = new Error(
     `npm publish failed (exit ${result.exitCode})${result.stderr ? `: ${result.stderr}` : ""}`,
@@ -217,6 +248,7 @@ export async function publishNpmArchive(options: {
   logger.info(`waiting for staged ${identity.name}@${identity.version}`);
   await waitForMatchingNpmRelease(identity, options.registry, {
     intervalMs: options.intervalMs,
+    requestTimeoutMs: options.requestTimeoutMs,
     timeoutMs: options.timeoutMs,
   });
   return "staged";

package/src/release-context.ts

@@ -3,6 +3,10 @@
 export const RELEASE_VERSION = "${{ needs.build-release.outputs.release_version }}";
 /** Generated GitHub Actions workflow triggered by release tags. */
 export const RELEASE_WORKFLOW_FILE = "release.yml";
+/** Environment applied to release dependency installation and synthesis. */
+export const RELEASE_INSTALL_ENV = {
+  ONNXRUNTIME_NODE_INSTALL: "skip",
+} as const;
 /** Public npm registry queried after npm publication completes. */
 export const PUBLIC_NPM_REGISTRY_URL = "https://registry.npmjs.org";
 /** Public PyPI JSON API queried after Python publication completes. */
@@ -11,3 +15,5 @@ export const PUBLIC_PYPI_REGISTRY_URL = "https://pypi.org/pypi";
 export const PUBLICATION_WAIT_TIMEOUT_SECONDS = 20 * 60;
 /** Delay between public registry probes while a release is still invisible. */
 export const PUBLICATION_WAIT_INTERVAL_SECONDS = 5;
+/** Maximum duration of one public registry request before the next poll can proceed. */
+export const PUBLICATION_REQUEST_TIMEOUT_SECONDS = 10;

package/src/release.ts

@@ -19,6 +19,7 @@ import { projectReleaseBranch, taskCommand, type DBXToolsJavaScriptProject } fro
 import {
   PUBLIC_NPM_REGISTRY_URL,
   PUBLICATION_WAIT_TIMEOUT_SECONDS,
+  RELEASE_INSTALL_ENV,
   RELEASE_VERSION,
   RELEASE_WORKFLOW_FILE,
 } from "./release-context.ts";
@@ -254,6 +255,7 @@ function releaseBuildJob(
     timeoutMinutes: 60,
     env: {
       CI: "true",
+      ...RELEASE_INSTALL_ENV,
       ...(options.docs
         ? { DOCS_SITE_URL: options.docs.siteUrl, DOCS_BASE: options.docs.base ?? "/" }
         : {}),

package/tasks/release.ts

@@ -13,7 +13,7 @@ import { TaskDirectoriesOptionSchema, TaskRootOptionSchema } from "./options.ts"
 import { writeReleaseNotes } from "./release-notes.ts";
 import { assertReleaseVersion } from "./release-version.ts";
 import { captureTaskCommand, runTaskCommand, taskCommandSucceeds } from "../src/_task-command.ts";
-import { RELEASE_WORKFLOW_FILE } from "../src/release-context.ts";
+import { RELEASE_INSTALL_ENV, RELEASE_WORKFLOW_FILE } from "../src/release-context.ts";
 import {
   RELEASE_INSTALL_MODES,
   RELEASE_PUBLISH_TARGETS,
@@ -504,7 +504,11 @@ export async function runRelease(
     throw new Error("--no-release-notes cannot be combined with supplied release notes");
   }
 
-  if (install === "always") runTaskCommand(root, "bun", ["install"]);
+  if (install === "always") {
+    runTaskCommand(root, "bun", ["install"], {
+      env: { ...process.env, ...RELEASE_INSTALL_ENV },
+    });
+  }
   if (selection.validation && hasPackageScript(root, "eslint:fix")) {
     runTaskCommand(root, "bun", ["run", "eslint:fix"]);
   }
@@ -514,7 +518,11 @@ export async function runRelease(
   runTaskCommand(root, "git", ["fetch", remote, branch, "--tags"]);
   if (options.bump ?? true) {
     runTaskCommand(root, "bun", ["run", "bump"], {
-      env: { ...process.env, DBX_TOOLS_RELEASE_INSTALL: install === "auto" ? "auto" : "never" },
+      env: {
+        ...process.env,
+        ...RELEASE_INSTALL_ENV,
+        DBX_TOOLS_RELEASE_INSTALL: install === "auto" ? "auto" : "never",
+      },
     });
   }
 

package/tasks/verify-publications.ts

@@ -14,12 +14,14 @@ import {
 import {
   PUBLIC_NPM_REGISTRY_URL,
   PUBLIC_PYPI_REGISTRY_URL,
+  PUBLICATION_REQUEST_TIMEOUT_SECONDS,
   PUBLICATION_WAIT_INTERVAL_SECONDS,
   PUBLICATION_WAIT_TIMEOUT_SECONDS,
 } from "../src/release-context.ts";
 
 const DEFAULT_CONCURRENCY = 8;
 const DEFAULT_INTERVAL_SECONDS = PUBLICATION_WAIT_INTERVAL_SECONDS;
+const DEFAULT_REQUEST_TIMEOUT_SECONDS = PUBLICATION_REQUEST_TIMEOUT_SECONDS;
 const DEFAULT_TIMEOUT_SECONDS = PUBLICATION_WAIT_TIMEOUT_SECONDS;
 const logger = log.logger("projen:verify-publications");
 
@@ -60,9 +62,16 @@ export interface PublicationProbe {
 export interface PublicationWaitOptions {
   readonly concurrency?: number;
   readonly intervalMs?: number;
+  readonly requestTimeoutMs?: number;
   readonly timeoutMs?: number;
 }
 
+/** Human-readable state for one sorted set of unresolved publications. */
+export function publicationWaitMessage(probes: readonly PublicationProbe[]): string {
+  const labels = probes.map(({ label }) => label).sort((left, right) => left.localeCompare(right));
+  return `waiting for ${labels.length} public publication${labels.length === 1 ? "" : "s"} - ${labels.join(", ")}`;
+}
+
 /** Poll every unresolved publication concurrently and stop after one shared timeout. */
 export async function waitForPublications(
   probes: readonly PublicationProbe[],
@@ -70,9 +79,10 @@ export async function waitForPublications(
 ): Promise<void> {
   if (probes.length === 0) throw new Error("No public publications were provided");
   const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_SECONDS * 1_000;
   const errors = new Map<string, Error>();
-  let pending = [...probes];
-  let previousCount: number | undefined;
+  let pending = [...probes].sort((left, right) => left.label.localeCompare(right.label));
+  let previousPending = "";
   try {
     for await (const unavailable of poll<PublicationProbe[]>(
       async ({ signal }) => {
@@ -80,7 +90,9 @@ export async function waitForPublications(
           pending,
           async (probe) => {
             try {
-              const available = await probe.available(signal);
+              const available = await probe.available(
+                AbortSignal.any([signal, AbortSignal.timeout(requestTimeoutMs)]),
+              );
               if (available) errors.delete(probe.label);
               return { available, probe };
             } catch (error) {
@@ -90,7 +102,10 @@ export async function waitForPublications(
           },
           { concurrency },
         );
-        return results.filter(({ available }) => !available).map(({ probe }) => probe);
+        return results
+          .filter(({ available }) => !available)
+          .map(({ probe }) => probe)
+          .sort((left, right) => left.label.localeCompare(right.label));
       },
       {
         intervalMs: options.intervalMs ?? DEFAULT_INTERVAL_SECONDS * 1_000,
@@ -99,12 +114,11 @@ export async function waitForPublications(
       },
     )) {
       pending = unavailable;
-      if (pending.length > 0 && pending.length !== previousCount) {
-        logger.info(
-          `waiting for ${pending.length} public publication${pending.length === 1 ? "" : "s"}`,
-        );
+      const pendingKey = pending.map(({ label }) => label).join("\0");
+      if (pending.length > 0 && pendingKey !== previousPending) {
+        logger.info(publicationWaitMessage(pending));
       }
-      previousCount = pending.length;
+      previousPending = pendingKey;
     }
   } catch (error) {
     if (pending.length === 0) throw error;
@@ -243,6 +257,11 @@ export const VerifyPublicationsOptionsSchema = z
       .positive()
       .default(DEFAULT_TIMEOUT_SECONDS)
       .describe("Maximum time to wait for the complete publication batch"),
+    requestTimeoutSeconds: z.coerce
+      .number()
+      .positive()
+      .default(DEFAULT_REQUEST_TIMEOUT_SECONDS)
+      .describe("Maximum duration of one public registry request"),
   })
   .refine((options) => options.npmDirectory || options.pypiDirectory, {
     message: "At least one publication directory is required",
@@ -271,6 +290,7 @@ export async function main(args: readonly string[] = process.argv.slice(2)): Pro
   await waitForPublications(probes, {
     concurrency: options.concurrency,
     intervalMs: options.intervalSeconds * 1_000,
+    requestTimeoutMs: options.requestTimeoutSeconds * 1_000,
     timeoutMs: options.timeoutSeconds * 1_000,
   });
 }