@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/release/gate.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { ghFor, runGate, tagRelease } from "../fixtures/gate-world.ts";
+import { removePlanted } from "../fixtures/planted-repo.ts";
+import { commit, gitIn, NAME, world } from "../fixtures/release-world.ts";
+
+afterEach(removePlanted);
+
+const LIST = "databaseId,status,conclusion,event,headBranch,createdAt";
+
+describe("repo release gate passes", () => {
+  it("prints one line: the tag, version, changelog and the ci run it waited for", async () => {
+    const w = world({}, false);
+    const short = tagRelease(w, { version: "0.2.0" });
+    expect(await runGate(w, [`${NAME}@0.2.0`])).toEqual({
+      code: 0,
+      out: `repo release gate: ${NAME}@0.2.0 is ${short}, version 0.2.0, changelog ok · waiting for ci on ${short} (run 7)… · passed\n`,
+      err: "",
+    });
+  });
+
+  it("waits on the tagged commit even when the checkout is on a later one", async () => {
+    const w = world({}, false);
+    tagRelease(w, { version: "0.2.0" });
+    const sha = gitIn(w.work, "rev-parse", "HEAD");
+    commit(w, "chore: later", { "later.txt": "x\n" });
+    const calls: string[] = [];
+    expect((await runGate(w, [`${NAME}@0.2.0`], ghFor("main", {}, calls))).code).toBe(0);
+    expect(calls).toContain(`run list --commit ${sha} --workflow ci.yml --json ${LIST}`);
+  });
+});
+
+describe("repo release gate on a ci that did not pass", () => {
+  const setup = () => {
+    const w = world({}, false);
+    return { w, short: tagRelease(w, { version: "0.2.0" }) };
+  };
+
+  it("prints the failed jobs and tells you to release the next version", async () => {
+    const { w, short } = setup();
+    const got = await runGate(w, [`${NAME}@0.2.0`], ghFor("main", { conclusion: "failure" }));
+    expect(got.code).toBe(1);
+    expect(got.out).toContain("failed: test; logs below\nboom\n");
+    expect(got.err).toBe(
+      `repo release gate: CI failed on ${short}; a tag is never moved, so fix it in a new commit and release the next version\n`,
+    );
+  });
+
+  it("says a newer push cancelled it", async () => {
+    const { w, short } = setup();
+    const got = await runGate(w, [`${NAME}@0.2.0`], ghFor("main", { conclusion: "cancelled" }));
+    expect(got.err).toBe(
+      `repo release gate: a newer push cancelled CI on ${short}; rerun ci on it, then rerun this job\n`,
+    );
+  });
+
+  it("says there was no run", async () => {
+    const { w, short } = setup();
+    const got = await runGate(w, [`${NAME}@0.2.0`], ghFor("main", { run: false }));
+    expect(got.err).toBe(
+      `repo release gate: no CI result for ${short} (no ci run after 120s); rerun this job once ci has run\n`,
+    );
+  });
+});

package/cli/release/gate.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { readJson, waitFor, type Target } from "../scripts/ci-wait.ts";
+import { read, type Tools } from "./git.ts";
+import { parseManifest } from "./manifest.ts";
+import { sectionFor } from "./changelog-parse.ts";
+import { refuse } from "./refuse.ts";
+import type { ReleaseIo } from "./release.ts";
+import {
+  CHANGELOG_FILE,
+  GH_DEFAULT_BRANCH,
+  GIT_ON_BRANCH,
+  GIT_SHOW,
+  GIT_TAG_REF,
+  MANIFEST_FILE,
+  SHA_SHOWN,
+} from "./release.constants.ts";
+import {
+  GATE_PREFIX,
+  WAIT_USAGE,
+  gateCiLines,
+  gateOk,
+  nameDiffers,
+  noDefaultBranch,
+  noManifestAt,
+  noSection,
+  notOnBranch,
+  tagMissing,
+  versionDiffers,
+} from "./release-messages.constants.ts";
+import { splitSpec, type Spec } from "./wait.ts";
+
+const branchSchema = () => z.object({ defaultBranchRef: z.object({ name: z.string() }) });
+
+/** The commit the tag names when its package.json, changelog and branch agree with the tag; else the refusal line. */
+function check(t: Tools, tag: string, parts: Spec): string | Target {
+  const sha = read(t, GIT_TAG_REF(tag));
+  if (sha === "") return tagMissing(tag);
+  const short = sha.slice(0, SHA_SHOWN);
+  const manifest = parseManifest(read(t, GIT_SHOW(sha, MANIFEST_FILE)));
+  if (manifest === null) return noManifestAt(short);
+  if (manifest.name !== parts.name) return nameDiffers(parts.name, short, manifest.name);
+  if (manifest.version !== parts.version) return versionDiffers(parts.version, short, manifest.version);
+  if (sectionFor(read(t, GIT_SHOW(sha, CHANGELOG_FILE)), parts.version) === null)
+    return noSection(short, parts.version);
+  const got = t.gh([...GH_DEFAULT_BRANCH], t.cwd);
+  const named = readJson(got, branchSchema());
+  if (named === null) return noDefaultBranch(got.stderr.trim());
+  const branch = named.defaultBranchRef.name;
+  return t.git(GIT_ON_BRANCH(sha, branch), t.cwd).code === 0 ? { sha, branch } : notOnBranch(short, branch);
+}
+
+/** `repo release gate <name>@<version>`: the tag matches the package and changelog on the default branch, and CI passed. */
+export async function gate(argv: readonly string[], io: ReleaseIo): Promise<number> {
+  const tag = argv[0] ?? "";
+  const parts = argv.length === 1 ? splitSpec(tag) : null;
+  if (parts === null) return refuse(io, GATE_PREFIX, WAIT_USAGE);
+  const tools: Tools = { cwd: io.cwd, git: io.git, gh: io.gh };
+  const target = check(tools, tag, parts);
+  if (typeof target === "string") return refuse(io, GATE_PREFIX, target);
+  const short = target.sha.slice(0, SHA_SHOWN);
+  const printed: string[] = [];
+  const outcome = await waitFor({ ...io, stdout: (text) => printed.push(text.trim()), target });
+  if (outcome.kind !== "passed") {
+    io.stdout(`${printed.join("\n")}\n`);
+    const detail = outcome.kind === "error" ? outcome.detail : "";
+    return refuse(io, GATE_PREFIX, gateCiLines[outcome.kind](short, detail));
+  }
+  io.stdout(`${GATE_PREFIX}${[gateOk(tag, short, parts.version), ...printed].join(" · ")}\n`);
+  return 0;
+}

package/cli/release/git.ts

@@ -0,0 +1,66 @@
+import type { Runner } from "../scripts/ci-wait.ts";
+import type { Commit } from "./version.ts";
+import {
+  BARE_TAG_OF,
+  COMMIT_END,
+  COMMIT_SEPARATOR,
+  GIT_AHEAD_BEHIND,
+  GIT_COMMITS,
+  GIT_ORIGIN_HEAD,
+  GIT_RELEASE_LOG,
+  GIT_TAG_REF,
+  MAIN_FALLBACK,
+  ORIGIN_HEAD_PREFIX,
+  TAG_OF,
+} from "./release.constants.ts";
+import { gitFailed } from "./release-messages.constants.ts";
+
+/** The checkout `repo release` works in, and the git and gh it runs there. */
+export type Tools = { cwd: string; git: Runner; gh: Runner };
+
+/** What git prints for `args`, trimmed; empty when it fails. */
+export const read = (t: Tools, args: readonly string[]): string => t.git([...args], t.cwd).stdout.trim();
+
+/** Runs git with `args` and throws a line naming the failure; the flow's boundary prints it. */
+export function must(t: Tools, args: readonly string[]): string {
+  const got = t.git([...args], t.cwd);
+  if (got.code !== 0)
+    throw new Error(gitFailed(args[0] /* every git call here names a subcommand */ as string, got.stderr.trim()));
+  return got.stdout.trim();
+}
+
+/** The default branch: what origin's HEAD names, else main. */
+export function defaultBranch(t: Tools): string {
+  const ref = read(t, GIT_ORIGIN_HEAD);
+  return ref.startsWith(ORIGIN_HEAD_PREFIX) ? ref.slice(ORIGIN_HEAD_PREFIX.length) : MAIN_FALLBACK;
+}
+
+/** How many commits `branch` is ahead of and behind origin's. */
+export function divergence(t: Tools, branch: string): { ahead: number; behind: number } {
+  const [ahead, behind] = read(t, GIT_AHEAD_BEHIND(branch)).split(/\s+/);
+  return { ahead: Number(ahead), behind: Number(behind) };
+}
+
+/** The tag that marks `version` as released, `<name>@<version>` or `v<version>`; null when neither exists. */
+export function releaseTag(t: Tools, name: string, version: string): string | null {
+  return [TAG_OF(name, version), BARE_TAG_OF(version)].find((tag) => read(t, GIT_TAG_REF(tag)) !== "") ?? null;
+}
+
+/** The sha of the commit in HEAD's history whose subject is exactly `subject`; null when there is none. */
+export function commitWithSubject(t: Tools, subject: string): string | null {
+  const lines = read(t, GIT_RELEASE_LOG(subject)).split("\n");
+  const hit = lines.map((line) => line.split("\t")).find(([, found]) => found === subject);
+  return hit?.[0] ?? null;
+}
+
+/** The commits after `since` (every commit when null), newest first. */
+export function commitsSince(t: Tools, since: string | null): Commit[] {
+  return read(t, GIT_COMMITS(since))
+    .split(COMMIT_END)
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== "")
+    .map((entry) => {
+      const at = entry.indexOf(COMMIT_SEPARATOR);
+      return { subject: entry.slice(0, at), body: entry.slice(at + 1) };
+    });
+}

package/cli/release/github.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { removePlanted, tempDir, write } from "../fixtures/planted-repo.ts";
+import type { Runner } from "../scripts/ci-wait.ts";
+import { releaseGithub } from "./github.ts";
+
+afterEach(removePlanted);
+
+const CHANGELOG = `# Changelog
+
+## [Unreleased]
+
+## [0.2.0-rc.1] - 2026-11-09
+
+### Added
+
+- a thing
+
+### Fixed
+
+- another
+
+## [0.1.0] - 2026-10-01
+
+### Added
+
+- first
+`;
+const TAG = "@acme/app@0.1.0";
+const NOTES = "### Added\n\n- first";
+const FORMAT = "repo release github: name the tag as <name>@<version>, e.g. @workerstack/repo@1.0.0\n";
+
+/** A gh whose `release view` finds the release when `exists` is true, or once `create` ran when it is "after-create". */
+function fakeGh(exists: boolean | "after-create", created = 0): { gh: Runner; calls: string[] } {
+  const calls: string[] = [];
+  let made = false;
+  const gh: Runner = (args) => {
+    calls.push(args.join(" "));
+    if (args[1] === "view") {
+      const found = exists === true || (exists === "after-create" && made);
+      return { code: found ? 0 : 1, stdout: "", stderr: "" };
+    }
+    made = true;
+    return { code: created, stdout: "", stderr: created === 0 ? "" : "denied" };
+  };
+  return { gh, calls };
+}
+
+async function github(argv: string[], gh: Runner, changelog: string | null = CHANGELOG) {
+  const dir = tempDir();
+  if (changelog !== null) write(dir, { "CHANGELOG.md": changelog });
+  const out: string[] = [];
+  const err: string[] = [];
+  const code = await releaseGithub(argv, { cwd: dir, stdout: (s) => out.push(s), stderr: (s) => err.push(s), gh });
+  return { code, out: out.join(""), err: err.join("") };
+}
+
+describe("repo release github", () => {
+  it("creates the release from the changelog section of the version", async () => {
+    const { gh, calls } = fakeGh(false);
+    expect(await github([TAG], gh)).toEqual({
+      code: 0,
+      out: `repo release github: created release ${TAG} from CHANGELOG.md\n`,
+      err: "",
+    });
+    expect(calls).toEqual([
+      `release view ${TAG}`,
+      `release create ${TAG} --verify-tag --title ${TAG} --notes ${NOTES}`,
+    ]);
+  });
+
+  it("marks a prerelease", async () => {
+    const tag = "@acme/app@0.2.0-rc.1";
+    const { gh, calls } = fakeGh(false);
+    await github([tag], gh);
+    const notes = "### Added\n\n- a thing\n\n### Fixed\n\n- another";
+    expect(calls[1]).toBe(`release create ${tag} --verify-tag --title ${tag} --notes ${notes} --prerelease`);
+  });
+});
+
+describe("repo release github reruns", () => {
+  it("leaves a release that exists alone", async () => {
+    const { gh, calls } = fakeGh(true);
+    expect(await github([TAG], gh)).toEqual({
+      code: 0,
+      out: `repo release github: release ${TAG} already exists\n`,
+      err: "",
+    });
+    expect(calls).toEqual([`release view ${TAG}`]);
+  });
+
+  it("counts a failed create as done when the release exists by then", async () => {
+    const { gh } = fakeGh("after-create", 1);
+    expect(await github([TAG], gh)).toMatchObject({
+      code: 0,
+      out: `repo release github: release ${TAG} already exists\n`,
+    });
+  });
+});
+
+describe("repo release github refuses", () => {
+  it("a failed create with gh's reason", async () => {
+    const { gh } = fakeGh(false, 1);
+    expect(await github([TAG], gh)).toEqual({
+      code: 1,
+      out: "",
+      err: "repo release github: gh release create failed: denied\n",
+    });
+  });
+
+  it("a changelog without the version's section", async () => {
+    const { gh, calls } = fakeGh(false);
+    expect(await github(["@acme/app@9.9.9"], gh)).toEqual({
+      code: 1,
+      out: "",
+      err: "repo release github: CHANGELOG.md has no ## [9.9.9] section to make the notes from\n",
+    });
+    expect(calls).toEqual([]);
+  });
+
+  it("a missing changelog the same way", async () => {
+    expect((await github([TAG], fakeGh(false).gh, null)).code).toBe(1);
+  });
+
+  it("a missing or malformed argument with the tag format", async () => {
+    expect((await github([], fakeGh(false).gh)).err).toBe(FORMAT);
+    expect((await github(["x"], fakeGh(false).gh)).err).toBe(FORMAT);
+  });
+});

package/cli/release/github.ts

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Runner } from "../scripts/ci-wait.ts";
+import { sectionFor, trimBlank } from "./changelog-parse.ts";
+import { refuse } from "./refuse.ts";
+import { CHANGELOG_FILE, GH_RELEASE_CREATE, GH_RELEASE_VIEW } from "./release.constants.ts";
+import {
+  GITHUB_PREFIX,
+  WAIT_USAGE,
+  createFailed,
+  noNotes,
+  releaseCreated,
+  releaseExists,
+} from "./release-messages.constants.ts";
+import { splitSpec } from "./wait.ts";
+
+/** Where `repo release github` reads the changelog and prints, and the gh it works through. */
+export type GithubIo = { cwd: string; stdout: (text: string) => void; stderr: (text: string) => void; gh: Runner };
+
+/** The text of CHANGELOG.md in `cwd`; empty when it cannot be read. */
+function changelogText(cwd: string): string {
+  try {
+    return fs.readFileSync(path.join(cwd, CHANGELOG_FILE), "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/** `repo release github <name>@<version>`: creates the GitHub release of the tag from its changelog section, once. */
+export function releaseGithub(argv: readonly string[], io: GithubIo): number {
+  const tag = argv[0] ?? "";
+  const parts = argv.length === 1 ? splitSpec(tag) : null;
+  if (parts === null) return refuse(io, GITHUB_PREFIX, WAIT_USAGE);
+  const section = sectionFor(changelogText(io.cwd), parts.version);
+  if (section === null) return refuse(io, GITHUB_PREFIX, noNotes(parts.version));
+  const exists = (): boolean => io.gh(GH_RELEASE_VIEW(tag), io.cwd).code === 0;
+  let line = releaseExists(tag);
+  if (!exists()) {
+    const notes = trimBlank(section.body).join("\n");
+    const made = io.gh(GH_RELEASE_CREATE(tag, notes, parts.version.includes("-")), io.cwd);
+    if (made.code === 0) line = releaseCreated(tag);
+    else if (!exists()) return refuse(io, GITHUB_PREFIX, createFailed(made.stderr.trim()));
+  }
+  io.stdout(`${GITHUB_PREFIX}${line}\n`);
+  return 0;
+}

package/cli/release/list-dir.test.ts

@@ -0,0 +1,11 @@
+import { afterEach, expect, it } from "vitest";
+import { removePlanted, tempDir, write } from "../fixtures/planted-repo.ts";
+import { listDir } from "./list-dir.ts";
+
+afterEach(removePlanted);
+
+it("lists the names in a directory", () => {
+  const dir = tempDir();
+  write(dir, { "a.tgz": "x", "b.txt": "y" });
+  expect(listDir(dir).sort()).toEqual(["a.tgz", "b.txt"]);
+});

package/cli/release/list-dir.ts

@@ -0,0 +1,6 @@
+import fs from "node:fs";
+
+/** The names in a directory. */
+export function listDir(dir: string): string[] {
+  return fs.readdirSync(dir);
+}

package/cli/release/main.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { main } from "./main.ts";
+
+const writeErr = process.stderr.write;
+const writeOut = process.stdout.write;
+afterEach(() => {
+  process.stderr.write = writeErr;
+  process.stdout.write = writeOut;
+});
+
+/** Runs `main` with stdout and stderr captured. */
+async function run(argv: string[]) {
+  const out: string[] = [];
+  const err: string[] = [];
+  const into =
+    (lines: string[]) =>
+    (text: string): boolean => (lines.push(text), true);
+  process.stdout.write = into(out) /* the code writes strings only */ as typeof process.stdout.write;
+  process.stderr.write = into(err) /* the code writes strings only */ as typeof process.stderr.write;
+  const code = await main(argv);
+  return { code, out: out.join(""), err: err.join("") };
+}
+
+const TAG_FORMAT = "name the tag as <name>@<version>, e.g. @workerstack/repo@1.0.0\n";
+const USAGE = "usage: repo release [--stable | --pre <id>] | wait | gate | pack | publish | github <name>@<version>\n";
+
+describe("repo release", () => {
+  it("prints the usage for help", async () => {
+    expect(await run(["help"])).toEqual({ code: 0, out: USAGE, err: "" });
+  });
+
+  it("sends `wait` to the npm poll", async () => {
+    expect(await run(["wait"])).toEqual({ code: 1, out: "", err: `repo release wait: ${TAG_FORMAT}` });
+  });
+
+  it.each(["gate", "publish", "github"])("sends `%s` to its command", async (command) => {
+    expect(await run([command])).toEqual({ code: 1, out: "", err: `repo release ${command}: ${TAG_FORMAT}` });
+  });
+
+  it("sends `pack` to the packer", async () => {
+    const got = await run(["pack", "extra"]);
+    expect(got.err).toBe("repo release pack: takes no arguments; it packs the package in this checkout\n");
+  });
+
+  it("sends anything else to the release", async () => {
+    expect(await run(["--bogus"])).toEqual({ code: 1, out: "", err: `repo release: ${USAGE}` });
+  });
+});

package/cli/release/main.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import os from "node:os";
+import { readEnv } from "../env.ts";
+import { inheritRunner, realSleep, spawnRunner } from "../scripts/ci-wait-run.ts";
+import { gate } from "./gate.ts";
+import { releaseGithub } from "./github.ts";
+import { listDir } from "./list-dir.ts";
+import { releasePack } from "./pack.ts";
+import { releasePublish } from "./publish.ts";
+import {
+  GATE_COMMAND,
+  GITHUB_ACTIONS_ON,
+  GITHUB_COMMAND,
+  HELP_COMMAND,
+  PACK_COMMAND,
+  PUBLISH_COMMAND,
+  WAIT_COMMAND,
+} from "./release.constants.ts";
+import { releaseMain } from "./release.ts";
+import { USAGE } from "./release-messages.constants.ts";
+import { releaseWait } from "./wait.ts";
+
+const packTools = () => ({
+  bun: spawnRunner("bun"),
+  tar: spawnRunner("tar"),
+  tmp: os.tmpdir(),
+  mkdtemp: fs.mkdtempSync,
+  list: listDir,
+});
+
+/** `repo release [--stable | --pre <id>]`, or one of `help`, `wait`, `gate`, `pack`, `publish` and `github`. */
+export function main(argv: string[]): Promise<number> {
+  const io = {
+    stdout: process.stdout.write.bind(process.stdout),
+    stderr: process.stderr.write.bind(process.stderr),
+    now: Date.now,
+    sleep: realSleep,
+  };
+  const run = { ...io, cwd: process.cwd(), git: spawnRunner("git"), gh: spawnRunner("gh") };
+  const rest = argv.slice(1);
+  const ci = readEnv().GITHUB_ACTIONS === GITHUB_ACTIONS_ON;
+  if (argv[0] === HELP_COMMAND) return (io.stdout(`${USAGE}\n`), Promise.resolve(0));
+  if (argv[0] === WAIT_COMMAND) return releaseWait(rest, { ...io, fetch });
+  if (argv[0] === GATE_COMMAND) return gate(rest, run);
+  if (argv[0] === PACK_COMMAND) return Promise.resolve(releasePack(rest, { ...run, ...packTools() }));
+  if (argv[0] === GITHUB_COMMAND) return Promise.resolve(releaseGithub(rest, run));
+  if (argv[0] === PUBLISH_COMMAND) {
+    return releasePublish(rest, { ...run, ...packTools(), npm: inheritRunner("npm"), fetch, ci });
+  }
+  return releaseMain(argv, run);
+}

package/cli/release/manifest.test.ts

@@ -0,0 +1,24 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { removePlanted, tempDir, write } from "../fixtures/planted-repo.ts";
+import { parseManifest, readManifest } from "./manifest.ts";
+
+afterEach(removePlanted);
+
+describe("the manifest", () => {
+  it("is parsed from text, private unless it says otherwise", () => {
+    expect(parseManifest('{"name":"a","version":"1.0.0"}')).toEqual({ name: "a", version: "1.0.0", private: false });
+    expect(parseManifest('{"name":"a","version":"1.0.0","private":true}')?.private).toBe(true);
+  });
+
+  it("is null for text that is not a manifest", () => {
+    expect(parseManifest("not json")).toBeNull();
+    expect(parseManifest('{"name":"a"}')).toBeNull();
+  });
+
+  it("is read from the root's package.json, null when there is none", () => {
+    const dir = tempDir();
+    expect(readManifest(dir)).toBeNull();
+    write(dir, { "package.json": { name: "a", version: "2.0.0" } });
+    expect(readManifest(dir)).toEqual({ name: "a", version: "2.0.0", private: false });
+  });
+});

package/cli/release/manifest.ts

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { MANIFEST_FILE, VERSION_LINE } from "./release.constants.ts";
+
+/** The fields of the root package.json a release reads. */
+export type Manifest = { name: string; version: string; private: boolean };
+
+const schema = () => z.object({ name: z.string(), version: z.string(), private: z.boolean().optional() });
+
+/** The manifest in `text`; null when it is not JSON or lacks a name or version. */
+export function parseManifest(text: string): Manifest | null {
+  try {
+    const parsed = schema().safeParse(JSON.parse(text));
+    return parsed.success ? { ...parsed.data, private: parsed.data.private === true } : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The manifest at `root`; null when it is missing, not JSON or lacks a name or version. */
+export function readManifest(root: string): Manifest | null {
+  try {
+    return parseManifest(fs.readFileSync(path.join(root, MANIFEST_FILE), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Rewrites the `version` line of the manifest at `root`, and nothing else in the file. */
+export function writeVersion(root: string, version: string): void {
+  const file = path.join(root, MANIFEST_FILE);
+  fs.writeFileSync(file, fs.readFileSync(file, "utf8").replace(VERSION_LINE, `$1"${version}"`));
+}

package/cli/release/pack.test.ts

@@ -0,0 +1,107 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { removePlanted, tempDir, write } from "../fixtures/planted-repo.ts";
+import { spawnRunner } from "../scripts/ci-wait-run.ts";
+import type { Runner } from "../scripts/ci-wait.ts";
+import { releasePack } from "./pack.ts";
+
+afterEach(removePlanted);
+
+const ok = (stdout: string) => ({ code: 0, stdout, stderr: "" });
+
+/** Runs `release pack` in `cwd`; `bun` and `tar` default to the real tools. */
+type Tools = { bun?: Runner; tar?: Runner; mkdtemp?: (prefix: string) => string; list?: (dir: string) => string[] };
+
+async function pack(cwd: string, tools: Tools = {}, argv: string[] = []) {
+  const out: string[] = [];
+  const err: string[] = [];
+  const tmp = tempDir();
+  const code = await releasePack(argv, {
+    cwd,
+    stdout: (s) => out.push(s),
+    stderr: (s) => err.push(s),
+    bun: tools.bun ?? spawnRunner("bun"),
+    tar: tools.tar ?? spawnRunner("tar"),
+    tmp,
+    mkdtemp: tools.mkdtemp ?? fs.mkdtempSync,
+    list: tools.list ?? ((dir) => fs.readdirSync(dir)),
+  });
+  return { code, out: out.join(""), err: err.join(""), tmp };
+}
+
+/** Fakes bun's packer to name a tarball and tar to show `manifest` as its package.json. */
+const fakes = (manifest: unknown, stdout = ""): Tools => ({
+  bun: () => ok(stdout),
+  tar: () => ok(JSON.stringify(manifest)),
+  mkdtemp: (prefix) => `${prefix}x1`,
+  list: () => ["acme-app-0.1.0.tgz"],
+});
+
+describe("repo release pack", () => {
+  it("packs the package and prints the tarball path", async () => {
+    const dir = tempDir();
+    write(dir, { "package.json": { name: "@acme/app", version: "0.1.0" }, "index.js": "x\n" });
+    const got = await pack(dir);
+    expect(got.code).toBe(0);
+    const file = got.out.trim();
+    expect(got.err).toBe(`${file}\n`);
+    expect(path.basename(file)).toBe("acme-app-0.1.0.tgz");
+    expect(path.dirname(path.dirname(file))).toBe(got.tmp);
+    expect(fs.existsSync(file)).toBe(true);
+  });
+
+  it("takes the path from the pack directory and shows the prepack output on stderr", async () => {
+    const prepack = "$ bun run \x62uild\nrepo sync: up to date\n";
+    const got = await pack("/repo", fakes({ name: "@acme/app", version: "0.1.0" }, prepack));
+    const file = path.join(got.tmp, "repo-pack-x1", "acme-app-0.1.0.tgz");
+    expect(got).toMatchObject({ code: 0, out: `${file}\n`, err: prepack });
+  });
+});
+
+describe("repo release pack refuses", () => {
+  it.each([
+    ["dependencies", "workspace:^", "@workerstack/x"],
+    ["peerDependencies", "catalog:", "react"],
+    ["optionalDependencies", "workspace:*", "y"],
+    ["devDependencies", "catalog:default", "z"],
+  ])("refuses a packed %s entry naming %s", async (field, spec, dep) => {
+    const got = await pack("/repo", fakes({ name: "@acme/app", version: "0.1.0", [field]: { [dep]: spec } }));
+    expect(got).toMatchObject({
+      code: 1,
+      out: "",
+      err: `repo release pack: the packed package.json names ${spec} for ${dep}; pin it before releasing\n`,
+    });
+  });
+});
+
+describe("repo release pack refuses what it cannot pack", () => {
+  it("when bun cannot pack", async () => {
+    const got = await pack("/repo", { bun: () => ({ code: 1, stdout: "", stderr: "no package.json\n" }) });
+    expect(got).toMatchObject({ code: 1, out: "", err: "repo release pack: bun pm pack failed: no package.json\n" });
+  });
+
+  it.each([[[]], [["a.tgz", "b.tgz"]]])("a pack directory holding %j instead of one tarball", async (names) => {
+    const got = await pack("/repo", { ...fakes({}), list: () => [...names, "notes.txt"] });
+    expect(got.err).toMatch(
+      new RegExp(
+        `^repo release pack: bun pm pack left ${names.length} tarballs in .*repo-pack-x1; expected exactly one\\n$`,
+      ),
+    );
+  });
+
+  it("a tarball whose package.json cannot be read", async () => {
+    const got = await pack("/repo", { ...fakes({}), tar: () => ok("not json") });
+    expect(got).toMatchObject({
+      code: 1,
+      out: "",
+      err: "repo release pack: the packed tarball has no readable package.json with a name and a version\n",
+    });
+  });
+
+  it("arguments with the usage line", async () => {
+    expect((await pack("/repo", {}, ["x"])).err).toBe(
+      "repo release pack: takes no arguments; it packs the package in this checkout\n",
+    );
+  });
+});