@yorozu/build 0.1.0

package/yorozu-build.js

@@ -0,0 +1,527 @@
+#!/usr/bin/env node
+import { asNonNull, collectPackageJsons, error, filterPackageJsonsForPublish, findRootPackage, getWorkspaceRoot, info, parallelMap, warn } from "./chunks/21EFCjEU.js";
+import { boolean, buildPackageCli, bumpVersion, command, createGithubRelease, findProjectChangedPackages, generateChangelog, generateDepsGraphCli, generateDocsCli, getCommitsBetween, getLatestTag, gitTagExists, isRunningInGithubActions, loadConfig, publishPackages, publishPackagesCli, resolveWorkspaceRoot, run, runContinuousReleaseCli, string, validateWorkspaceDeps, writeGithubActionsOutput } from "./chunks/CMapqBQB.js";
+import { ExecError, exec, sortWorkspaceByPublishOrder } from "./chunks/Cr5v7tI0.js";
+import { generateDenoWorkspace, jsrCreatePackages, populateFromUpstream } from "./chunks/CYSd7-PF.js";
+import process from "node:process";
+import { basename } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/cli/commands/lint/index.ts
+var INTERNAL_MESSAGES = {
+	not_workspace_proto: "internal dependencies must be linked with workspace: protocol",
+	not_workspace_dep: "workspace: protocol is used to link to a package not found in the workspace"
+};
+var lintCli = command({
+	name: "lint",
+	desc: "check the workspace for any issues",
+	options: {
+		workspace: string().desc("path to the workspace root (default: cwd)"),
+		noErrorCode: boolean("no-error-code").desc("whether to always exit with a zero code").default(false)
+	},
+	handler: async (args) => {
+		let workspaceRoot = resolveWorkspaceRoot(args.workspace);
+		let config = (await loadConfig({ workspaceRoot }))?.lint;
+		let errors = await validateWorkspaceDeps({
+			workspaceRoot,
+			config
+		});
+		if (errors.length === 0) {
+			info("workspace dependencies look good");
+			return;
+		}
+		let externalErrors = errors.filter((item) => item.type === "external");
+		let internalErrors = errors.filter((item) => item.type === "internal");
+		if (externalErrors.length > 0) {
+			warn("Found external dependencies mismatch:");
+			for (let item of externalErrors) warn(`  - at ${item.package}: ${item.at} has ${item.dependency}@${item.version}, but ${item.otherPackage} has @${item.otherVersion}`);
+		}
+		if (internalErrors.length > 0) {
+			warn("Found issues with internal dependencies:");
+			for (let item of internalErrors) warn(`  - at ${item.package}, dependency ${item.dependency}: ${INTERNAL_MESSAGES[item.subtype]}`);
+		}
+		if (!args.noErrorCode) process.exit(1);
+	}
+});
+//#endregion
+//#region src/cli/commands/bump-version.ts
+function sharedWorkspaceBumpOptions(params) {
+	return {
+		type: params.type === "auto" ? void 0 : params.type,
+		withRoot: true,
+		all: true,
+		dryRun: params.dryRun
+	};
+}
+function formatBumpVersionResult(result, withReleaseType) {
+	let lines = [];
+	if (withReleaseType) {
+		lines.push(`detected release type: ${result.releaseType}`);
+		lines.push(`  has breaking changes: ${result.hasBreakingChanges}`);
+		lines.push(`  has new features: ${result.hasFeatures}`);
+		lines.push("");
+	}
+	lines.push("list of changed packages:");
+	for (let { package: pkg, prevVersion } of result.changedPackages) {
+		let versionStr = prevVersion;
+		if (!pkg.json.yorozu?.ownVersioning) versionStr += ` → ${pkg.json.version}`;
+		lines.push(`  ${pkg.json.name}: ${versionStr}`);
+	}
+	return lines.join("\n");
+}
+var bumpVersionCli = command({
+	name: "bump-version",
+	desc: "bump the shared workspace version",
+	options: {
+		root: string().desc("path to the root of the workspace (default: process.cwd())"),
+		type: string().desc("override type of release (major, minor, patch) (default: auto-detect)").enum("major", "minor", "patch", "auto").default("auto"),
+		since: string().desc("starting point for the changelog (default: latest tag)"),
+		dryRun: boolean("dry-run").desc("whether to only print the detected changes without actually modifying anything"),
+		quiet: boolean().desc("whether to only print the new version number").alias("q")
+	},
+	handler: async (args) => {
+		let root = resolveWorkspaceRoot(args.root);
+		let releaseType = args.type === "auto" ? void 0 : args.type;
+		let workspace = await collectPackageJsons(root, true);
+		let config = await loadConfig({
+			workspaceRoot: root,
+			require: false
+		});
+		let since = args.since ?? await getLatestTag(root);
+		if (since == null) throw new Error("no previous tag found, cannot determine changeset");
+		let result = await bumpVersion({
+			workspace,
+			cwd: root,
+			since,
+			params: config?.versioning,
+			...sharedWorkspaceBumpOptions({
+				type: args.type,
+				dryRun: args.dryRun
+			})
+		});
+		if (args.quiet) info(JSON.stringify(result.nextVersions));
+		else info(formatBumpVersionResult(result, releaseType == null));
+		if (isRunningInGithubActions()) {
+			writeGithubActionsOutput("versions", JSON.stringify(result.nextVersions));
+			writeGithubActionsOutput("hasBreakingChanges", String(result.hasBreakingChanges));
+			writeGithubActionsOutput("hasFeatures", String(result.hasFeatures));
+			writeGithubActionsOutput("changedPackages", result.changedPackages.map((item) => item.package.json.name).join(","));
+		}
+	}
+});
+//#endregion
+//#region src/cli/commands/gen-changelog.ts
+var generateChangelogCli = command({
+	name: "gen-changelog",
+	desc: "generate a changelog for the workspace",
+	options: {
+		only: string().desc("comma-separated list of packages to include"),
+		root: string().desc("path to the root of the workspace (default: process.cwd())"),
+		since: string().desc("starting point for the changelog (default: latest tag)")
+	},
+	handler: async (args) => {
+		let root = resolveWorkspaceRoot(args.root);
+		let config = await loadConfig({
+			workspaceRoot: root,
+			require: false
+		});
+		let workspacePackages = await collectPackageJsons(root, false);
+		if (args.only !== void 0) {
+			let only = new Set(args.only.split(",").map((item) => item.trim()));
+			workspacePackages = workspacePackages.filter((pkg) => pkg.json.name != null && only.has(pkg.json.name));
+		}
+		let since = args.since ?? await getLatestTag(root);
+		if (since == null) throw new Error("no previous tag found, cannot determine changeset");
+		let changelog = await generateChangelog({
+			workspace: workspacePackages,
+			cwd: root,
+			since,
+			params: config?.versioning
+		});
+		if (isRunningInGithubActions()) {
+			writeGithubActionsOutput("changelog", changelog);
+			info("Written changelog to `changelog` output");
+		} else info(changelog);
+	}
+});
+//#endregion
+//#region src/cli/commands/find-changed-packages.ts
+var findChangedPackagesCli = command({
+	name: "find-changed-packages",
+	desc: "find changed packages between two commits, and output a comma-separated list of package names",
+	options: {
+		root: string().desc("path to the root of the workspace (default: process.cwd())"),
+		since: string().desc("starting point for the changelog (default: latest tag)"),
+		until: string().desc("ending point for the changelog (default: HEAD)")
+	},
+	handler: async (args) => {
+		let root = resolveWorkspaceRoot(args.root);
+		let config = await loadConfig({
+			workspaceRoot: root,
+			require: false
+		});
+		let since = args.since ?? await getLatestTag(root);
+		if (since == null) throw new Error("no previous tag found, cannot determine changeset");
+		let result = (await findProjectChangedPackages({
+			params: config?.versioning,
+			root,
+			since,
+			until: args.until
+		})).map((pkg) => pkg.json.name).join(",");
+		if (isRunningInGithubActions()) {
+			writeGithubActionsOutput("packages", result);
+			info("Written packages to `packages` output");
+		} else info(result);
+	}
+});
+//#endregion
+//#region src/cli/commands/release.ts
+function npmPublishList(workspace) {
+	return filterPackageJsonsForPublish(sortWorkspaceByPublishOrder(workspace.filter((pkg) => !pkg.root)), "npm");
+}
+function printPublishList(packages) {
+	info("publish list:");
+	if (packages.length === 0) {
+		info("  (none)");
+		return;
+	}
+	for (let pkg of packages) info(`  ${pkg.json.name}@${pkg.json.version}`);
+}
+function shouldSkipAutoRelease(params) {
+	return params.kind === "auto" && params.prevTag != null && params.commitsSincePrevTag.length === 0;
+}
+async function nextDateTag(root) {
+	let date = /* @__PURE__ */ new Date();
+	let tagNamePrefix = `v${date.getFullYear()}.${(date.getMonth() + 1).toString().padStart(2, "0")}.${date.getDate().toString().padStart(2, "0")}`;
+	let currentSuffix = "a";
+	let tagName = `${tagNamePrefix}${currentSuffix}`;
+	while (await gitTagExists(tagName, root)) {
+		if (currentSuffix === "z") throw new Error("Too many releases for today (max 26)");
+		currentSuffix = String.fromCharCode(currentSuffix.charCodeAt(0) + 1);
+		tagName = `${tagNamePrefix}${currentSuffix}`;
+	}
+	return tagName;
+}
+//#endregion
+//#region src/cli/main.ts
+await run([
+	lintCli,
+	buildPackageCli,
+	publishPackagesCli,
+	bumpVersionCli,
+	generateChangelogCli,
+	findChangedPackagesCli,
+	command({
+		name: "release",
+		desc: "release packages",
+		options: {
+			kind: string("kind").desc("release kind").enum("major", "minor", "patch", "auto").default("auto"),
+			withGithubRelease: boolean("with-github-release").desc("whether to create a github release (requires GITHUB_TOKEN env var). if false, will only create a commit with the release notes").default(false),
+			gitExtraOrigins: string("git-extra-origins").desc("extra git origins to push to (e.g. for mirrors). note that these origins will be force-pushed to"),
+			githubToken: string("github-token").desc("github token to use for creating a release (defaults to GITHUB_TOKEN env var)"),
+			githubRepo: string("github-repo").desc("github repo to create a release for (defaults to GITHUB_REPOSITORY env var)"),
+			githubApiUrl: string("github-api-url").desc("github api url to use for creating a release (for github-compatible apis)"),
+			withJsr: boolean("with-jsr").desc("whether to publish to jsr").default(false),
+			jsrRegistry: string("jsr-registry").desc("URL of the jsr registry to publish to"),
+			jsrToken: string("jsr-token").desc("jsr token to use for publishing"),
+			jsrPublishArgs: string("jsr-publish-args").desc("additional arguments to pass to `deno publish`"),
+			jsrCreatePackages: boolean("jsr-create-packages").desc("whether to create missing packages in jsr"),
+			withNpm: boolean("with-npm").desc("whether to publish to npm"),
+			npmToken: string("npm-token").desc("npm token to use for publishing (passed via env and a temporary local .npmrc)"),
+			npmPublishArgs: string("npm-publish-args").desc("additional arguments to pass to `npm publish`"),
+			npmDistDir: string("npm-dist-dir").desc("directory to publish to npm from, relative to package root (default: dist)"),
+			npmRegistry: string("npm-registry").desc("URL of the npm registry to publish to"),
+			noProvenance: boolean("no-provenance").desc("version to NOT use provenance even when it should be possible"),
+			dryRun: boolean("dry-run").desc("whether to skip publishing and only print what is going to happen")
+		},
+		handler: async (args) => {
+			let root = getWorkspaceRoot();
+			let config = await loadConfig({
+				workspaceRoot: root,
+				require: false
+			});
+			let workspaceWithRoot = await collectPackageJsons(root, true);
+			let rootPackage = findRootPackage(workspaceWithRoot);
+			let prevTag = await getLatestTag(root);
+			if (prevTag == null) info("no previous tag found, assuming this is a first ever release");
+			else info(`previous tag: ${prevTag}`);
+			let bumpVersionResult;
+			let nextVersion;
+			let changelog;
+			if (prevTag == null) {
+				nextVersion = asNonNull(rootPackage.json.version);
+				changelog = "Initial release";
+			} else {
+				let commitsSincePrevTag = await getCommitsBetween({
+					since: prevTag,
+					cwd: root
+				});
+				if (shouldSkipAutoRelease({
+					kind: args.kind,
+					prevTag,
+					commitsSincePrevTag
+				})) {
+					info(`no commits since ${prevTag}, nothing to do`);
+					process.exit(0);
+				}
+				bumpVersionResult = await bumpVersion({
+					workspace: workspaceWithRoot,
+					since: prevTag,
+					type: args.kind === "auto" ? void 0 : args.kind,
+					all: true,
+					cwd: root,
+					params: config?.versioning,
+					dryRun: args.dryRun,
+					withRoot: true
+				});
+				info(formatBumpVersionResult(bumpVersionResult, args.kind === "auto"));
+				nextVersion = bumpVersionResult.nextVersion;
+				changelog = await generateChangelog({
+					workspace: bumpVersionResult.changedPackages.map((pkg) => pkg.package),
+					cwd: root,
+					since: prevTag,
+					params: config?.versioning
+				});
+			}
+			let taggingSchema = config?.versioning?.taggingSchema ?? "semver";
+			let tagName;
+			if (prevTag == null || taggingSchema === "semver") {
+				tagName = `v${nextVersion}`;
+				if (await gitTagExists(tagName, root)) throw new Error(`tag ${tagName} already exists. did the previous release complete successfully? if so, please verify versions in package.json and try again`);
+			} else if (taggingSchema === "date") tagName = await nextDateTag(root);
+			else throw new Error(`Unknown tagging schema: ${String(taggingSchema)}`);
+			info(`next version: ${nextVersion}`);
+			info(`next tag: ${tagName}`);
+			info("--begin changelog--");
+			info(changelog);
+			info("--end changelog--");
+			printPublishList(npmPublishList(workspaceWithRoot));
+			if (isRunningInGithubActions()) {
+				writeGithubActionsOutput("version", nextVersion);
+				writeGithubActionsOutput("tag", tagName);
+				writeGithubActionsOutput("changelog", changelog);
+			}
+			let tarballs = [];
+			if (args.withNpm) if (args.dryRun) info("dry run, skipping npm publish");
+			else {
+				info("publishing to npm...");
+				let publishResult = await publishPackages({
+					packages: [":all"],
+					workspace: workspaceWithRoot,
+					workspaceRoot: root,
+					registryUrl: args.npmRegistry,
+					token: args.npmToken ?? process.env.NPM_TOKEN,
+					distDir: args.npmDistDir,
+					publishArgs: args.npmPublishArgs?.split(" "),
+					dryRun: args.dryRun,
+					withBuild: true,
+					withTarballs: args.withGithubRelease,
+					noProvenance: args.noProvenance
+				});
+				if (publishResult.failed.length > 0) {
+					info("failed to publish:");
+					for (let pkg of publishResult.failed) info(`  ${pkg}`);
+					process.exit(1);
+				}
+				info("published to npm");
+				tarballs = publishResult.tarballs;
+			}
+			else if (args.withGithubRelease) throw new Error("Cannot create a github release without publishing to npm (yet)");
+			if (args.withJsr) if (args.dryRun) info("dry run, skipping jsr publish");
+			else {
+				if (args.jsrCreatePackages) {
+					info("creating missing packages in jsr...");
+					if (await jsrCreatePackages({
+						workspaceRoot: root,
+						workspacePackages: workspaceWithRoot,
+						registry: args.jsrRegistry,
+						token: args.jsrToken,
+						githubRepo: args.githubRepo
+					})) info("some packages are missing, this might cause issues");
+				}
+				info("generating deno workspace...");
+				let workspaceDir = await generateDenoWorkspace({
+					workspaceRoot: root,
+					workspacePackages: workspaceWithRoot,
+					rootConfig: config?.jsr
+				});
+				info("publishing to jsr...");
+				await exec([
+					"deno",
+					"publish",
+					"--quiet",
+					"--allow-dirty",
+					...args.jsrToken != null ? ["--token", args.jsrToken] : [],
+					...args.jsrPublishArgs?.split(" ") ?? []
+				], {
+					env: {
+						...process.env,
+						JSR_URL: args.jsrRegistry
+					},
+					cwd: workspaceDir,
+					stdio: "inherit",
+					throwOnError: true
+				});
+				info("published to jsr");
+			}
+			if (args.dryRun) info("dry run, skipping release commit and tag");
+			else {
+				await config?.versioning?.beforeReleaseCommit?.(workspaceWithRoot);
+				let message = `chore(release): ${tagName}`;
+				if (!args.withGithubRelease) message += `\n\n${changelog}`;
+				await exec([
+					"git",
+					"commit",
+					"-am",
+					message,
+					"--allow-empty"
+				], {
+					cwd: root,
+					stdio: "inherit",
+					throwOnError: true
+				});
+				await exec([
+					"git",
+					"tag",
+					tagName,
+					"-m",
+					tagName
+				], {
+					cwd: root,
+					stdio: "inherit",
+					throwOnError: true
+				});
+				await exec([
+					"git",
+					"push",
+					"--follow-tags"
+				], {
+					cwd: root,
+					stdio: "inherit",
+					throwOnError: true
+				});
+				if (args.gitExtraOrigins != null) for (let origin of args.gitExtraOrigins.split(",")) {
+					await exec([
+						"git",
+						"push",
+						origin,
+						"--force"
+					], {
+						cwd: root,
+						stdio: "inherit",
+						throwOnError: true
+					});
+					try {
+						await exec([
+							"git",
+							"push",
+							origin,
+							"--force",
+							"--tags"
+						], {
+							cwd: root,
+							throwOnError: true
+						});
+					} catch (err) {
+						if (!(err instanceof ExecError)) throw err;
+						if (err.result.stderr.includes(`cannot lock ref 'refs/tags/${tagName}': reference already exists`)) info(`tag ${tagName} already exists on ${origin}, skipping`);
+						else throw err;
+					}
+				}
+			}
+			if (args.withGithubRelease) if (args.dryRun) info("dry run, skipping github release");
+			else {
+				let token = args.githubToken ?? process.env.GITHUB_TOKEN;
+				if (token == null) throw new Error("github token is not set");
+				let repo = args.githubRepo ?? process.env.GITHUB_REPOSITORY;
+				if (repo == null) throw new Error("github repo is not set");
+				info("creating github release...");
+				await createGithubRelease({
+					token,
+					repo,
+					tag: tagName,
+					name: tagName,
+					body: changelog,
+					apiUrl: args.githubApiUrl,
+					artifacts: await parallelMap(tarballs, async (file) => ({
+						name: basename(file),
+						type: "application/gzip",
+						body: new Uint8Array(await readFile(file))
+					}))
+				});
+				info(`github release created: https://github.com/${repo}/releases/tag/${tagName}`);
+			}
+			info("done!");
+		}
+	}),
+	command({
+		name: "jsr",
+		desc: "jsr-related commands",
+		subcommands: [
+			command({
+				name: "populate",
+				desc: "populate a local JSR instance with packages from an upstream registry",
+				options: {
+					upstream: string().desc("URL of the upstream registry (default: process.env.JSR_URL)"),
+					createViaApi: boolean("create-via-api").desc("create packages via the API instead of manually via web UI"),
+					packages: string().desc("comma-separated list of packages to populate (with version, e.g. `@std/fs@0.105.0`)").required(),
+					downstream: string().desc("URL of the downstream local registry").required(),
+					token: string().desc("API token"),
+					quiet: boolean().alias("q").desc("suppress output"),
+					publishArgs: string("publish-args").desc("Additional arguments to pass to `deno publish`")
+				},
+				transform: (args) => {
+					return {
+						...args,
+						packages: args.packages.split(",").map((item) => item.trim()),
+						publishArgs: args.publishArgs?.split(" ")
+					};
+				},
+				handler: populateFromUpstream
+			}),
+			command({
+				name: "create-packages",
+				desc: "create missing packages from the workspace",
+				options: {
+					registry: string("registry").desc("URL of the registry to publish to").default("https://jsr.io"),
+					root: string().desc("path to the root of the workspace (default: cwd)"),
+					token: string("token").desc("token to use for managing the packages"),
+					githubRepo: string("github-repo").desc("github repo to set for the package (requires --token)")
+				},
+				handler: async (args) => {
+					if (!await jsrCreatePackages({
+						workspaceRoot: resolveWorkspaceRoot(args.root),
+						registry: args.registry,
+						token: args.token,
+						githubRepo: args.githubRepo
+					})) info("all packages were published");
+				}
+			}),
+			command({
+				name: "gen-deno-workspace",
+				desc: "generate a deno workspace for jsr publishing",
+				options: {
+					workspaceRoot: string("root").desc("path to the root of the workspace (default: cwd)"),
+					withDryRun: boolean("with-dry-run").desc("whether to run `deno publish --dry-run` after generating the workspace")
+				},
+				handler: async (args) => {
+					let workspaceRoot = resolveWorkspaceRoot(args.workspaceRoot);
+					info(`deno workspace generated at ${await generateDenoWorkspace({
+						workspaceRoot,
+						rootConfig: (await loadConfig({ workspaceRoot }))?.jsr,
+						withDryRun: args.withDryRun
+					})}`);
+				}
+			})
+		]
+	}),
+	generateDocsCli,
+	generateDepsGraphCli,
+	runContinuousReleaseCli
+], { theme: (event) => {
+	if (event.type === "error" && event.violation === "unknown_error") {
+		error(event.error instanceof Error ? event.error : new Error(String(event.error)));
+		process.exit(1);
+	}
+	return false;
+} });
+//#endregion