@dbx-tools/projen 0.9.32 → 0.9.36

package/tasks/{python-registry.ts → lib/python-registry.ts}

@@ -2,24 +2,25 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { net } from "@dbx-tools/shared-core";
-import { captureTaskCommand } from "../src/_task-command.ts";
+import { parse } from "smol-toml";
+import { captureTaskCommand } from "../../src/_task-command.ts";
 
 export interface LocalPythonRegistry {
   readonly indexUrl: string;
   readonly publishUrl: string;
 }
 
-/** Read the default index URL from uv's TOML configuration. */
-export function parseUvDefaultIndex(source: string): string | undefined {
-  const blocks = source.split(/(?=^\[\[index\]\]\s*$)/m);
-  for (const block of blocks) {
-    if (!/^\[\[index\]\]\s*$/m.test(block) || !/^\s*default\s*=\s*true\s*$/m.test(block)) {
-      continue;
-    }
-    const url = /^\s*url\s*=\s*["']([^"']+)["']\s*$/m.exec(block)?.[1];
-    if (url) return url;
-  }
-  return undefined;
+interface UvIndex {
+  readonly url?: unknown;
+  readonly default?: unknown;
+  readonly "publish-url"?: unknown;
+}
+
+function uvIndexes(source: string): UvIndex[] {
+  const document = parse(source) as { index?: unknown };
+  return Array.isArray(document.index)
+    ? document.index.filter((value): value is UvIndex => Boolean(value && typeof value === "object"))
+    : [];
 }
 
 /**
@@ -30,15 +31,12 @@ export function parseUvDefaultIndex(source: string): string | undefined {
  * a non-default block is discoverable here.
  */
 export function parseUvIndexes(source: string): string[] {
-  const blocks = source.split(/(?=^\[\[index\]\]\s*$)/m);
   let primary: string | undefined;
   const extras: string[] = [];
-  for (const block of blocks) {
-    if (!/^\[\[index\]\]\s*$/m.test(block)) continue;
-    const url = /^\s*url\s*=\s*["']([^"']+)["']\s*$/m.exec(block)?.[1];
-    if (!url) continue;
-    if (/^\s*default\s*=\s*true\s*$/m.test(block)) primary = url;
-    else extras.push(url);
+  for (const index of uvIndexes(source)) {
+    if (typeof index.url !== "string") continue;
+    if (index.default === true) primary = index.url;
+    else extras.push(index.url);
   }
   return primary ? [primary, ...extras] : extras;
 }
@@ -52,12 +50,10 @@ export function parseUvIndexes(source: string): string[] {
  */
 export function parseUvPublishUrls(source: string): Map<string, string> {
   const map = new Map<string, string>();
-  const blocks = source.split(/(?=^\[\[index\]\]\s*$)/m);
-  for (const block of blocks) {
-    if (!/^\[\[index\]\]\s*$/m.test(block)) continue;
-    const url = /^\s*url\s*=\s*["']([^"']+)["']\s*$/m.exec(block)?.[1];
-    const publishUrl = /^\s*publish-url\s*=\s*["']([^"']+)["']\s*$/m.exec(block)?.[1];
-    if (url && publishUrl) map.set(url, publishUrl);
+  for (const index of uvIndexes(source)) {
+    if (typeof index.url === "string" && typeof index["publish-url"] === "string") {
+      map.set(index.url, index["publish-url"]);
+    }
   }
   return map;
 }
@@ -167,11 +163,6 @@ export function activePythonIndexes(): string[] {
   return out;
 }
 
-/** The primary (first) active Python index, or `undefined` when none is set. */
-export function activePythonIndex(): string | undefined {
-  return activePythonIndexes()[0];
-}
-
 /**
  * Resolve `auto`, `false`, or an explicit devpi index/publish URL.
  *

package/tasks/{python-release.ts → lib/python-release.ts}

@@ -12,6 +12,7 @@ const directSibling = (
   dependency: string,
   sibling: { readonly directory: string; readonly name: string },
 ): boolean => {
+  if (dependency === sibling.name) return true;
   const prefix = `${sibling.name} @ git+`;
   if (!dependency.startsWith(prefix)) return false;
   const marker = "#subdirectory=";

package/tasks/lib/release-version.ts

@@ -0,0 +1,66 @@
+#!/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 { captureTaskCommand } from "../../src/_task-command.ts";
+import { compareSemver, parseSemver, type Semver } from "../../src/workspace-version.ts";
+
+function publishedVersion(root: string, prefixes: readonly string[]): string | undefined {
+  let best: Semver | undefined;
+  for (const prefix of prefixes) {
+    const tags = captureTaskCommand(root, "git", [
+      "-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 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}`);
+  }
+}
+
+export function main(args: string[] = process.argv.slice(2)): void {
+  const { values } = parseArgs({
+    args,
+    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"],
+  });
+}

package/tasks/lib/release.ts

@@ -0,0 +1,212 @@
+#!/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 { publishLocalRelease } from "./local-publish.ts";
+import { assertReleaseVersion } from "./release-version.ts";
+import {
+  captureTaskCommand,
+  runTaskCommand,
+  taskCommandSucceeds,
+} from "../../src/_task-command.ts";
+import { readWorkspaceVersion } from "../../src/workspace-version.ts";
+
+const logger = log.logger("projen:release");
+
+function gitHead(root: string, ref: string): string | undefined {
+  if (!taskCommandSucceeds(root, "git", ["rev-parse", "--verify", ref])) return undefined;
+  return captureTaskCommand(root, "git", ["rev-parse", ref], { check: true });
+}
+
+function assertAncestor(root: string, ancestor: string, descendant: string, message: string): void {
+  if (!taskCommandSucceeds(root, "git", ["merge-base", "--is-ancestor", ancestor, descendant])) {
+    throw new Error(message);
+  }
+}
+
+function prepareReleaseBranch(options: {
+  readonly branch: string;
+  readonly remote: string;
+  readonly root: string;
+}): void {
+  const { branch, remote, root } = options;
+  const sourceBranch = captureTaskCommand(root, "git", ["branch", "--show-current"], {
+    check: true,
+  });
+  if (!sourceBranch) throw new Error("release cannot run from a detached HEAD");
+
+  const status = captureTaskCommand(
+    root,
+    "git",
+    ["status", "--porcelain=v1", "--untracked-files=all"],
+    { check: true },
+  );
+  if (status) {
+    runTaskCommand(root, "git", ["add", "--all"]);
+    runTaskCommand(root, "git", ["commit", "-m", "chore: prepare release"]);
+  }
+
+  runTaskCommand(root, "git", ["fetch", "--prune", remote, "--tags"]);
+  const sourceHead = captureTaskCommand(root, "git", ["rev-parse", "HEAD"], { check: true });
+  const remoteSourceHead = gitHead(root, `refs/remotes/${remote}/${sourceBranch}`);
+  if (remoteSourceHead) {
+    assertAncestor(
+      root,
+      remoteSourceHead,
+      sourceHead,
+      `cannot fast-forward ${remote}/${sourceBranch} to ${sourceBranch}`,
+    );
+  }
+  runTaskCommand(root, "git", ["push", remote, `HEAD:${sourceBranch}`]);
+
+  if (sourceBranch === branch) return;
+
+  const remoteMain = gitHead(root, `refs/remotes/${remote}/${branch}`);
+  if (!remoteMain) throw new Error(`release branch ${remote}/${branch} does not exist`);
+  assertAncestor(
+    root,
+    remoteMain,
+    sourceHead,
+    `cannot safely merge ${sourceBranch} into ${branch}; ${branch} is not an ancestor`,
+  );
+
+  const localMain = gitHead(root, `refs/heads/${branch}`);
+  if (localMain) {
+    assertAncestor(
+      root,
+      localMain,
+      sourceHead,
+      `cannot safely fast-forward local ${branch} to ${sourceBranch}`,
+    );
+  } else {
+    runTaskCommand(root, "git", ["branch", branch, `${remote}/${branch}`]);
+  }
+  runTaskCommand(root, "git", ["switch", branch]);
+  runTaskCommand(root, "git", ["merge", "--ff-only", sourceBranch]);
+  runTaskCommand(root, "git", ["push", remote, `HEAD:${branch}`]);
+}
+
+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;
+  readonly validationTasks?: readonly string[];
+}): Promise<string> {
+  const { branch, prefix, remote, root } = options;
+
+  prepareReleaseBranch({ branch, remote, root });
+
+  runTaskCommand(root, "git", ["fetch", remote, branch, "--tags"]);
+  if (options.bump ?? true) {
+    runTaskCommand(root, "bun", ["run", "bump"]);
+  }
+
+  const version = readWorkspaceVersion(root);
+  const tag = `${prefix}${version}`;
+  assertReleaseVersion(version, { root, prefixes: [prefix], assertNext: true });
+
+  if (taskCommandSucceeds(root, "git", ["rev-parse", "--verify", `refs/tags/${tag}`])) {
+    throw new Error(`release tag ${tag} already exists`);
+  }
+
+  runTaskCommand(root, "bun", ["run", "version:check"]);
+  for (const task of options.validationTasks ?? []) {
+    runTaskCommand(root, "bun", ["run", task]);
+  }
+  const status = captureTaskCommand(
+    root,
+    "git",
+    ["status", "--porcelain=v1", "--untracked-files=all"],
+    { check: true },
+  );
+  if (status) {
+    if (!(options.bump ?? true)) {
+      throw new Error("--no-bump requires an already committed synchronized version");
+    }
+    if (taskCommandSucceeds(root, "git", ["diff", "--quiet", "HEAD", "--", "VERSION"])) {
+      throw new Error("release changes must include the local VERSION bump");
+    }
+    runTaskCommand(root, "git", ["add", "--all"]);
+    runTaskCommand(root, "git", ["commit", "-m", `chore(release): ${version}`]);
+  }
+
+  const remoteHead = captureTaskCommand(root, "git", ["rev-parse", `${remote}/${branch}`], {
+    check: true,
+  });
+  const head = captureTaskCommand(root, "git", ["rev-parse", "HEAD"], { check: true });
+  if (!taskCommandSucceeds(root, "git", ["merge-base", "--is-ancestor", remoteHead, head])) {
+    throw new Error(
+      `cannot fast-forward ${remote}/${branch} to HEAD; ${branch} has diverged (rebase before release)`,
+    );
+  }
+
+  runTaskCommand(root, "git", ["tag", "--annotate", tag, "--message", tag]);
+  try {
+    runTaskCommand(root, "git", ["push", "--atomic", remote, `HEAD:${branch}`, `refs/tags/${tag}`]);
+  } catch (error) {
+    runTaskCommand(root, "git", ["tag", "--delete", tag]);
+    throw error;
+  }
+  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;
+}
+
+export async function main(): Promise<void> {
+  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(
+      "--validate <task>",
+      "task to run before pushing",
+      (task, tasks: string[]) => [...tasks, task],
+      [],
+    )
+    .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;
+        validate: string[];
+      }) => {
+        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,
+          validationTasks: options.validate,
+        });
+      },
+    )
+    .parseAsync();
+}

package/tasks/local-publish.ts

@@ -1,120 +1,6 @@
-/** Build and publish the current workspace to configured loopback registries. */
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { log, net } from "@dbx-tools/shared-core";
-import { Command } from "commander";
-import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
-import { runTaskCommandAsync } from "../src/_task-command.ts";
+#!/usr/bin/env -S bun
+import { main } from "./lib/local-publish.ts";
 
-const logger = log.logger("projen:local-publish");
+export * from "./lib/local-publish.ts";
 
-/** Options for publishing the current workspace to local registries. */
-export interface LocalPublishOptions {
-  readonly localPypi: string;
-  readonly localRegistry: string;
-  readonly pythonRoot: string;
-  readonly root: string;
-  readonly version: string;
-}
-
-export function resolveLocalRegistry(value: string): string | undefined {
-  const trimmed = value.trim();
-  if (!trimmed || trimmed.toLowerCase() === "false") return undefined;
-  if (trimmed.toLowerCase() === "auto") {
-    const registry = projectUtils.npmRegistry();
-    return registry && net.isLoopbackHost(registry) ? registry.href : undefined;
-  }
-  return trimmed;
-}
-
-/** Outcome of a local publish: which ecosystems were deployed to a local registry. */
-export interface LocalPublishResult {
-  readonly npm: boolean;
-  readonly python: boolean;
-}
-
-/** Build and publish the current workspace directly to local registries. */
-export async function publishLocalRelease(options: LocalPublishOptions): Promise<LocalPublishResult> {
-  const root = resolve(options.root);
-  const localRegistry = resolveLocalRegistry(options.localRegistry);
-  const activeIndexes = activePythonIndexes();
-  const localPypi = resolveLocalPypi(options.localPypi, activeIndexes);
-  const publishes: Promise<unknown>[] = [];
-
-  if (
-    options.localPypi.toLowerCase() === "auto" &&
-    activeIndexes.some((index) => net.isLoopbackHost(index)) &&
-    !localPypi
-  ) {
-    logger.info(
-      `skipped local Python publish: no active index (${activeIndexes.join(", ")}) is a devpi +simple index`,
-    );
-  }
-
-  if (localRegistry) {
-    const publishNpmScript = fileURLToPath(new URL("./publish.ts", import.meta.url));
-    logger.info(`building and publishing npm workspace to ${localRegistry}`);
-    publishes.push(
-      runTaskCommandAsync(root, process.execPath, [
-        publishNpmScript,
-        options.version,
-        "--registry",
-        localRegistry,
-      ]),
-    );
-  }
-
-  if (localPypi) {
-    const publishPythonScript = fileURLToPath(new URL("./publish-python.ts", import.meta.url));
-    logger.info(`building and publishing Python workspace to ${localPypi.publishUrl}`);
-    publishes.push(
-      runTaskCommandAsync(root, process.execPath, [
-        publishPythonScript,
-        options.version,
-        "--root",
-        options.pythonRoot,
-        "--index-url",
-        localPypi.indexUrl,
-        "--publish-url",
-        localPypi.publishUrl,
-      ]),
-    );
-  }
-
-  if (publishes.length === 0) {
-    logger.info("no local registries configured; skipping local publish");
-    return { npm: false, python: false };
-  }
-
-  await Promise.all(publishes);
-  logger.success(`published local workspace ${options.version}`);
-  return { npm: Boolean(localRegistry), python: Boolean(localPypi) };
-}
-
-if (import.meta.main) {
-  await new Command()
-    .requiredOption("--version <version>", "release version")
-    .option("--root <path>", "repository root")
-    .option("--python-root <path>", "Python package root", "packages/py")
-    .option("--local-registry <url>", "local npm registry", "auto")
-    .option("--local-pypi <url>", "local devpi index", "auto")
-    .action(
-      async (options: {
-        version: string;
-        root?: string;
-        pythonRoot: string;
-        localRegistry: string;
-        localPypi: string;
-      }) => {
-        await publishLocalRelease({
-          localPypi: options.localPypi,
-          localRegistry: options.localRegistry,
-          pythonRoot: options.pythonRoot,
-          root: options.root ?? projectUtils.root() ?? process.cwd(),
-          version: options.version,
-        });
-      },
-    )
-    .parseAsync();
-}
+if (import.meta.main) await main();

package/tasks/openapi.ts

@@ -7,25 +7,29 @@ import { watchLoop } from "../src/watch.ts";
 
 const logger = log.logger("projen:openapi");
 
-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",
-    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).
-  const dirs = await generateOpenapi();
-  if (dirs.length > 0) runSynth({ post: true });
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  if (args.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",
+      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).
+    const dirs = await generateOpenapi();
+    if (dirs.length > 0) runSynth({ post: true });
+  }
 }
+
+if (import.meta.main) await main();

package/tasks/projenrc.ts

@@ -17,8 +17,6 @@ function resynthWatchPaths(): string[] {
   return paths;
 }
 
-const WATCH_PATHS = resynthWatchPaths();
-
 // Watch-only: `sync --watch` runs this under `concurrently` as the intelligent
 // re-synth trigger. It watches `.projenrc.ts` plus any `dbxToolsConfig.syncResynthPaths`
 // entries (from the root's `syncResynthPaths` option) and re-synths (+install) on edit -
@@ -26,13 +24,17 @@ const WATCH_PATHS = resynthWatchPaths();
 // makes the watch intelligent vs stock `projen --watch`, which re-synths on any tree
 // change. `{ dot: false }` keeps the default dotfile ignore group from pruning dotfile
 // targets. (A one-shot "projenrc" is just a synth, i.e. `bun run default`.)
-watchLoop(
-  "projenrc",
-  WATCH_PATHS,
-  () => {
-    logger.start("projenrc changed - re-synthesizing (+install)");
-    runSynth({ post: true });
-    logger.success("re-synth complete");
-  },
-  { dot: false },
-);
+export function main(): void {
+  watchLoop(
+    "projenrc",
+    resynthWatchPaths(),
+    () => {
+      logger.start("projenrc changed - re-synthesizing (+install)");
+      runSynth({ post: true });
+      logger.success("re-synth complete");
+    },
+    { ignoreOptions: { dot: false } },
+  );
+}
+
+if (import.meta.main) main();