@dbx-tools/projen 0.9.154 → 0.9.158

package/tasks/release-version.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 /** Validate one stable release version against the canonical workspace policy. */
 import { resolve } from "node:path";
-import * as projectUtils from "@dbx-tools/core/project-utils";
+import { projectUtils } from "@dbx-tools/core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
 import { TaskRootOptionSchema } from "./options.ts";

package/tasks/release.ts

@@ -2,8 +2,8 @@
 /** Run the configured release transaction. */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { errorUtils, json, log } from "@dbx-tools/shared-core";
+import { projectUtils, type ProjectGhAccount, resolveProjectGhAccount } from "@dbx-tools/core";
+import { log, toError, parse } from "@dbx-tools/shared-core";
 import type { Command } from "commander";
 import { z } from "zod";
 import { parsedTaskOptions, runTaskMain, taskCommand } from "./cli.ts";
@@ -67,7 +67,7 @@ const GithubReleaseRunViewSchema = z
 
 /** Inputs required to locate and watch one tag-triggered release workflow. */
 export interface WatchReleaseGithubActionsOptions {
-  readonly account: projectUtils.ProjectGhAccount;
+  readonly account: ProjectGhAccount;
   readonly head: string;
   readonly root: string;
   readonly tag: string;
@@ -80,7 +80,7 @@ export type ReleaseGithubActionsWatcher = (
   options: WatchReleaseGithubActionsOptions,
 ) => Promise<void>;
 
-function githubRepository(account: projectUtils.ProjectGhAccount): string {
+function githubRepository(account: ProjectGhAccount): string {
   return account.host === "github.com"
     ? account.remote.repository
     : `${account.host}/${account.remote.repository}`;
@@ -194,7 +194,7 @@ export async function watchReleaseGithubActions(
       ],
       { check: true, env: account.env, stderr: "inherit" },
     );
-    const parsed = z.array(GithubReleaseRunSchema).safeParse(json.parse(output, []));
+    const parsed = z.array(GithubReleaseRunSchema).safeParse(parse(output, []));
     if (!parsed.success) throw new Error("GitHub returned invalid release workflow metadata");
     run = parsed.data.find(
       (candidate) => candidate.headSha === head && candidate.headBranch === tag,
@@ -234,7 +234,7 @@ export async function watchReleaseGithubActions(
         ],
         { check: true, env: account.env, stderr: "inherit" },
       );
-      const parsed = GithubReleaseRunViewSchema.safeParse(json.parse(output));
+      const parsed = GithubReleaseRunViewSchema.safeParse(parse(output));
       if (!parsed.success) throw new Error("GitHub returned invalid release progress metadata");
       reportGithubProgress(parsed.data, progress);
       completed = parsed.data.status === "completed";
@@ -251,7 +251,7 @@ export async function watchReleaseGithubActions(
     }
   } catch (error) {
     logger.warn("GitHub Actions release watch stopped; the remote run was not cancelled", {
-      error: errorUtils.toError(error),
+      error: toError(error),
       runId: run.databaseId,
       url: run.url,
     });
@@ -305,7 +305,7 @@ function pushAnnotatedReleaseTag(options: {
 }): void {
   const { annotation, branch, head, remote, root, tag } = options;
   runTaskCommand(root, "git", ["tag", "--annotate", tag, "--message", annotation]);
-  const githubAccount = projectUtils.resolveProjectGhAccount(root, { remote });
+  const githubAccount = resolveProjectGhAccount(root, { remote });
   if (!githubAccount) {
     logger.warn(
       "no authenticated GitHub account can access the release repository; using git push",
@@ -382,7 +382,7 @@ function pushAnnotatedReleaseTag(options: {
   } catch (error) {
     if (remoteRefCreated) throw error;
     logger.warn("GitHub API tag creation failed; using git push", {
-      error: errorUtils.toError(error),
+      error: toError(error),
       repository: githubAccount.remote.repository,
     });
     runTaskCommand(root, "git", ["push", remote, `refs/tags/${tag}`]);
@@ -480,7 +480,7 @@ export async function runRelease(
     /** After local release actions, wait for and stream the matching GitHub Actions run. */
     readonly watchGithubActions?: boolean;
     readonly githubActionsWatcher?: ReleaseGithubActionsWatcher;
-    readonly resolveGithubAccount?: typeof projectUtils.resolveProjectGhAccount;
+    readonly resolveGithubAccount?: typeof resolveProjectGhAccount;
   },
 ): Promise<string> {
   const { branch, prefix, remote, root } = options;
@@ -606,7 +606,7 @@ export async function runRelease(
   }
 
   if (shouldWatchReleaseGithubActions(options, selection)) {
-    const account = (options.resolveGithubAccount ?? projectUtils.resolveProjectGhAccount)(root, {
+    const account = (options.resolveGithubAccount ?? resolveProjectGhAccount)(root, {
       remote,
     });
     if (account) {

package/tasks/sync.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 /** Synthesize once or supervise Projen, barrels, and registered focused watchers. */
 import { fileURLToPath } from "node:url";
-import { errorUtils, log } from "@dbx-tools/shared-core";
+import { log, toError } from "@dbx-tools/shared-core";
 import concurrently from "concurrently";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
@@ -84,7 +84,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
     } catch (err) {
       // A tree that doesn't synth is precisely when the watcher is most useful: the edit
       // that repairs it is the one the projenrc watcher is sitting there waiting for.
-      logger.error("initial sync failed - watching anyway", { error: errorUtils.toError(err) });
+      logger.error("initial sync failed - watching anyway", { error: toError(err) });
     }
 
     const watchers = [

package/tasks/test-workspace.ts

@@ -1,8 +1,8 @@
 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 { spawnSync, spawn } from "@dbx-tools/core";
+import { findFilesSync } from "@dbx-tools/path";
+import { log, sequence } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions, taskPositionals, taskRoot } from "./cli.ts";
 import { TaskRootOptionSchema } from "./options.ts";
@@ -137,7 +137,7 @@ function changedFiles(root: string, base?: string): string[] {
   const candidates = base ? [base] : ["origin/main", "main", "HEAD~1"];
   let committed: string[] = [];
   for (const candidate of candidates) {
-    const result = exec.spawnSync("git", ["diff", "--name-only", `${candidate}...HEAD`], {
+    const result = spawnSync("git", ["diff", "--name-only", `${candidate}...HEAD`], {
       cwd: root,
       stdin: "ignore",
       stdout: "capture",
@@ -148,14 +148,14 @@ function changedFiles(root: string, base?: string): string[] {
       break;
     }
   }
-  const working = exec.spawnSync("git", ["diff", "--name-only", "HEAD"], {
+  const working = spawnSync("git", ["diff", "--name-only", "HEAD"], {
     cwd: root,
     stdin: "ignore",
     stdout: "capture",
     stderr: "ignore",
     check: true,
   }).stdoutLines;
-  return [...object.sequence(committed, working).filter(Boolean).distinct()].sort();
+  return [...sequence(committed, working).filter(Boolean).distinct()].sort();
 }
 
 function selectedTests(
@@ -203,13 +203,13 @@ function runnerGroup(root: string, path: string): string {
   if (relativePath.startsWith("packages/js/shared/")) return "browser-shared";
   if (
     relativePath.startsWith("packages/js/ui/") ||
-    relativePath.startsWith("packages/example/app/")
+    relativePath.startsWith("packages/demo/client/")
   ) {
     return "react-ui";
   }
   if (relativePath.startsWith("projen/")) return "projen";
   if (relativePath.startsWith("docs/scripts/")) return "docs";
-  if (relativePath.startsWith("packages/example/")) return "examples";
+  if (relativePath.startsWith("packages/demo/")) return "demo";
   return "node";
 }
 
@@ -228,7 +228,7 @@ async function runTests(root: string, files: readonly string[]): Promise<void> {
   const started = performance.now();
   const jobs = [...groups].map(async ([name, paths]) => {
     const groupStarted = performance.now();
-    const result = await exec.spawn("bun", ["test", ...paths], {
+    const result = await spawn("bun", ["test", ...paths], {
       cwd: root,
       stdin: "ignore",
       stdout: "inherit",

package/tasks/verify-publications.ts

@@ -3,10 +3,14 @@
 import { createHash } from "node:crypto";
 import { readFileSync, readdirSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
-import { asyncUtils, errorUtils, log } from "@dbx-tools/shared-core";
+import { log, poll, mapConcurrent, toError } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
-import { npmReleaseMatches, publishedNpmRelease, readNpmArchiveIdentity } from "./publish-npm.ts";
+import {
+  npmReleaseMatches,
+  publishedNpmRelease,
+  readNpmArchiveIdentity,
+} from "../src/npm-release.ts";
 import { PUBLIC_NPM_REGISTRY_URL, PUBLIC_PYPI_REGISTRY_URL } from "../src/release-context.ts";
 
 const DEFAULT_CONCURRENCY = 8;
@@ -65,9 +69,9 @@ export async function waitForPublications(
   let pending = [...probes];
   let previousCount: number | undefined;
   try {
-    for await (const unavailable of asyncUtils.poll<PublicationProbe[]>(
+    for await (const unavailable of poll<PublicationProbe[]>(
       async ({ signal }) => {
-        const results = await asyncUtils.mapConcurrent(
+        const results = await mapConcurrent(
           pending,
           async (probe) => {
             try {
@@ -75,7 +79,7 @@ export async function waitForPublications(
               if (available) errors.delete(probe.label);
               return { available, probe };
             } catch (error) {
-              errors.set(probe.label, errorUtils.toError(error));
+              errors.set(probe.label, toError(error));
               return { available: false, probe };
             }
           },

package/tasks/version-check.ts

@@ -2,9 +2,9 @@
 /** Verify that every committed package version matches the root VERSION file. */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { find } from "@dbx-tools/path";
-import { json, log } from "@dbx-tools/shared-core";
+import { projectUtils } from "@dbx-tools/core";
+import { findFiles } from "@dbx-tools/path";
+import { log, parseRecord } from "@dbx-tools/shared-core";
 import { parse } from "smol-toml";
 import { runTaskMain } from "./cli.ts";
 import { recordedPackages } from "../src/packages.ts";
@@ -13,7 +13,7 @@ import { readWorkspaceVersion } from "../src/workspace-version.ts";
 const logger = log.logger("projen:version-check");
 
 function manifestVersion(path: string): string | undefined {
-  const manifest = json.parseRecord(readFileSync(path, "utf8"));
+  const manifest = parseRecord(readFileSync(path, "utf8"));
   return typeof manifest?.version === "string" ? manifest.version : undefined;
 }
 
@@ -37,7 +37,7 @@ export async function main(): Promise<void> {
     check(`${pkg.path}/package.json`, manifestVersion(join(pkg.dir, "package.json")));
   }
 
-  for await (const path of find.findFiles("**/pyproject.toml", { cwd: root })) {
+  for await (const path of findFiles("**/pyproject.toml", { cwd: root })) {
     check(path, pythonVersion(join(root, path)));
   }
   if (mismatches.length > 0) {