@ucdjs/release-scripts 0.1.0-beta.36 → 0.1.0-beta.37

package/dist/index.d.mts

@@ -29,6 +29,8 @@ interface ReleaseScriptsOptionsInput {
   npm?: {
     otp?: string;
     provenance?: boolean;
+    access?: "public" | "restricted";
+    runBuild?: boolean;
   };
   prompts?: {
     versions?: boolean;

package/dist/index.mjs

@@ -362,7 +362,9 @@ function normalizeReleaseScriptsOptions(options) {
 		} : DEFAULT_TYPES,
 		npm: {
 			otp: npm.otp,
-			provenance: npm.provenance ?? true
+			provenance: npm.provenance ?? true,
+			access: npm.access ?? "public",
+			runBuild: npm.runBuild ?? true
 		},
 		prompts: {
 			versions: prompts.versions ?? !isCI,
@@ -482,7 +484,19 @@ async function checkoutBranch(branch, workspaceRoot) {
 		}
 		return ok(false);
 	} catch (error) {
-		return err(toGitError("checkoutBranch", error));
+		const gitError = toGitError("checkoutBranch", error);
+		logger.error(`Git checkout failed: ${gitError.message}`);
+		if (gitError.stderr) logger.error(`Git stderr: ${gitError.stderr}`);
+		try {
+			const branchResult = await run("git", ["branch", "-a"], { nodeOptions: {
+				cwd: workspaceRoot,
+				stdio: "pipe"
+			} });
+			logger.verbose(`Available branches:\n${branchResult.stdout}`);
+		} catch {
+			logger.verbose("Could not list available branches");
+		}
+		return err(gitError);
 	}
 }
 async function pullLatestChanges(branch, workspaceRoot) {
@@ -656,6 +670,60 @@ async function getGroupedFilesByCommitSha(workspaceRoot, from, to) {
 		return err(toGitError("getGroupedFilesByCommitSha", error));
 	}
 }
+/**
+* Create a git tag for a package release
+* @param packageName - The package name (e.g., "@scope/name")
+* @param version - The version to tag (e.g., "1.2.3")
+* @param workspaceRoot - The root directory of the workspace
+* @returns Result indicating success or failure
+*/
+async function createPackageTag(packageName, version, workspaceRoot) {
+	const tagName = `${packageName}@${version}`;
+	try {
+		logger.info(`Creating tag: ${farver.green(tagName)}`);
+		await runIfNotDry("git", ["tag", tagName], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("createPackageTag", error));
+	}
+}
+/**
+* Push a specific tag to the remote repository
+* @param tagName - The tag name to push
+* @param workspaceRoot - The root directory of the workspace
+* @returns Result indicating success or failure
+*/
+async function pushTag(tagName, workspaceRoot) {
+	try {
+		logger.info(`Pushing tag: ${farver.green(tagName)}`);
+		await runIfNotDry("git", [
+			"push",
+			"origin",
+			tagName
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "pipe"
+		} });
+		return ok(void 0);
+	} catch (error) {
+		return err(toGitError("pushTag", error));
+	}
+}
+/**
+* Create and push a package tag in one operation
+* @param packageName - The package name
+* @param version - The version to tag
+* @param workspaceRoot - The root directory of the workspace
+* @returns Result indicating success or failure
+*/
+async function createAndPushPackageTag(packageName, version, workspaceRoot) {
+	const createResult = await createPackageTag(packageName, version, workspaceRoot);
+	if (!createResult.ok) return createResult;
+	return pushTag(`${packageName}@${version}`, workspaceRoot);
+}
 
 //#endregion
 //#region src/core/changelog.ts
@@ -1281,6 +1349,51 @@ function getAllAffectedPackages(graph, changedPackages) {
 	return affected;
 }
 /**
+* Calculate the order in which packages should be published
+*
+* Performs topological sorting to ensure dependencies are published before dependents.
+* Assigns a "level" to each package based on its depth in the dependency tree.
+*
+* This is used by the publish command to publish packages in the correct order.
+*
+* @param graph - Dependency graph
+* @param packagesToPublish - Set of package names to publish
+* @returns Array of packages in publish order with their dependency level
+*/
+function getPackagePublishOrder(graph, packagesToPublish) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const toUpdate = new Set(packagesToPublish);
+	const packagesToProcess = new Set(packagesToPublish);
+	for (const pkg of packagesToPublish) {
+		const deps = graph.dependents.get(pkg);
+		if (deps) for (const dep of deps) {
+			packagesToProcess.add(dep);
+			toUpdate.add(dep);
+		}
+	}
+	function visit(pkgName, level) {
+		if (visited.has(pkgName)) return;
+		visited.add(pkgName);
+		const pkg = graph.packages.get(pkgName);
+		if (!pkg) return;
+		const allDeps = [...pkg.workspaceDependencies, ...pkg.workspaceDevDependencies];
+		let maxDepLevel = level;
+		for (const dep of allDeps) if (toUpdate.has(dep)) {
+			visit(dep, level);
+			const depResult = result.find((r) => r.package.name === dep);
+			if (depResult && depResult.level >= maxDepLevel) maxDepLevel = depResult.level + 1;
+		}
+		result.push({
+			package: pkg,
+			level: maxDepLevel
+		});
+	}
+	for (const pkg of toUpdate) visit(pkg, 0);
+	result.sort((a, b) => a.level - b.level);
+	return result;
+}
+/**
 * Create version updates for all packages affected by dependency changes
 *
 * When a package is updated, all packages that depend on it should also be updated.
@@ -1741,11 +1854,193 @@ async function prepareWorkflow(options) {
 	};
 }
 
+//#endregion
+//#region src/core/npm.ts
+function toNPMError(operation, error, code) {
+	return {
+		type: "npm",
+		operation,
+		message: error instanceof Error ? error.message : String(error),
+		code
+	};
+}
+/**
+* Get the NPM registry URL
+* Respects NPM_CONFIG_REGISTRY environment variable, defaults to npmjs.org
+*/
+function getRegistryURL() {
+	return process.env.NPM_CONFIG_REGISTRY || "https://registry.npmjs.org";
+}
+/**
+* Fetch package metadata from NPM registry
+* @param packageName - The package name (e.g., "lodash" or "@scope/name")
+* @returns Result with package metadata or error
+*/
+async function getPackageMetadata(packageName) {
+	try {
+		const registry = getRegistryURL();
+		const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName);
+		const response = await fetch(`${registry}/${encodedName}`, { headers: { Accept: "application/json" } });
+		if (!response.ok) {
+			if (response.status === 404) return err(toNPMError("getPackageMetadata", `Package not found: ${packageName}`, "E404"));
+			return err(toNPMError("getPackageMetadata", `HTTP ${response.status}: ${response.statusText}`));
+		}
+		return ok(await response.json());
+	} catch (error) {
+		return err(toNPMError("getPackageMetadata", error, "ENETWORK"));
+	}
+}
+/**
+* Check if a specific package version exists on NPM
+* @param packageName - The package name
+* @param version - The version to check (e.g., "1.2.3")
+* @returns Result with boolean (true if version exists) or error
+*/
+async function checkVersionExists(packageName, version) {
+	const metadataResult = await getPackageMetadata(packageName);
+	if (!metadataResult.ok) {
+		if (metadataResult.error.code === "E404") return ok(false);
+		return err(metadataResult.error);
+	}
+	return ok(version in metadataResult.value.versions);
+}
+/**
+* Build a package before publishing
+* @param packageName - The package name to build
+* @param workspaceRoot - Path to the workspace root
+* @param options - Normalized release scripts options
+* @returns Result indicating success or failure
+*/
+async function buildPackage(packageName, workspaceRoot, options) {
+	if (!options.npm.runBuild) return ok(void 0);
+	try {
+		await runIfNotDry("pnpm", [
+			"--filter",
+			packageName,
+			"build"
+		], { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "inherit"
+		} });
+		return ok(void 0);
+	} catch (error) {
+		return err(toNPMError("buildPackage", error));
+	}
+}
+/**
+* Publish a package to NPM
+* Uses pnpm to handle workspace protocol and catalog: resolution automatically
+* @param packageName - The package name to publish
+* @param workspaceRoot - Path to the workspace root
+* @param options - Normalized release scripts options
+* @returns Result indicating success or failure
+*/
+async function publishPackage(packageName, workspaceRoot, options) {
+	const args = [
+		"--filter",
+		packageName,
+		"publish",
+		"--access",
+		options.npm.access,
+		"--no-git-checks"
+	];
+	if (options.npm.otp) args.push("--otp", options.npm.otp);
+	if (process.env.NPM_CONFIG_TAG) args.push("--tag", process.env.NPM_CONFIG_TAG);
+	const env = { ...process.env };
+	if (options.npm.provenance) env.NPM_CONFIG_PROVENANCE = "true";
+	try {
+		await runIfNotDry("pnpm", args, { nodeOptions: {
+			cwd: workspaceRoot,
+			stdio: "inherit",
+			env
+		} });
+		return ok(void 0);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return err(toNPMError("publishPackage", error, errorMessage.includes("E403") ? "E403" : errorMessage.includes("EPUBLISHCONFLICT") ? "EPUBLISHCONFLICT" : errorMessage.includes("EOTP") ? "EOTP" : void 0));
+	}
+}
+
 //#endregion
 //#region src/workflows/publish.ts
 async function publishWorkflow(options) {
-	logger.warn("Publish workflow is not implemented yet.");
-	logger.verbose("Publish options:", options);
+	logger.section("📦 Publishing Packages");
+	const discovered = await discoverWorkspacePackages(options.workspaceRoot, options);
+	if (!discovered.ok) exitWithError(`Failed to discover packages: ${discovered.error.message}`);
+	const workspacePackages = discovered.value;
+	logger.item(`Found ${workspacePackages.length} packages in workspace`);
+	const graph = buildPackageDependencyGraph(workspacePackages);
+	const publicPackages = workspacePackages.filter((pkg) => !pkg.packageJson.private);
+	logger.item(`Publishing ${publicPackages.length} public packages (private packages excluded)`);
+	if (publicPackages.length === 0) {
+		logger.warn("No public packages to publish");
+		return;
+	}
+	const publishOrder = getPackagePublishOrder(graph, new Set(publicPackages.map((p) => p.name)));
+	const status = {
+		published: [],
+		skipped: [],
+		failed: []
+	};
+	for (const order of publishOrder) {
+		const pkg = order.package;
+		const version = pkg.version;
+		const packageName = pkg.name;
+		logger.section(`📦 ${farver.cyan(packageName)} ${farver.gray(`(level ${order.level})`)}`);
+		logger.step(`Checking if ${farver.cyan(`${packageName}@${version}`)} exists on NPM...`);
+		const existsResult = await checkVersionExists(packageName, version);
+		if (!existsResult.ok) {
+			logger.error(`Failed to check version: ${existsResult.error.message}`);
+			status.failed.push(packageName);
+			exitWithError(`Publishing failed for ${packageName}: ${existsResult.error.message}`, "Check your network connection and NPM registry access");
+		}
+		if (existsResult.value) {
+			logger.info(`Version ${farver.cyan(version)} already exists on NPM, skipping`);
+			status.skipped.push(packageName);
+			continue;
+		}
+		if (options.npm.runBuild) {
+			logger.step(`Building ${farver.cyan(packageName)}...`);
+			const buildResult = await buildPackage(packageName, options.workspaceRoot, options);
+			if (!buildResult.ok) {
+				logger.error(`Failed to build package: ${buildResult.error.message}`);
+				status.failed.push(packageName);
+				exitWithError(`Publishing failed for ${packageName}: build failed`, "Check your build scripts and dependencies");
+			}
+		}
+		logger.step(`Publishing ${farver.cyan(`${packageName}@${version}`)} to NPM...`);
+		const publishResult = await publishPackage(packageName, options.workspaceRoot, options);
+		if (!publishResult.ok) {
+			logger.error(`Failed to publish: ${publishResult.error.message}`);
+			status.failed.push(packageName);
+			let hint;
+			if (publishResult.error.code === "E403") hint = "Authentication failed. Ensure your NPM token or OIDC configuration is correct";
+			else if (publishResult.error.code === "EPUBLISHCONFLICT") hint = "Version conflict. The version may have been published recently";
+			else if (publishResult.error.code === "EOTP") hint = "2FA/OTP required. Provide the otp option or use OIDC authentication";
+			exitWithError(`Publishing failed for ${packageName}`, hint);
+		}
+		logger.success(`Published ${farver.cyan(`${packageName}@${version}`)}`);
+		status.published.push(packageName);
+		logger.step(`Creating git tag ${farver.cyan(`${packageName}@${version}`)}...`);
+		const tagResult = await createAndPushPackageTag(packageName, version, options.workspaceRoot);
+		if (!tagResult.ok) {
+			logger.error(`Failed to create/push tag: ${tagResult.error.message}`);
+			logger.warn(`Package was published but tag was not created. You may need to create it manually.`);
+		} else logger.success(`Created and pushed tag ${farver.cyan(`${packageName}@${version}`)}`);
+	}
+	logger.section("📊 Publishing Summary");
+	logger.item(`${farver.green("✓")} Published: ${status.published.length} package(s)`);
+	if (status.published.length > 0) for (const pkg of status.published) logger.item(`  ${farver.green("•")} ${pkg}`);
+	if (status.skipped.length > 0) {
+		logger.item(`${farver.yellow("⚠")} Skipped (already exists): ${status.skipped.length} package(s)`);
+		for (const pkg of status.skipped) logger.item(`  ${farver.yellow("•")} ${pkg}`);
+	}
+	if (status.failed.length > 0) {
+		logger.item(`${farver.red("✖")} Failed: ${status.failed.length} package(s)`);
+		for (const pkg of status.failed) logger.item(`  ${farver.red("•")} ${pkg}`);
+	}
+	if (status.failed.length > 0) exitWithError(`Publishing completed with ${status.failed.length} failure(s)`);
+	logger.success("All packages published successfully!");
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.36",
+  "version": "0.1.0-beta.37",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",