tegami 1.1.3 → 1.2.1

package/dist/version-request-DvWVAYj2.js

@@ -0,0 +1,427 @@
+import { r as formatNpmDistTag } from "./semver-EKJ8yK5U.js";
+import { n as execFailure, s as isCI } from "./error-CAsrGb6e.js";
+import { t as _accessExpressionAsString } from "./_accessExpressionAsString-QhbUZzwv.js";
+import { n as _validateReport, t as _createStandardSchema } from "./_createStandardSchema-BGQyz-uA.js";
+import { o as PublishLock, r as runPreflights, s as parsePublishLock, t as initPublishPlan } from "./publish-Bt3e1RPs.js";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { x } from "tinyexec";
+import { tmpdir } from "node:os";
+//#region src/utils/version-request.ts
+const validatePublishGroupStore = (() => {
+	const _io0 = (input) => "object" === typeof input.groups && null !== input.groups && false === Array.isArray(input.groups) && _io1(input.groups);
+	const _io1 = (input) => Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return "pending" === value || "active" === value;
+	});
+	const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.groups && null !== input.groups && false === Array.isArray(input.groups) || _report(_exceptionable, {
+		path: _path + ".groups",
+		expected: "Record<string, \"pending\" | \"active\">",
+		value: input.groups
+	})) && _vo1(input.groups, _path + ".groups", _exceptionable) || _report(_exceptionable, {
+		path: _path + ".groups",
+		expected: "Record<string, \"pending\" | \"active\">",
+		value: input.groups
+	})].every((flag) => flag);
+	const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return "pending" === value || "active" === value || _report(_exceptionable, {
+			path: _path + _accessExpressionAsString(key),
+			expected: "(\"active\" | \"pending\")",
+			value
+		});
+	}).every((flag) => flag)].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+	let errors;
+	let _report;
+	return _createStandardSchema((input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = _validateReport(errors);
+			((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+				path: _path + "",
+				expected: "PublishGroupStore",
+				value: input
+			})) && _vo0(input, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "PublishGroupStore",
+				value: input
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	});
+})();
+function onVersionRequest(provider) {
+	const namespace = `${provider.name}:publish-group`;
+	/** package id -> version before applying the CLI draft */
+	const snapshots = /* @__PURE__ */ new Map();
+	function resolveConfig(graph) {
+		if (provider.options === false) return;
+		const { forceCreate = false, branch = "tegami/version-packages", base = "main", groups, ...rest } = provider.options ?? {};
+		const groupMap = /* @__PURE__ */ new Map();
+		if (groups?.length) {
+			const unlistedPackages = /* @__PURE__ */ new Set();
+			for (const pkg of graph.getPackages()) unlistedPackages.add(pkg.id);
+			for (let group of groups ?? []) {
+				if (!Array.isArray(group)) group = [group];
+				let id = publishGroupId(group);
+				if (id === "unlisted") id = "custom-unlisted";
+				groupMap.set(id, group);
+				for (const member of group) for (const pkg of graph.getByName(member)) unlistedPackages.delete(pkg.id);
+			}
+			if (unlistedPackages.size > 0) groupMap.set("unlisted", Array.from(unlistedPackages));
+		}
+		return {
+			forceCreate,
+			branch,
+			base,
+			groupMap,
+			...rest
+		};
+	}
+	/**
+	* Commit the group's lock state on top of `parent` and force-push its branch.
+	*
+	* Returns `true` and skips the push when the branch on `remote` already matches.
+	*/
+	async function syncGroupBranch(context, opts) {
+		const lock = new PublishLock(opts.baseLock);
+		while (lock.read(namespace));
+		lock.write(namespace, opts.store);
+		const commit = await createLockCommit(context, opts.parent, lock.serialize(), await opts.config.commit?.call(context, {
+			type: "update-lock",
+			store: opts.store,
+			updatedLock: lock
+		}));
+		if (opts.remote && opts.remote.get(opts.branch) === commit) return true;
+		await run(context.cwd, [
+			"push",
+			"--force",
+			"origin",
+			`${commit}:refs/heads/${opts.branch}`
+		], "Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.");
+		return false;
+	}
+	return {
+		/** snapshot package versions, hook into `initCliDraft` */
+		initCliDraft() {
+			for (const pkg of this.graph.getPackages()) snapshots.set(pkg.id, pkg.version);
+		},
+		/** commit & push version branches, then upsert their requests, hook into `applyCliDraft` */
+		async applyCliDraft(draft) {
+			const config = resolveConfig(this.graph);
+			if (!config || !provider.canCreate(this)) return;
+			if (!(config.forceCreate || isCI()) || !await hasGitChanges(this.cwd)) return;
+			const requests = [];
+			const updatedPackages = /* @__PURE__ */ new Map();
+			for (const id of draft.getPackageDrafts().keys()) {
+				const snapshot = snapshots.get(id);
+				const pkg = this.graph.get(id);
+				if (pkg?.version && snapshot && pkg.version !== snapshot) updatedPackages.set(id, pkg);
+			}
+			for (const [id, members] of config.groupMap) {
+				const packages = [];
+				for (const member of members) for (const pkg of this.graph.getByName(member)) {
+					if (!updatedPackages.delete(pkg.id)) continue;
+					packages.push(pkg);
+				}
+				if (packages.length === 0) continue;
+				requests.push({
+					branch: `${config.branch}/${id}`,
+					packages,
+					publishGroup: id
+				});
+			}
+			if (updatedPackages.size > 0) requests.push({
+				branch: config.branch,
+				packages: Array.from(updatedPackages.values())
+			});
+			if (requests.length === 0) return;
+			await createVersionCommit(this.cwd, await config.commit?.call(this, { type: "version-packages" }));
+			let baseLock;
+			let parent;
+			const tasks = [];
+			for (const { branch, packages, publishGroup } of requests) {
+				const plan = await initPublishPlan(this, { packages: publishGroup ? packages.map((pkg) => pkg.id) : void 0 });
+				if (plan) await runPreflights(this, plan);
+				const ctx = {
+					draft,
+					plan,
+					getPreviousVersion: (id) => snapshots.get(id)
+				};
+				const custom = await config.create?.call(this, ctx);
+				const title = custom?.title ?? (publishGroup ? `Release ${packages.map((pkg) => `${pkg.name} (${pkg.manager})`).join(", ")}` : "Version Packages");
+				if (publishGroup) {
+					parent ??= await resolveHead(this.cwd);
+					baseLock ??= await parsePublishLock(await readFile(this.lockPath, "utf8"));
+					const newGroups = {};
+					for (const req of requests) {
+						if (!req.publishGroup) continue;
+						newGroups[req.publishGroup] = req.publishGroup !== publishGroup ? "pending" : "active";
+					}
+					const inSync = await syncGroupBranch(this, {
+						baseLock,
+						config,
+						branch,
+						parent,
+						store: { groups: newGroups }
+					});
+					tasks.push(provider.upsert(this, {
+						title,
+						body: custom?.body ?? renderRequestBody(this, ctx),
+						head: branch,
+						base: config.base
+					}, !inSync));
+					continue;
+				}
+				await pushBranch(this.cwd, branch);
+				await provider.upsert(this, {
+					title,
+					body: custom?.body ?? renderRequestBody(this, ctx),
+					head: branch,
+					base: config.base
+				}, true);
+			}
+			await Promise.all(tasks);
+		},
+		/** restore publish groups from the lock into the plan, hook into `initPublishPlan` */
+		initPublishPlan({ lock, plan }) {
+			const config = resolveConfig(this.graph);
+			if (!config) return;
+			let data;
+			const publishGroups = /* @__PURE__ */ new Map();
+			plan.$versionRequest = { publishGroups };
+			while (data = lock.read(namespace)) {
+				const validated = validatePublishGroupStore(data);
+				if (!validated.success) continue;
+				const store = validated.data;
+				for (const [id, state] of Object.entries(store.groups)) {
+					if (!config.groupMap.has(id) || publishGroups.get(id) === "active") continue;
+					publishGroups.set(id, state);
+				}
+			}
+			if (publishGroups.size === 0) return;
+			const packages = [];
+			if (plan.options.packages) packages.push(...plan.options.packages);
+			for (const [id, state] of publishGroups) {
+				if (state === "pending") continue;
+				for (const pkg of config.groupMap.get(id)) packages.push(pkg);
+			}
+			plan.options = {
+				...plan.options,
+				packages
+			};
+		},
+		/** report `pending` while publish groups are waiting for their request */
+		resolvePlanStatus({ plan }) {
+			const publishGroups = plan.$versionRequest?.publishGroups;
+			if (!publishGroups) return;
+			for (const s of publishGroups.values()) if (s === "pending") return "pending";
+		},
+		/** re-sync the version requests of pending publish groups, hook into `beforePublishAll` */
+		async beforePublishAll({ plan }) {
+			if (plan.options.dryRun || !provider.canCreate(this)) return;
+			const config = resolveConfig(this.graph);
+			if (!config) return;
+			const publishGroups = plan.$versionRequest?.publishGroups;
+			if (!publishGroups || publishGroups.size === 0) return;
+			const pending = [];
+			for (const [id, state] of publishGroups) if (state === "pending") pending.push(id);
+			if (pending.length === 0) return;
+			const parent = await resolveHead(this.cwd);
+			const baseLock = parsePublishLock(await readFile(this.lockPath, "utf8"));
+			const remote = await resolveRemoteBranches(this.cwd, pending.map((id) => `${config.branch}/${id}`));
+			for (const id of pending) {
+				const newGroups = Object.fromEntries(publishGroups.entries());
+				newGroups[id] = "active";
+				await syncGroupBranch(this, {
+					branch: `${config.branch}/${id}`,
+					baseLock,
+					parent,
+					remote,
+					config,
+					store: { groups: newGroups }
+				});
+			}
+		}
+	};
+}
+function renderRequestBody(ctx, { draft, getPreviousVersion, plan }) {
+	const packageLines = [];
+	const changelogLines = [];
+	const publishLines = [];
+	const changesets = /* @__PURE__ */ new Map();
+	for (const [id, packageDraft] of draft.getPackageDrafts()) {
+		const pkg = ctx.graph.get(id);
+		if (!pkg) continue;
+		for (const changelog of packageDraft.changelogs ?? []) {
+			const list = changesets.get(changelog);
+			if (list) list.push(pkg);
+			else changesets.set(changelog, [pkg]);
+		}
+		const from = getPreviousVersion(id);
+		if (!from || from === pkg.version) continue;
+		packageLines.push(`| \`${pkg.name}\` | \`${from}\` | \`${pkg.version}\`${formatNpmDistTag(packageDraft.npm?.distTag)} |`);
+	}
+	for (const [entry, linkedPackages] of changesets) {
+		changelogLines.push(`### ${entry.subject ?? `\`${entry.filename}\``}`, "");
+		changelogLines.push("<details>", `<summary>Show Bumped Packages (${linkedPackages.length})</summary>`, "", ...linkedPackages.map((pkg) => `- \`${pkg.id}\``), "", "</details>", "");
+		for (const section of entry.sections) {
+			changelogLines.push(`#### ${section.title}`, "");
+			if (section.content) changelogLines.push(section.content);
+		}
+	}
+	if (plan) {
+		for (const [id, { preflight }] of plan.packages) if (preflight.shouldPublish) publishLines.push(`- ${id}`);
+	}
+	const sections = [
+		"## Summary",
+		"",
+		"All bumped packages.",
+		""
+	];
+	if (packageLines.length > 0) sections.push("| Package | From | To |", "| --- | --- | --- |", ...packageLines);
+	if (changelogLines.length > 0) sections.push("", "## Changelogs", ...changelogLines);
+	if (publishLines.length > 0) sections.push("", "## Publish", "", "The following packages will be published if merged:", ...publishLines);
+	sections.push("");
+	return sections.join("\n");
+}
+/**
+* Commit a lock file change on top of `parent` via a detached index, without touching the
+* working tree. Commit dates are pinned to the parent, so unchanged content always produces
+* the exact same commit.
+*/
+async function createLockCommit(context, parent, content, commit = {}) {
+	const { cwd } = context;
+	const dir = await mkdtemp(join(tmpdir(), "tegami-"));
+	try {
+		const blobFile = join(dir, "lock");
+		await writeFile(blobFile, content);
+		const blob = await run(cwd, [
+			"hash-object",
+			"-w",
+			blobFile
+		], "Failed to store the lock file update.");
+		const path = relative(cwd, context.lockPath).replaceAll("\\", "/");
+		const env = {
+			...process.env,
+			GIT_INDEX_FILE: join(dir, "index")
+		};
+		await run(cwd, ["read-tree", parent.commit], "Failed to read the current git tree.", env);
+		await run(cwd, [
+			"update-index",
+			"--add",
+			"--cacheinfo",
+			`100644,${blob},${path}`
+		], "Failed to update the lock file entry.", env);
+		const args = [
+			"commit-tree",
+			await run(cwd, ["write-tree"], "Failed to write the updated git tree.", env),
+			"-p",
+			parent.commit,
+			"-m",
+			commit.title ?? "Update lock file"
+		];
+		if (commit.body) args.push("-m", commit.body);
+		return await run(cwd, args, "Failed to commit the lock file update.", {
+			...env,
+			GIT_AUTHOR_DATE: parent.date,
+			GIT_COMMITTER_DATE: parent.date
+		});
+	} finally {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** the checked out commit and its committer date */
+async function resolveHead(cwd) {
+	const [commit = "", date = ""] = (await run(cwd, [
+		"show",
+		"-s",
+		"--format=%H%n%cI"
+	], "Failed to resolve the current commit.")).split("\n");
+	return {
+		commit,
+		date
+	};
+}
+/** branch -> commit on origin, `undefined` when the remote cannot be queried */
+async function resolveRemoteBranches(cwd, branches) {
+	const result = await x("git", [
+		"ls-remote",
+		"origin",
+		...branches.map((branch) => `refs/heads/${branch}`)
+	], { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) return;
+	const out = /* @__PURE__ */ new Map();
+	for (const line of result.stdout.split("\n")) {
+		const [commit, name] = line.split("	");
+		const ref = name?.trim();
+		if (commit && ref?.startsWith("refs/heads/")) out.set(ref.slice(11), commit.trim());
+	}
+	return out;
+}
+async function hasGitChanges(cwd) {
+	return (await run(cwd, ["status", "--porcelain"], "Failed to check git status.")).length > 0;
+}
+/** commit the working tree changes onto a detached HEAD */
+async function createVersionCommit(cwd, { title = "Version Packages", body } = {}) {
+	await run(cwd, ["checkout", "--detach"], "Failed to detach HEAD for version branches.");
+	await run(cwd, ["add", "-A"], "Failed to stage version changes.");
+	const args = [
+		"commit",
+		"-m",
+		title
+	];
+	if (body) args.push("-m", body);
+	await run(cwd, args, "Failed to commit version changes.");
+}
+async function pushBranch(cwd, branch) {
+	await run(cwd, [
+		"checkout",
+		"-B",
+		branch
+	], "Failed to create the version branch.");
+	await run(cwd, [
+		"push",
+		"--force",
+		"-u",
+		"origin",
+		branch
+	], "Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.");
+}
+async function run(cwd, args, message, env) {
+	const result = await x("git", args, { nodeOptions: {
+		cwd,
+		env
+	} });
+	if (result.exitCode !== 0) throw execFailure(message, result);
+	return result.stdout.trim();
+}
+function publishGroupId(members) {
+	const slugs = [];
+	for (const name of members.toSorted()) {
+		const v = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+		if (v.length > 0) slugs.push(v);
+	}
+	if (slugs.length === 0) slugs.push("group");
+	return slugs.join("-");
+}
+//#endregion
+export { onVersionRequest as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tegami",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "description": "A tool to manage changelogs, versioning, and publishing in monorepo",
   "license": "MIT",
   "author": "Fuma Nama",