tegami 0.2.1 → 1.0.0-beta.0

package/dist/npm-Q0qvAkIu.js

@@ -0,0 +1,362 @@
+import { i as isNodeError, n as execFailure } from "./error-DNy8R5ue.js";
+import { n as WorkspacePackage } from "./graph-OnX9ncdQ.js";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { x } from "tinyexec";
+import * as semver from "semver";
+import z from "zod";
+import { load } from "js-yaml";
+import { glob } from "tinyglobby";
+import { detect } from "package-manager-detector";
+//#region src/providers/npm/schema.ts
+const stringRecordSchema = z.record(z.string(), z.string());
+const pnpmWorkspaceSchema = z.looseObject({ packages: z.array(z.string()).optional() });
+const packageManifestSchema = z.looseObject({
+	name: z.string(),
+	version: z.string().optional(),
+	private: z.boolean().optional(),
+	publishConfig: z.looseObject({
+		access: z.enum(["public", "restricted"]).optional(),
+		registry: z.string().optional(),
+		tag: z.string().optional()
+	}).optional(),
+	scripts: z.record(z.string(), z.string()).optional(),
+	workspaces: z.array(z.string()).optional(),
+	dependencies: stringRecordSchema.optional(),
+	devDependencies: stringRecordSchema.optional(),
+	peerDependencies: stringRecordSchema.optional(),
+	optionalDependencies: stringRecordSchema.optional()
+});
+//#endregion
+//#region src/providers/npm.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+var NpmPackage = class extends WorkspacePackage {
+	path;
+	manifest;
+	manager = "npm";
+	constructor(path, manifest) {
+		super();
+		this.path = path;
+		this.manifest = manifest;
+	}
+	get name() {
+		return this.manifest.name;
+	}
+	get version() {
+		return this.manifest.version ?? "0.0.0";
+	}
+	async write() {
+		await writeFile(path.join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
+	}
+	initDraft() {
+		const defaults = super.initDraft();
+		defaults.npm = { distTag: this.manifest.publishConfig?.tag };
+		return defaults;
+	}
+	configureDraft(draft, group) {
+		super.configureDraft(draft, group);
+		const { distTag = group?.options?.npm?.distTag } = this.getPackageOptions().npm ?? {};
+		if (distTag) {
+			draft.npm ??= {};
+			draft.npm.distTag = distTag;
+		} else if (draft.prerelease) {
+			draft.npm ??= {};
+			draft.npm.distTag ??= draft.prerelease;
+		}
+	}
+};
+function parseDependencySpec(context, dependent, name, range) {
+	const { graph } = context;
+	if (range.startsWith("workspace:")) return {
+		range: range.slice(10),
+		linked: graph.get(`npm:${name}`),
+		protocol: "workspace"
+	};
+	if (range.startsWith("file:")) {
+		let target = path.resolve(dependent.path, range.slice(5));
+		if (path.basename(target) === "package.json") target = path.dirname(target);
+		return {
+			protocol: "file",
+			raw: range,
+			linked: graph.getPackages().find((pkg) => pkg instanceof NpmPackage && pkg.path === target)
+		};
+	}
+	if (range.startsWith("npm:")) {
+		const spec = range.slice(4);
+		const separator = spec.lastIndexOf("@");
+		if (separator <= 0) return;
+		const alias = spec.slice(0, separator);
+		return {
+			alias,
+			linked: graph.get(`npm:${alias}`),
+			range: spec.slice(separator + 1),
+			protocol: "npm"
+		};
+	}
+	return {
+		linked: graph.get(`npm:${name}`),
+		range
+	};
+}
+function formatDependencySpec(spec) {
+	if (spec.protocol === "workspace") return `workspace:${spec.range}`;
+	if (spec.protocol === "file") return spec.raw;
+	if (spec.protocol === "npm") return `npm:${spec.alias}@${spec.range}`;
+	return spec.range;
+}
+const packageLockSchema = z.object({
+	id: z.string(),
+	distTag: z.string().optional()
+});
+function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = true, bumpDep: getBumpDepType = ({ kind }) => {
+	switch (kind) {
+		case "dependencies":
+		case "optionalDependencies": return "patch";
+		case "devDependencies": return false;
+		case "peerDependencies":
+			if (onBreakPeerDep === "ignore") return false;
+			return "major";
+	}
+} } = {}) {
+	let active = false;
+	let client;
+	return {
+		name: "npm",
+		enforce: "pre",
+		async init() {
+			if (defaultClient) client = defaultClient;
+			else client = (await detect({ cwd: this.cwd }))?.name ?? "npm";
+			this.npm = { client };
+		},
+		async resolve() {
+			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
+			active = this.graph.getPackages().some((pkg) => pkg instanceof NpmPackage);
+		},
+		async publishPreflight({ pkg }) {
+			if (!(pkg instanceof NpmPackage)) return;
+			return { publish: pkg.manifest.private !== true && !await isPackagePublished(pkg) };
+		},
+		initPublishLock({ lock, draft }) {
+			for (const [id, pkg] of draft.getPackageDrafts()) {
+				if (!pkg.npm) continue;
+				lock.write("npm:packages", {
+					id,
+					distTag: pkg.npm.distTag
+				});
+			}
+		},
+		initPublishPlan({ lock, plan }) {
+			let data;
+			while (data = lock.read("npm:packages")) {
+				const parsed = packageLockSchema.safeParse(data).data;
+				if (!parsed) continue;
+				const packagePlan = plan.packages.get(parsed.id);
+				if (!packagePlan) continue;
+				packagePlan.npm = { distTag: parsed.distTag };
+			}
+		},
+		async publish({ pkg, plan }) {
+			if (!(pkg instanceof NpmPackage)) return;
+			return publish(client, pkg, plan.packages.get(pkg.id)?.npm?.distTag);
+		},
+		initDraft(plan) {
+			if (!active) return;
+			plan.addPolicy(depsPolicy(this, getBumpDepType));
+		},
+		async applyDraft(draft) {
+			if (!active) return;
+			const { graph } = this;
+			const writes = [];
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof NpmPackage)) continue;
+				const plan = draft.getPackageDraft(pkg.id);
+				if (plan) pkg.manifest.version = plan.bumpVersion(pkg);
+			}
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof NpmPackage)) continue;
+				for (const field of DEP_FIELDS) {
+					const dependencies = pkg.manifest[field];
+					if (!dependencies) continue;
+					for (const [k, v] of Object.entries(dependencies)) {
+						const spec = parseDependencySpec(this, pkg, k, v);
+						if (!spec?.linked || spec.protocol === "workspace" || spec.protocol === "file") continue;
+						if (!semver.validRange(spec.range)) continue;
+						if (semver.satisfies(spec.linked.version, spec.range)) continue;
+						let updatedRange;
+						const isPeer = field === "peerDependencies";
+						if (isPeer && onBreakPeerDep === "ignore") continue;
+						else if (isPeer && onBreakPeerDep === "set") updatedRange = spec.linked.version;
+						else if (isPeer && onBreakPeerDep === "error") throw new Error(`[Tegami] the version of "${spec.linked.name}" is beyond its peer dependency constraint "${v}" in package "${pkg.name}", please update the constraint to satisfy.`);
+						else if (spec.range.startsWith("^")) updatedRange = `^${spec.linked.version}`;
+						else if (spec.range.startsWith("~")) updatedRange = `~${spec.linked.version}`;
+						else updatedRange = spec.linked.version;
+						dependencies[k] = formatDependencySpec({
+							...spec,
+							range: updatedRange
+						});
+					}
+				}
+				writes.push(pkg.write());
+			}
+			await Promise.all(writes);
+		},
+		cli: { async draftApplied() {
+			if (!active || !updateLockFile) return;
+			let args;
+			if (client === "npm") args = ["ci"];
+			else if (client === "yarn") args = ["install", "--immutable"];
+			else if (client === "bun") args = ["install", "--frozen-lockfile"];
+			else args = ["install", "--frozen-lockfile"];
+			const result = await x(client, args, { nodeOptions: { cwd: this.cwd } });
+			if (result.exitCode !== 0) throw execFailure("Failed to update lockfile.", result);
+		} }
+	};
+}
+function depsPolicy(context, getBumpDepType) {
+	const { graph } = context;
+	function needsUpdate(spec, target) {
+		if (spec.linked && spec.protocol === "workspace") switch (spec.range) {
+			case "":
+			case "*": return true;
+			case "^":
+			case "~": return !semver.satisfies(target, `${spec.range}${spec.linked.version}`);
+		}
+		if (spec.linked && spec.protocol === "file") return true;
+		if (spec.protocol === "file" || !semver.validRange(spec.range)) return false;
+		return !semver.satisfies(target, spec.range);
+	}
+	return {
+		id: "npm:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof NpmPackage)) return;
+			const group = graph.getPackageGroup(pkg.id);
+			for (const dependent of graph.getPackages()) {
+				if (!(dependent instanceof NpmPackage)) continue;
+				for (const field of DEP_FIELDS) {
+					const dependencies = dependent.manifest[field];
+					if (!dependencies) continue;
+					for (const [k, v] of Object.entries(dependencies)) {
+						const spec = parseDependencySpec(context, dependent, k, v);
+						if (!spec || spec.linked !== pkg) continue;
+						if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
+						if (!needsUpdate(spec, plan.bumpVersion(pkg))) continue;
+						const bumpType = getBumpDepType({
+							kind: field,
+							dependent,
+							spec,
+							name: k
+						});
+						if (bumpType === false) continue;
+						this.bumpPackage(dependent, {
+							type: bumpType,
+							reason: `update dependency "${k}"`
+						});
+					}
+				}
+			}
+		}
+	};
+}
+async function publish(client, pkg, distTag) {
+	if (client === "bun") {
+		for (const script of [
+			"prepublishOnly",
+			"prepack",
+			"prepare"
+		]) {
+			if (!pkg.manifest.scripts?.[script]) continue;
+			const result = await x("bun", ["run", script], { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode === 0) continue;
+			return {
+				type: "failed",
+				error: execFailure(`Failed to run ${script} script for ${pkg.name}@${pkg.version}.`, result).message
+			};
+		}
+		const tarballPath = path.resolve(pkg.path, "pkg.tgz");
+		const packResult = await x("bun", [
+			"pm",
+			"pack",
+			"--filename",
+			tarballPath
+		], { nodeOptions: { cwd: pkg.path } });
+		if (packResult.exitCode !== 0) return {
+			type: "failed",
+			error: execFailure(`Failed to pack ${pkg.name}@${pkg.version}.`, packResult).message
+		};
+		const publishArgs = ["publish", tarballPath];
+		if (distTag) publishArgs.push("--tag", distTag);
+		const publishResult = await x("npm", publishArgs, { nodeOptions: { cwd: pkg.path } });
+		if (publishResult.exitCode !== 0) return {
+			type: "failed",
+			error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, publishResult).message
+		};
+		return { type: "published" };
+	}
+	let command;
+	const args = ["publish"];
+	if (distTag) args.push("--tag", distTag);
+	if (client === "pnpm") {
+		command = "pnpm";
+		args.push("--no-git-checks");
+	} else if (client === "yarn") command = "yarn";
+	else command = "npm";
+	const result = await x(command, args, { nodeOptions: { cwd: pkg.path } });
+	if (result.exitCode !== 0) return {
+		type: "failed",
+		error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result).message
+	};
+	return { type: "published" };
+}
+async function isPackagePublished(pkg) {
+	const registry = pkg.manifest.publishConfig?.registry ?? "https://registry.npmjs.org";
+	const base = registry.replace(/\/$/, "");
+	const response = await fetch(`${base}/${pkg.name}/${pkg.version}`, { headers: { Accept: "application/json" } });
+	if (response.status === 404) return false;
+	if (!response.ok) throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against the npm registry${registry ? ` "${registry}"` : ""}.`);
+	return true;
+}
+async function discoverNpmPackages(cwd, add) {
+	let patterns;
+	const rootManifest = await readManifest(cwd).catch(() => void 0);
+	const pnpmPatterns = await readFile(path.join(cwd, "pnpm-workspace.yaml"), "utf8").then((content) => pnpmWorkspaceSchema.parse(load(content) ?? {})).catch((error) => {
+		if (isNodeError(error) && error.code === "ENOENT") return void 0;
+		throw error;
+	});
+	if (pnpmPatterns) patterns = pnpmPatterns.packages ?? [];
+	else patterns = rootManifest?.workspaces ?? [];
+	const candidatePaths = await expandWorkspacePatterns(cwd, patterns);
+	const manifests = await Promise.all(candidatePaths.map((path) => readManifest(path).then((manifest) => ({
+		path,
+		manifest
+	})).catch(() => void 0)));
+	if (rootManifest?.name) add(new NpmPackage(cwd, rootManifest));
+	for (const entry of manifests) {
+		if (!entry) continue;
+		add(new NpmPackage(entry.path, entry.manifest));
+	}
+}
+async function expandWorkspacePatterns(cwd, patterns) {
+	if (patterns.length === 0) return [];
+	return (await glob(patterns, {
+		absolute: true,
+		cwd,
+		ignore: ["**/node_modules/**", "**/dist/**"],
+		onlyDirectories: true,
+		onlyFiles: false
+	})).map((item) => {
+		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
+	});
+}
+async function readManifest(packagePath) {
+	const content = await readFile(path.join(packagePath, "package.json"), "utf8");
+	const parsed = JSON.parse(content);
+	packageManifestSchema.parse(parsed);
+	return parsed;
+}
+//#endregion
+export { npm as n, NpmPackage as t };

package/dist/plugins/git.d.ts

@@ -1,4 +1,4 @@
-import { s as TegamiPlugin } from "../types-DEaKjB3O.js";
+import { s as TegamiPlugin } from "../types-DnCUr2dB.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, O as Draft, S as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-DEaKjB3O.js";
+import { C as WorkspacePackage, b as TegamiContext, p as PublishPlan, s as TegamiPlugin, t as Awaitable, w as Draft } from "../types-DnCUr2dB.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts

package/dist/plugins/github.js

@@ -1,4 +1,4 @@
-import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-C4vJ4SK8.js";
+import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-jcIUAvbl.js";
 import { a as isCI, n as execFailure } from "../error-DNy8R5ue.js";
 import { a as findOpenPullRequest, l as updatePullRequest, n as createPullRequest, r as createRelease, s as releaseExistsByTag } from "../api-D-jf_8xY.js";
 import { git } from "./git.js";
@@ -26,9 +26,7 @@ function github(options = {}) {
 			if (!packageDraft) continue;
 			const originalVersion = cliOriginalPackageVersions.get(pkg.id) ?? pkg.version;
 			if (originalVersion === pkg.version) continue;
-			let line = `- **${pkg.name}**: ${originalVersion} → ${pkg.version}`;
-			line += formatNpmDistTag(packageDraft.npm?.distTag);
-			packageLines.push(line);
+			packageLines.push(`| \`${pkg.name}\` | \`${originalVersion}\` | \`${pkg.version}\`${formatNpmDistTag(packageDraft.npm?.distTag)} |`);
 		}
 		const changelogLines = [];
 		for (const entry of draft.getChangelogs()) {
@@ -42,9 +40,9 @@ function github(options = {}) {
 			"## Summary",
 			"",
 			"Merge this PR to publish the versioned packages.",
-			"",
-			...packageLines
+			""
 		];
+		if (packageLines.length > 0) sections.push("| Package | From | To |", "| --- | --- | --- |", ...packageLines);
 		if (changelogLines.length > 0) sections.push("", "## Changelogs", ...changelogLines);
 		sections.push("");
 		return sections.join("\n");

package/dist/plugins/go.d.ts

@@ -0,0 +1,51 @@
+import { C as WorkspacePackage, O as BumpType, s as TegamiPlugin } from "../types-DnCUr2dB.js";
+
+//#region src/plugins/go.d.ts
+interface GoModFile {
+  module: string;
+  requires: Map<string, string>;
+  replaces: Map<string, GoReplace>;
+}
+interface GoReplace {
+  module: string;
+  path?: string;
+  version?: string;
+}
+declare class GoPackage extends WorkspacePackage {
+  readonly path: string;
+  readonly mod: GoModFile;
+  readonly manager = "go";
+  private versionValue;
+  private pendingRequires;
+  constructor(path: string, mod: GoModFile, version: string);
+  get name(): string;
+  get version(): string;
+  setVersion(version: string): void;
+  setRequire(module: string, version: string): void;
+  write(): Promise<void>;
+}
+interface GoPluginOptions {
+  /**
+   * Run `go work sync` or `go mod tidy` after versioning.
+   *
+   * @default true
+   */
+  updateLockFile?: boolean;
+  bumpDep?: (opts: {
+    dependent: GoPackage;
+    name: string;
+    version: string;
+  }) => BumpType | false;
+}
+/**
+ * Experimental plugin for Golang, the release flow of Golang is pretty special, there's some exceptions for it:
+ *
+ * - Version is stored in lock file, normally, it should prefer to store versions in a file like `package.json` & `Cargo.toml`, but for Golang, there is no such file.
+ * - Publishing is handed to Git plugin, because Golang uses Git tag for publishing.
+ */
+declare function go({
+  updateLockFile,
+  bumpDep: getBumpDepType
+}?: GoPluginOptions): TegamiPlugin;
+//#endregion
+export { GoPackage, GoPluginOptions, go };