tegami 0.0.1 → 0.1.0-beta.0

package/dist/providers/npm.js

@@ -0,0 +1,278 @@
+import { r as isNodeError, t as execFailure } from "../error-DBK-9uBa.js";
+import { n as WorkspacePackage } from "../graph-CUgwuRW5.js";
+import { i as pnpmWorkspaceSchema, r as packageManifestSchema } from "../schemas-Cc4h6bq5.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { x } from "tinyexec";
+import * as semver from "semver";
+import { glob } from "tinyglobby";
+import { load } from "js-yaml";
+import { detect } from "package-manager-detector";
+//#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(join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
+	}
+	onPlan(context) {
+		const defaults = super.onPlan(context);
+		defaults.publish ??= this.manifest.private !== true;
+		if (this.manifest.publishConfig?.tag) {
+			defaults.npm ??= {};
+			defaults.npm.distTag ??= this.manifest.publishConfig.tag;
+		}
+		return defaults;
+	}
+};
+var NpmRegistryClient = class {
+	cwd;
+	client;
+	id = "npm";
+	#versionMap = /* @__PURE__ */ new Map();
+	constructor(cwd, client, _graph) {
+		this.cwd = cwd;
+		this.client = client;
+	}
+	supports(pkg) {
+		return pkg instanceof NpmPackage;
+	}
+	async isPackagePublished(pkg) {
+		const cacheKey = `${pkg.id}@${pkg.version}`;
+		let info = this.#versionMap.get(cacheKey);
+		if (!info) {
+			const run = async () => {
+				const registry = pkg.manifest.publishConfig?.registry;
+				const args = [
+					"view",
+					`${pkg.name}@${pkg.version}`,
+					"version",
+					"--json"
+				];
+				if (registry) args.push("--registry", registry);
+				const result = await x(this.client, args, { nodeOptions: { cwd: this.cwd } });
+				if (result.exitCode === 0) return true;
+				const output = commandOutput(result);
+				if (isMissingRegistryEntry(output)) return false;
+				throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against the npm registry${registry ? ` "${registry}"` : ""}: ${output.trim() || `command exited with code ${result.exitCode}`}`);
+			};
+			info = run();
+			this.#versionMap.set(cacheKey, info);
+		}
+		return info;
+	}
+	async publish(pkg, { packageStore }) {
+		const args = ["publish"];
+		const distTag = packageStore.npm?.distTag;
+		if (distTag) args.push("--tag", distTag);
+		if (this.client === "pnpm") args.push("--no-git-checks");
+		const result = await x(this.client, args, { nodeOptions: { cwd: pkg.path } });
+		if (result.exitCode !== 0) throw execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result);
+	}
+};
+function commandOutput(result) {
+	return [result.stdout, result.stderr].filter(Boolean).join("\n");
+}
+function isMissingRegistryEntry(output) {
+	const normalized = output.toLowerCase();
+	return normalized.includes("e404") || normalized.includes("404") || normalized.includes("no match") || normalized.includes("no matching version") || normalized.includes("not found");
+}
+function parseDependencySpec(context, name, range) {
+	const { graph } = context;
+	if (range.startsWith("workspace:")) return {
+		range: range.slice(10),
+		linked: graph.get(`npm:${name}`),
+		protocol: "workspace"
+	};
+	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 === "npm") return `npm:${spec.alias}@${spec.range}`;
+	return spec.range;
+}
+function npm({ client: defaultClient, onBreakPeerDep = "set", 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 client;
+	function depsPolicy(context) {
+		const { graph } = context;
+		function needsUpdate(dependent, spec, target) {
+			if (spec.linked) {
+				const group = graph.getPackageGroup(dependent.id);
+				if (group?.options.syncBump && graph.getPackageGroup(spec.linked.id) === group) return false;
+				if (spec.protocol === "workspace") switch (spec.range) {
+					case "":
+					case "*": return true;
+					case "^":
+					case "~": return !semver.satisfies(target, `${spec.range}${spec.linked.version}`);
+				}
+			}
+			if (!semver.validRange(spec.range)) return false;
+			return !semver.satisfies(target, spec.range);
+		}
+		return {
+			id: "npm:deps",
+			onUpdate({ pkg, plan }) {
+				if (!(pkg instanceof NpmPackage)) return;
+				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, k, v);
+							if (!spec || spec.linked !== pkg) continue;
+							if (!needsUpdate(dependent, spec, plan.bumpVersion(pkg))) continue;
+							const bumpType = getBumpDepType({
+								kind: field,
+								spec,
+								name: k
+							});
+							if (bumpType === false) continue;
+							this.bumpPackage(dependent, {
+								type: bumpType,
+								reason: `update dependency "${k}"`
+							});
+						}
+					}
+				}
+			}
+		};
+	}
+	return {
+		name: "npm",
+		enforce: "pre",
+		async init() {
+			if (defaultClient) {
+				client = defaultClient;
+				return;
+			}
+			if ((await detect({ cwd: this.cwd }))?.name === "pnpm") client = "pnpm";
+			else client = "npm";
+		},
+		async resolve() {
+			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
+		},
+		createRegistryClient() {
+			return new NpmRegistryClient(this.cwd, client, this.graph);
+		},
+		initPlan(plan) {
+			plan.addPolicy(depsPolicy(this));
+		},
+		async applyPlan(draft) {
+			const { graph } = this;
+			const writes = [];
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof NpmPackage)) continue;
+				const plan = draft.getPackagePlan(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, k, v);
+						if (!spec || !spec.linked) continue;
+						if (!semver.validRange(spec.range) || spec.protocol === "workspace") 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);
+		}
+	};
+}
+async function discoverNpmPackages(cwd, add) {
+	let patterns;
+	const rootManifest = await readManifest(cwd).catch(() => void 0);
+	const pnpmPatterns = await readFile(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) add(new NpmPackage(cwd, rootManifest));
+	for (const entry of manifests) {
+		if (!entry?.manifest) continue;
+		add(new NpmPackage(entry.path, entry.manifest));
+	}
+}
+async function expandWorkspacePatterns(cwd, patterns) {
+	if (patterns.length === 0) return [];
+	return glob(patterns, {
+		absolute: true,
+		cwd,
+		ignore: ["**/node_modules/**", "**/dist/**"],
+		onlyDirectories: true,
+		onlyFiles: false
+	});
+}
+async function readManifest(packagePath) {
+	const content = await readFile(join(packagePath, "package.json"), "utf8");
+	const parsed = JSON.parse(content);
+	packageManifestSchema.parse(parsed);
+	return parsed;
+}
+//#endregion
+export { NpmPackage, NpmRegistryClient, npm };

package/dist/schemas-Cc4h6bq5.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+//#region src/schemas.ts
+const changelogFrontmatterSchema = z.object({
+	subject: z.string().optional(),
+	packages: z.array(z.string()).default([])
+});
+const stringRecordSchema = z.record(z.string(), z.string());
+const jsonCodec = (schema) => z.codec(z.string(), schema, {
+	decode: (jsonString, ctx) => {
+		try {
+			return JSON.parse(jsonString);
+		} catch (err) {
+			ctx.issues.push({
+				code: "invalid_format",
+				format: "json",
+				input: jsonString,
+				message: err.message
+			});
+			return z.NEVER;
+		}
+	},
+	encode: (value) => JSON.stringify(value)
+});
+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(),
+	workspaces: z.array(z.string()).optional(),
+	dependencies: stringRecordSchema.optional(),
+	devDependencies: stringRecordSchema.optional(),
+	peerDependencies: stringRecordSchema.optional(),
+	optionalDependencies: stringRecordSchema.optional()
+});
+//#endregion
+export { pnpmWorkspaceSchema as i, jsonCodec as n, packageManifestSchema as r, changelogFrontmatterSchema as t };

package/dist/semver-mWK2Khi2.js

@@ -0,0 +1,33 @@
+import { inc, parse } from "semver";
+//#region src/utils/semver.ts
+function formatNpmDistTag(distTag) {
+	return distTag && distTag !== "latest" ? ` (${distTag})` : "";
+}
+function formatPackageVersion(name, version, distTag) {
+	return `${name}@${version}${formatNpmDistTag(distTag)}`;
+}
+const WEIGHTS = {
+	major: 3,
+	minor: 2,
+	patch: 1
+};
+const PRE = {
+	major: "premajor",
+	minor: "preminor",
+	patch: "prepatch"
+};
+function maxBump(a, b) {
+	if (WEIGHTS[a] > WEIGHTS[b]) return a;
+	return b;
+}
+function bumpVersion(version, type, prerelease) {
+	let next = version;
+	if (prerelease) {
+		if (parse(version)?.prerelease[0] === prerelease) next = inc(version, "prerelease", prerelease);
+		else if (type) next = inc(version, PRE[type], prerelease);
+	} else if (type) next = inc(version, type);
+	if (!next) throw new Error(`Invalid semver version: ${version}`);
+	return next;
+}
+//#endregion
+export { maxBump as i, formatNpmDistTag as n, formatPackageVersion as r, bumpVersion as t };

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "tegami",
-  "version": "0.0.1",
+  "version": "0.1.0-beta.0",
+  "description": "Utility for package versioning & publish",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "repository": {
+    "type": "git",
+    "url": "github:fuma-nama/tegami"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./cli": "./dist/cli/index.js",
+    "./generators/simple": "./dist/generators/simple.js",
+    "./plugins/git": "./dist/plugins/git.js",
+    "./plugins/github": "./dist/plugins/github.js",
+    "./providers/cargo": "./dist/providers/cargo.js",
+    "./providers/npm": "./dist/providers/npm.js",
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -26,27 +47,6 @@
     "typescript": "6.0.3",
     "@repo/typescript-config": "0.0.0"
   },
-  "description": "Utility for package versioning & publish",
-  "license": "MIT",
-  "author": "Fuma Nama",
-  "repository": {
-    "type": "git",
-    "url": "github:fuma-nama/tegami"
-  },
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.mjs",
-    "./cli": "./dist/cli/index.mjs",
-    "./generators/simple": "./dist/generators/simple.mjs",
-    "./plugins/git": "./dist/plugins/git.mjs",
-    "./plugins/github": "./dist/plugins/github.mjs",
-    "./providers/cargo": "./dist/providers/cargo.mjs",
-    "./providers/npm": "./dist/providers/npm.mjs",
-    "./package.json": "./package.json"
-  },
   "scripts": {
     "types:check": "tsc --noEmit",
     "build": "tsdown",