@dbx-tools/projen 0.9.32 → 0.9.37

package/tasks/release-version.ts

@@ -1,65 +1,6 @@
 #!/usr/bin/env -S bun
-/** Validate one stable release version against the canonical workspace policy. */
-import { resolve } from "node:path";
-import { parseArgs } from "node:util";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { captureGitTaskCommand } from "../src/_task-command.ts";
-import { compareSemver, parseSemver, type Semver } from "../src/workspace-version.ts";
+import { main } from "./lib/release-version.ts";
 
-function publishedVersion(root: string, prefixes: readonly string[]): string | undefined {
-  let best: Semver | undefined;
-  for (const prefix of prefixes) {
-    const tags = captureGitTaskCommand(root, [
-      "-c",
-      "versionsort.suffix=-",
-      "tag",
-      "--sort=-version:refname",
-      "--list",
-      `${prefix}*`,
-    ]);
-    for (const tag of tags.split("\n")) {
-      if (!tag.startsWith(prefix)) continue;
-      const version = parseSemver(tag.slice(prefix.length));
-      if (version && (!best || compareSemver(version, best) > 0)) best = version;
-    }
-  }
-  return best?.join(".");
-}
+export * from "./lib/release-version.ts";
 
-export function assertReleaseVersion(
-  version: string,
-  options: { root?: string; prefixes?: readonly string[]; assertNext?: boolean } = {},
-): void {
-  const parsed = parseSemver(version);
-  if (!parsed) {
-    throw new Error(
-      `release version must be an exact stable x.y.z, got ${JSON.stringify(version)}`,
-    );
-  }
-  if (!options.assertNext) return;
-  const root = resolve(options.root ?? projectUtils.root() ?? process.cwd());
-  const prefixes = options.prefixes?.length ? options.prefixes : ["v"];
-  const current = publishedVersion(root, prefixes);
-  const currentParsed = current ? parseSemver(current) : undefined;
-  if (currentParsed && compareSemver(parsed, currentParsed) <= 0) {
-    throw new Error(`release version ${version} must be greater than published ${current}`);
-  }
-}
-
-if (import.meta.main) {
-  const { values } = parseArgs({
-    options: {
-      version: { type: "string" },
-      root: { type: "string" },
-      prefix: { type: "string", multiple: true },
-      "assert-next": { type: "boolean", default: false },
-    },
-    strict: true,
-  });
-  if (!values.version) throw new Error("--version is required");
-  assertReleaseVersion(values.version, {
-    ...(values.root ? { root: values.root } : {}),
-    ...(values.prefix ? { prefixes: values.prefix } : {}),
-    assertNext: values["assert-next"],
-  });
-}
+if (import.meta.main) main();

package/tasks/release.ts

@@ -1,124 +1,6 @@
 #!/usr/bin/env -S bun
-/** Run the configured release transaction. */
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { log } from "@dbx-tools/shared-core";
-import { Command } from "commander";
-import {
-  captureGitTaskCommand,
-  gitTaskCommandSucceeds,
-  runGitTaskCommand,
-  runTaskCommand,
-} from "../src/_task-command.ts";
-import { assertReleaseVersion } from "./release-version.ts";
-import { publishLocalRelease } from "./local-publish.ts";
-import { readWorkspaceVersion } from "../src/workspace-version.ts";
+import { main } from "./lib/release.ts";
 
-const logger = log.logger("projen:release");
+export { main, runRelease } from "./lib/release.ts";
 
-export async function runRelease(options: {
-  readonly root: string;
-  readonly branch: string;
-  readonly bump?: boolean;
-  readonly prefix: string;
-  readonly remote: string;
-  readonly localPublish?: boolean;
-  readonly pythonRoot?: string;
-}): Promise<string> {
-  const { branch, prefix, remote, root } = options;
-
-  // Release runs from any branch: whatever is checked out is fast-forwarded onto
-  // `branch`. The working tree is committed into the release commit unless it is
-  // already clean - the clean tree is a convenience, not a precondition.
-  if (options.bump ?? true) {
-    runTaskCommand(root, "bun", ["run", "bump"]);
-  }
-
-  const version = readWorkspaceVersion(root);
-  const tag = `${prefix}${version}`;
-  runGitTaskCommand(root, ["fetch", remote, branch, "--tags"]);
-  assertReleaseVersion(version, { root, prefixes: [prefix], assertNext: true });
-
-  if (gitTaskCommandSucceeds(root, ["rev-parse", "--verify", `refs/tags/${tag}`])) {
-    throw new Error(`release tag ${tag} already exists`);
-  }
-
-  runTaskCommand(root, "bun", ["run", "version:check"]);
-  const status = captureGitTaskCommand(
-    root,
-    ["status", "--porcelain=v1", "--untracked-files=all"],
-    { check: true },
-  );
-  if (status) {
-    if (gitTaskCommandSucceeds(root, ["diff", "--quiet", "HEAD", "--", "VERSION"])) {
-      throw new Error("release changes must include the local VERSION bump");
-    }
-    runGitTaskCommand(root, ["add", "--all"]);
-    runGitTaskCommand(root, ["commit", "-m", `chore(release): ${version}`]);
-  }
-
-  // Fast-forward only: HEAD must already contain the remote branch tip, otherwise
-  // the push would be a non-fast-forward (an unclean merge) and we fail instead
-  // of force-pushing. This holds regardless of which branch is checked out.
-  const remoteHead = captureGitTaskCommand(root, ["rev-parse", `${remote}/${branch}`], {
-    check: true,
-  });
-  const head = captureGitTaskCommand(root, ["rev-parse", "HEAD"], { check: true });
-  if (!gitTaskCommandSucceeds(root, ["merge-base", "--is-ancestor", remoteHead, head])) {
-    throw new Error(
-      `cannot fast-forward ${remote}/${branch} to HEAD; ${branch} has diverged (rebase before release)`,
-    );
-  }
-
-  runGitTaskCommand(root, ["push", remote, `HEAD:${branch}`]);
-  runGitTaskCommand(root, ["tag", "--annotate", tag, "--message", tag]);
-  runGitTaskCommand(root, ["push", remote, `refs/tags/${tag}`]);
-  logger.success(`released ${tag}`, { sha: head });
-
-  // Restore local deploys: when a non-standard (loopback) npm or uv registry is
-  // configured, publish the freshly tagged version to it directly. Detection and
-  // publishing are owned by local-publish.ts; this no-ops on standard registries.
-  if (options.localPublish ?? true) {
-    await publishLocalRelease({
-      localPypi: "auto",
-      localRegistry: "auto",
-      pythonRoot: options.pythonRoot ?? "packages/py",
-      root,
-      version,
-    });
-  }
-
-  return tag;
-}
-
-if (import.meta.main) {
-  await new Command()
-    .option("--root <path>", "repository root")
-    .option("--branch <name>", "release branch", "main")
-    .option("--prefix <prefix>", "release tag prefix", "v")
-    .option("--remote <name>", "git remote", "origin")
-    .option("--python-root <path>", "Python package root for local publish", "packages/py")
-    .option("--no-bump", "use an existing synchronized local version bump")
-    .option("--no-local-publish", "skip publishing to configured local registries")
-    .action(
-      async (options: {
-        root?: string;
-        branch: string;
-        bump: boolean;
-        prefix: string;
-        remote: string;
-        pythonRoot: string;
-        localPublish: boolean;
-      }) => {
-        await runRelease({
-          root: options.root ?? projectUtils.root() ?? process.cwd(),
-          branch: options.branch,
-          bump: options.bump,
-          prefix: options.prefix,
-          remote: options.remote,
-          pythonRoot: options.pythonRoot,
-          localPublish: options.localPublish,
-        });
-      },
-    )
-    .parseAsync();
-}
+if (import.meta.main) await main();

package/tasks/sync.ts

@@ -2,7 +2,7 @@
 import { fileURLToPath } from "node:url";
 import { log } from "@dbx-tools/shared-core";
 import concurrently from "concurrently";
-import { pythonNodeBindingProjects, repoRoot } from "../src/packages.ts";
+import { repoRoot } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
 
@@ -35,79 +35,80 @@ function watcher(script: string, name: string, prefixColor: string, ...args: str
   };
 }
 
-if (!process.argv.includes("--watch")) {
-  // One-shot: full synth (+install + barrels via the post-synth component). This is
-  // the scriptable path, so a failed synth stays a failed exit code.
-  logger.start("synthesizing");
-  await withWorkspaceMutationLock(repoRoot, () => runSynth({ post: true }));
-  logger.success("synced");
-} else {
-  // Watch: one initial full synth to bring the tree up to date, then focused
-  // watchers under `concurrently`. The projenrc watcher is the intelligent stand-in
-  // for stock `projen --watch` - it re-synths (+install) ONLY when `.projenrc.ts` or
-  // a configured `syncResynthPaths` entry changes, while barrels/openapi keep generated
-  // OUTPUT fresh on source edits with no full synth.
-  //
-  // VS Code auto-runs this on folder open, so from here down nothing is allowed to be
-  // fatal: errors are logged and retried, and only a stop signal ends the task.
-  logger.start("initial sync");
-  try {
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  if (!args.includes("--watch")) {
+    // One-shot: full synth (+install + barrels via the post-synth component). This is
+    // the scriptable path, so a failed synth stays a failed exit code.
+    logger.start("synthesizing");
     await withWorkspaceMutationLock(repoRoot, () => runSynth({ post: true }));
-    logger.success("synced - watching (Ctrl-C to stop)");
-  } 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:",
-      err instanceof Error ? err.message : err,
-    );
-  }
+    logger.success("synced");
+  } else {
+    // Watch: one initial full synth to bring the tree up to date, then focused
+    // watchers under `concurrently`. The projenrc watcher is the intelligent stand-in
+    // for stock `projen --watch` - it re-synths (+install) ONLY when `.projenrc.ts` or
+    // a configured `syncResynthPaths` entry changes, while barrels/openapi keep generated
+    // OUTPUT fresh on source edits with no full synth.
+    //
+    // VS Code auto-runs this on folder open, so from here down nothing is allowed to be
+    // fatal: errors are logged and retried, and only a stop signal ends the task.
+    logger.start("initial sync");
+    try {
+      await withWorkspaceMutationLock(repoRoot, () => runSynth({ post: true }));
+      logger.success("synced - watching (Ctrl-C to stop)");
+    } 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:",
+        err instanceof Error ? err.message : err,
+      );
+    }
 
-  const watchers = [
-    watcher("projenrc.ts", "projenrc", "magenta"),
-    watcher("barrels.ts", "barrels", "cyan", "--watch"),
-    watcher("openapi.ts", "openapi", "green", "--watch"),
-  ];
-  if (pythonNodeBindingProjects(repoRoot).length > 0) {
-    watchers.push(watcher("python-node-bindings-watch.ts", "node-bindings", "blue"));
-  }
-  const { result } = concurrently(watchers, {
-    prefix: "name",
-    // No `killOthersOn`: one watcher falling over is no reason to tear the other two
-    // down. `-1` is concurrently's spelling for "restart forever", so a crashed
-    // watcher comes back instead of silently leaving its outputs stale.
-    restartTries: -1,
-    restartDelay: RESTART_DELAY_MS,
-  });
+    const watchers = [
+      watcher("projenrc.ts", "projenrc", "magenta"),
+      watcher("barrels.ts", "barrels", "cyan", "--watch"),
+      watcher("openapi.ts", "openapi", "green", "--watch"),
+    ];
+    const { result } = concurrently(watchers, {
+      prefix: "name",
+      // No `killOthersOn`: one watcher falling over is no reason to tear the other two
+      // down. `-1` is concurrently's spelling for "restart forever", so a crashed
+      // watcher comes back instead of silently leaving its outputs stale.
+      restartTries: -1,
+      restartDelay: RESTART_DELAY_MS,
+    });
 
-  let stopping = false;
+    let stopping = false;
 
-  /**
-   * Wind the watchers down for good.
-   *
-   * Restarting forever means an ordinary SIGTERM would be answered by respawning every
-   * watcher, so the task has to opt out explicitly. SIGINT is the one signal concurrently
-   * neutralizes - it rewrites that exit to 0 before the restart controller sees it - so
-   * re-emitting it is how we say "stop" in a language the supervisor understands.
-   *
-   * Killing is asynchronous (concurrently shells out to `ps` to walk each process tree)
-   * and can outlive `result`. The timer keeps the process open until the kills
-   * land, which prevents orphaned watchers after SIGTERM. It also stops waiting
-   * if one of them wedges.
-   */
-  function stop(): void {
-    if (stopping) return;
-    stopping = true;
-    process.emit("SIGINT", "SIGINT");
-    setTimeout(() => process.exit(0), STOP_GRACE_MS);
-  }
+    /**
+     * Wind the watchers down for good.
+     *
+     * Restarting forever means an ordinary SIGTERM would be answered by respawning every
+     * watcher, so the task has to opt out explicitly. SIGINT is the one signal concurrently
+     * neutralizes - it rewrites that exit to 0 before the restart controller sees it - so
+     * re-emitting it is how we say "stop" in a language the supervisor understands.
+     *
+     * Killing is asynchronous (concurrently shells out to `ps` to walk each process tree)
+     * and can outlive `result`. The timer keeps the process open until the kills
+     * land, which prevents orphaned watchers after SIGTERM. It also stops waiting
+     * if one of them wedges.
+     */
+    function stop(): void {
+      if (stopping) return;
+      stopping = true;
+      process.emit("SIGINT", "SIGINT");
+      setTimeout(() => process.exit(0), STOP_GRACE_MS);
+    }
 
-  // Registered after `concurrently()` so its own signal handler - the one that actually
-  // kills the children - is already in place by the time ours can fire.
-  for (const signal of ["SIGTERM", "SIGHUP"] as const) process.on(signal, stop);
+    // Registered after `concurrently()` so its own signal handler - the one that actually
+    // kills the children - is already in place by the time ours can fire.
+    for (const signal of ["SIGTERM", "SIGHUP"] as const) process.on(signal, stop);
 
-  // With infinite restarts this settles only once a stop signal has wound the watchers
-  // down, so there is no failure left to report. When `stop()` is driving, the pending
-  // grace timer keeps us alive past this point and owns the exit.
-  await result.catch(() => {});
+    // With infinite restarts this settles only once a stop signal has wound the watchers
+    // down, so there is no failure left to report. When `stop()` is driving, the pending
+    // grace timer keeps us alive past this point and owns the exit.
+    await result.catch(() => {});
+  }
 }
+
+if (import.meta.main) await main();

package/tasks/version-check.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S bun
 /** Verify that every committed package version matches the root VERSION file. */
-import { existsSync, readFileSync } from "node:fs";
+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";
@@ -23,7 +23,7 @@ function pythonVersion(path: string): string | undefined {
   return typeof manifest.project?.version === "string" ? manifest.project.version : undefined;
 }
 
-function main(): void {
+export function main(): void {
   const root = projectUtils.root() ?? process.cwd();
   const version = readWorkspaceVersion(root);
   const mismatches: string[] = [];
@@ -34,13 +34,6 @@ function main(): void {
   check("package.json", manifestVersion(join(root, "package.json")));
   for (const pkg of recordedPackages(root)) {
     check(`${pkg.path}/package.json`, manifestVersion(join(pkg.dir, "package.json")));
-    const barrel = join(pkg.dir, "index.ts");
-    if (existsSync(barrel)) {
-      const actual = /export const PACKAGE_VERSION = "([^"]+)";/.exec(
-        readFileSync(barrel, "utf8"),
-      )?.[1];
-      check(`${pkg.path}/index.ts`, actual);
-    }
   }
 
   for (const path of find.findFiles("**/pyproject.toml", { cwd: root })) {
@@ -52,4 +45,4 @@ function main(): void {
   logger.success(`all workspace package versions match ${version}`);
 }
 
-main();
+if (import.meta.main) main();