@dbx-tools/projen 0.9.47 → 0.9.51

package/tasks/lib/release-version.ts

@@ -1,66 +0,0 @@
-#!/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

@@ -1,278 +0,0 @@
-#!/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, Option } from "commander";
-import { publishLocalRelease } from "./local-publish.ts";
-import { assertReleaseVersion } from "./release-version.ts";
-import {
-  captureTaskCommand,
-  runTaskCommand,
-  taskCommandSucceeds,
-} from "../../src/_task-command.ts";
-import {
-  RELEASE_INSTALL_MODES,
-  RELEASE_PUBLISH_TARGETS,
-  releasePublishesLocally,
-  releaseStepSelection,
-  releaseTagAnnotation,
-  type ReleaseInstallMode,
-  type ReleaseSelectionOptions,
-} from "../../src/release-options.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: ReleaseSelectionOptions & {
-    readonly root: string;
-    readonly branch: string;
-    readonly bump?: boolean;
-    readonly prefix: string;
-    readonly remote: string;
-    readonly localPublish?: boolean;
-    readonly localRegistry?: string;
-    readonly localPypi?: string;
-    readonly install?: ReleaseInstallMode;
-    readonly pythonRoot?: string;
-    readonly validationTasks?: readonly string[];
-  },
-): Promise<string> {
-  const { branch, prefix, remote, root } = options;
-  const selection = releaseStepSelection(options);
-  const install = options.install ?? "auto";
-
-  if (install === "always") runTaskCommand(root, "bun", ["install"]);
-
-  prepareReleaseBranch({ branch, remote, root });
-
-  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" },
-    });
-  }
-
-  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 selection.validation ? (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",
-    releaseTagAnnotation(tag, selection),
-  ]);
-  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) && releasePublishesLocally(options.publish)) {
-    await publishLocalRelease({
-      localPypi: options.pypi === false ? "false" : (options.localPypi ?? "auto"),
-      localRegistry: options.npm === false ? "false" : (options.localRegistry ?? "auto"),
-      pythonRoot: options.pythonRoot ?? "packages/py",
-      root,
-      version,
-    });
-  }
-
-  return tag;
-}
-
-/** Build the release task's native parser without executing git or registry operations. */
-export function createReleaseCommand(): Command {
-  return new Command()
-    .name("release")
-    .description("Prepare an annotated release and select its build and publication steps")
-    .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")
-    .addOption(
-      new Option("--publish <target>", "publication scope")
-        .choices([...RELEASE_PUBLISH_TARGETS])
-        .default("auto"),
-    )
-    .addOption(
-      new Option("--install <mode>", "local workspace dependency installation")
-        .choices([...RELEASE_INSTALL_MODES])
-        .default("auto"),
-    )
-    .option("--no-npm", "skip npm build and publication, including local npm publication")
-    .option("--no-pypi", "skip Python build and publication, including local Python publication")
-    .option("--docs", "build and deploy docs for a selected scope")
-    .option("--no-docs", "skip documentation build and deployment")
-    .option(
-      "--no-validation",
-      "skip optional release validation tasks; version/source checks remain mandatory",
-    )
-    .option("--no-local-publish", "skip publishing to configured local registries")
-    .option("--local-registry <auto|false|url>", "local npm registry selection", "auto")
-    .option("--local-pypi <auto|false|url>", "local devpi registry selection", "auto")
-    .action(
-      async (
-        options: ReleaseSelectionOptions & {
-          root?: string;
-          branch: string;
-          bump: boolean;
-          prefix: string;
-          remote: string;
-          pythonRoot: string;
-          localPublish: boolean;
-          localRegistry: string;
-          localPypi: string;
-          install: ReleaseInstallMode;
-          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,
-          localRegistry: options.localRegistry,
-          localPypi: options.localPypi,
-          install: options.install,
-          publish: options.publish,
-          npm: options.npm,
-          pypi: options.pypi,
-          docs: options.docs,
-          validation: options.validation,
-          validationTasks: options.validate,
-        });
-      },
-    );
-}
-
-/** Execute the native release task parser. */
-export async function main(): Promise<void> {
-  await createReleaseCommand().parseAsync();
-}