@wpelevator/wp-release 0.6.0 → 0.7.0

package/dist/changeset-release.js

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import { loadChangesetConfig } from "./changeset-config.js";
 import { findMainPluginFile } from "./package-meta.js";
 import { findConstantValues } from "./version-check.js";
-import { getChangesetBump, getNextVersion, parseChangeset, } from "./changesets.js";
+import { formatChangelogEntries, formatChangeset, getChangesetBump, getNextVersion, parseChangeset, } from "./changesets.js";
 import { ValidationError } from "./errors.js";
 const execFileAsync = promisify(execFile);
 /**
@@ -19,6 +19,18 @@ export async function getChangesetReleasePlan(input) {
     const context = await getReleaseContext(input);
     return context?.plan;
 }
+/**
+ * Discover the packages of the repository configuration.
+ *
+ * @param  input Repository root and optional explicit config file.
+ * @return Packages in the configured order with their current versions.
+ * @throws {ValidationError} Without a config, or for an invalid one.
+ */
+export async function getChangesetPackages(input) {
+    const loaded = await requireConfig(input);
+    const packages = await discoverPackages(input.cwd, loaded.config);
+    return packages.map(toChangesetPackage);
+}
 async function getReleaseContext(input) {
     const loaded = await loadChangesetConfig(input);
     if (!loaded) {
@@ -110,7 +122,10 @@ export async function versionChangesets(input) {
     if (!context) {
         throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
     }
-    const { config, packages, plan: releasePlan } = context;
+    const { config, packages } = context;
+    const releasePlan = input.packages
+        ? selectReleasePlan(context.plan, packages, input.packages)
+        : context.plan;
     const date = input.date ?? new Date().toISOString().slice(0, 10);
     if (!input.dryRun) {
         const journal = new Map();
@@ -128,9 +143,7 @@ export async function versionChangesets(input) {
             }
             const changesetDirectory = path.resolve(input.cwd, config.changesets ?? '.changeset');
             for (const changeset of releasePlan.changesets) {
-                const file = path.join(changesetDirectory, changeset.fileName);
-                await rememberFile(journal, file);
-                await rm(file);
+                await consumeChangeset(path.join(changesetDirectory, changeset.fileName), changeset, input.packages, journal);
             }
         }
         catch (error) {
@@ -147,6 +160,48 @@ export async function versionChangesets(input) {
         changed: !input.dryRun && releasePlan.changesets.length > 0,
     };
 }
+/**
+ * Limit a release plan to some packages and the changesets that name them.
+ *
+ * @param  plan     Release plan of all pending changesets.
+ * @param  packages Configured packages.
+ * @param  names    Packages to version.
+ * @return Release plan of the named packages.
+ * @throws {ValidationError} For unknown packages.
+ */
+function selectReleasePlan(plan, packages, names) {
+    names.forEach((name) => {
+        if (!packages.some((pkg) => pkg.name === name)) {
+            throw new ValidationError(`Unknown package "${name}".`);
+        }
+    });
+    return {
+        releases: plan.releases.filter((release) => names.includes(release.package.name)),
+        changesets: plan.changesets.filter((changeset) => names.some((name) => Object.hasOwn(changeset.packages, name))),
+    };
+}
+/**
+ * Remove an applied changeset, or only the applied packages from a changeset
+ * that names other packages too, so that their releases keep its summary.
+ *
+ * @param file      Changeset file.
+ * @param changeset Parsed changeset.
+ * @param applied   Versioned packages, or undefined when all were versioned.
+ * @param journal   File journal for rolling back.
+ */
+async function consumeChangeset(file, changeset, applied, journal) {
+    const remaining = Object.entries(changeset.packages).filter(([name]) => undefined !== applied && !applied.includes(name));
+    await rememberFile(journal, file);
+    if (remaining.length) {
+        await writeFile(file, formatChangeset({
+            packages: Object.fromEntries(remaining),
+            summary: changeset.summary,
+        }));
+    }
+    else {
+        await rm(file);
+    }
+}
 /**
  * Create missing release tags, optionally pushing them to the configured remote.
  *
@@ -157,49 +212,64 @@ export async function tagChangesets(input) {
     if (input.githubRelease && !input.push) {
         throw new ValidationError('GitHub Releases require pushing the tags.');
     }
+    if (input.untagged && input.push) {
+        throw new ValidationError('Listing untagged releases cannot be combined with pushing tags.');
+    }
     const context = await getReleaseContext(input);
     if (!context) {
         throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
     }
+    const selected = selectPackages(context.packages, input);
     const packages = input.since
-        ? (await changedPackagesSince(input.cwd, context.packages, input.since)).packages
-        : context.packages;
+        ? (await changedPackagesSince(input.cwd, selected, input.since))
+            .packages
+        : selected;
     const results = [];
+    const dryRun = input.dryRun || input.untagged;
     const tagFormat = context.config.tagFormat ?? '{path}/{version}';
     for (const pkg of packages) {
-        const version = 'git-tag' === pkg.versionConfig.from.kind
-            ? await getLatestChangelogVersion(pkg.directory, pkg.currentVersion)
-            : pkg.currentVersion;
+        const version = await getTagVersion(pkg, input.version);
+        if (undefined !== input.version && input.version !== version) {
+            throw new ValidationError(`Package "${pkg.name}" is at version ${version}, not ${input.version}.`);
+        }
         const tag = formatTag(tagFormat, pkg, version);
         const exists = await gitTagExists(input.cwd, tag);
-        const notes = await readReleaseNotes(pkg.directory, version);
-        if (!exists && !input.dryRun) {
+        if (!exists) {
+            await verifyVersionTargets(input.cwd, pkg, version);
+        }
+        const previousTag = await getPreviousTag(input.cwd, formatTag(tagFormat, pkg, ''), version);
+        const notes = await getReleaseNotes(input.cwd, context.config, pkg, { version, tag, previousTag }, exists ? tag : 'HEAD');
+        if (!exists && !dryRun) {
             await git(input.cwd, ['tag', tag]);
         }
         results.push({
             package: pkg.name,
             version,
             tag,
-            created: !exists && !input.dryRun,
+            ...(previousTag ? { previousTag } : {}),
+            prerelease: isPrerelease(version),
+            exists,
+            created: !exists && !dryRun,
             notes,
         });
     }
-    if (input.push && !input.dryRun) {
-        const created = results.filter((result) => result.created);
-        if (created.length) {
-            await git(input.cwd, [
-                'push',
-                'origin',
-                ...created.map((item) => item.tag),
-            ]);
+    // Push one tag at a time because GitHub doesn't create push events for
+    // tags when more than three are pushed at once.
+    if (input.push && !dryRun) {
+        for (const item of results.filter((result) => result.created)) {
+            await git(input.cwd, ['push', 'origin', item.tag]);
         }
     }
-    if (input.githubRelease && !input.dryRun) {
+    if (input.githubRelease && !dryRun) {
         for (const release of results) {
             await createGitHubRelease(input.cwd, release);
         }
     }
-    return { tags: results };
+    return {
+        tags: input.untagged
+            ? results.filter((result) => !result.exists)
+            : results,
+    };
 }
 async function createGitHubRelease(cwd, release) {
     try {
@@ -217,6 +287,7 @@ async function createGitHubRelease(cwd, release) {
                 `${release.package}@${release.version}`,
                 '--notes',
                 release.notes,
+                ...(release.prerelease ? ['--prerelease'] : []),
             ], { cwd });
         }
         catch (error) {
@@ -225,6 +296,141 @@ async function createGitHubRelease(cwd, release) {
         }
     }
 }
+/**
+ * Get the version to tag. Packages versioned by their git tags have no
+ * version file, so the expected version is the version to tag, or else the
+ * latest CHANGELOG.md version.
+ *
+ * @param pkg      Configured package.
+ * @param expected Expected version from --version, if any.
+ * @return Version to tag.
+ */
+async function getTagVersion(pkg, expected) {
+    if ('git-tag' !== pkg.versionConfig.from.kind) {
+        return pkg.currentVersion;
+    }
+    return (expected ??
+        (await getLatestChangelogVersion(pkg.directory, pkg.currentVersion)));
+}
+/**
+ * Pick the packages passed with --package, or all packages without it.
+ *
+ * @param  packages Configured packages.
+ * @param  input    Tag options.
+ * @return Selected packages in the configured order.
+ * @throws {ValidationError} For unknown packages, or --version without a single package.
+ */
+function selectPackages(packages, input) {
+    const names = input.packages ?? [];
+    if (undefined !== input.version && 1 !== names.length) {
+        throw new ValidationError('An expected version requires exactly one package.');
+    }
+    names.forEach((name) => {
+        if (!packages.some((pkg) => pkg.name === name)) {
+            throw new ValidationError(`Unknown package "${name}".`);
+        }
+    });
+    return names.length
+        ? packages.filter((pkg) => names.includes(pkg.name))
+        : packages;
+}
+/**
+ * Find the tag of the newest release before a version.
+ *
+ * @param cwd     Repository root.
+ * @param prefix  Tag prefix of the package, like `plugins/alpha/`.
+ * @param version Version being released.
+ * @return Previous tag, or undefined for the first release.
+ */
+async function getPreviousTag(cwd, prefix, version) {
+    const output = await git(cwd, ['tag', '--list', `${prefix}*`]);
+    return output
+        .trim()
+        .split(/\r?\n/)
+        .filter((tag) => tag.startsWith(prefix))
+        .map((tag) => ({ tag, version: tag.slice(prefix.length) }))
+        .filter((item) => isVersion(item.version) &&
+        compareVersions(item.version, version) < 0)
+        .sort((a, b) => compareVersions(b.version, a.version))[0]?.tag;
+}
+/**
+ * Build the release notes of a tag with the configured formatter.
+ *
+ * @param cwd                 Repository root.
+ * @param config              Repository release configuration.
+ * @param pkg                 Released package.
+ * @param release             Version, tag and previous tag of the release.
+ * @param release.version     Released version.
+ * @param release.tag         Release tag.
+ * @param release.previousTag Tag of the previous release, if any.
+ * @param end                 Commit of the release: the tag, or HEAD before tagging.
+ * @return Release notes.
+ */
+async function getReleaseNotes(cwd, config, pkg, release, end) {
+    const changelog = await readReleaseNotes(pkg.directory, release.version);
+    const commits = await getReleaseCommits(cwd, pkg, end, release.previousTag);
+    const notes = changelog ||
+        commits
+            .map((commit) => `- ${commit.subject} (${commit.shortHash})`)
+            .join('\n');
+    if (!config.releaseNotes) {
+        return notes;
+    }
+    const formatted = await config.releaseNotes({
+        package: toChangesetPackage(pkg),
+        ...release,
+        changelog,
+        commits,
+        notes,
+    });
+    if ('string' !== typeof formatted) {
+        throw new ValidationError(`The releaseNotes formatter didn't return a string for package "${pkg.name}".`);
+    }
+    return formatted.trim();
+}
+/**
+ * List the commits that changed a package since its previous release.
+ *
+ * @param cwd         Repository root.
+ * @param pkg         Released package.
+ * @param end         Commit of the release.
+ * @param previousTag Tag of the previous release, if any.
+ * @return Commits, newest first.
+ */
+async function getReleaseCommits(cwd, pkg, end, previousTag) {
+    const packageFromRepo = path.relative(cwd, pkg.directory).split(path.sep).join('/') ||
+        '.';
+    const output = await git(cwd, [
+        'log',
+        '--format=%H%x1f%h%x1f%s',
+        previousTag ? `${previousTag}..${end}` : end,
+        '--',
+        packageFromRepo,
+    ]);
+    return output
+        .trim()
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => {
+        const [hash = '', shortHash = '', subject = ''] = line.split('\x1f');
+        return { hash, shortHash, subject };
+    });
+}
+/**
+ * Remove the release configuration from a package passed to config callbacks.
+ *
+ * @param pkg Configured package.
+ * @return Package without its group configuration.
+ */
+function toChangesetPackage(pkg) {
+    return {
+        name: pkg.name,
+        directory: pkg.directory,
+        path: pkg.path,
+        type: pkg.type,
+        currentVersion: pkg.currentVersion,
+    };
+}
 /**
  * Check whether changed files belong to packages without a changeset.
  *
@@ -543,9 +749,7 @@ async function prependChangelog(directory, release, date, readmeChangelog, chang
     const summaries = release.changesets
         .map((item) => item.summary.trim())
         .filter(Boolean);
-    const section = `## ${release.nextVersion} (${date})\n\n${summaries
-        .map((item) => `- ${item.replaceAll(/\r?\n/g, '\n  ')}`)
-        .join('\n')}\n\n`;
+    const section = `## ${release.nextVersion} (${date})\n\n${formatChangelogEntries(release.changesets)}\n\n`;
     const changelog = path.join(directory, 'CHANGELOG.md');
     let previous = '';
     try {
@@ -820,10 +1024,60 @@ function packageType(group) {
     }
     return 'other';
 }
+const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?$/;
+function isVersion(version) {
+    return VERSION_PATTERN.test(version);
+}
+function isPrerelease(version) {
+    return Boolean(VERSION_PATTERN.exec(version)?.[4]);
+}
+/**
+ * Compare two versions with SemVer precedence, where a pre-release like
+ * 1.0.0-rc.1 comes before 1.0.0.
+ *
+ * @param left  Version.
+ * @param right Version to compare with.
+ * @return Negative when left is lower, positive when higher, otherwise 0.
+ */
 function compareVersions(left, right) {
-    const a = left.split('.').map(Number);
-    const b = right.split('.').map(Number);
-    return ((a[0] ?? 0) - (b[0] ?? 0) ||
+    const [leftCore = '', leftPre] = splitPrerelease(left);
+    const [rightCore = '', rightPre] = splitPrerelease(right);
+    const a = leftCore.split('.').map(Number);
+    const b = rightCore.split('.').map(Number);
+    const core = (a[0] ?? 0) - (b[0] ?? 0) ||
         (a[1] ?? 0) - (b[1] ?? 0) ||
-        (a[2] ?? 0) - (b[2] ?? 0));
+        (a[2] ?? 0) - (b[2] ?? 0);
+    if (core || leftPre === rightPre) {
+        return core;
+    }
+    if (undefined === leftPre || undefined === rightPre) {
+        return undefined === leftPre ? 1 : -1;
+    }
+    return comparePrerelease(leftPre.split('.'), rightPre.split('.'));
+}
+function splitPrerelease(version) {
+    const index = version.indexOf('-');
+    return -1 === index
+        ? [version]
+        : [version.slice(0, index), version.slice(index + 1)];
+}
+function comparePrerelease(left, right) {
+    const [a, ...leftRest] = left;
+    const [b, ...rightRest] = right;
+    if (undefined === a || undefined === b) {
+        return (undefined === a ? 0 : 1) - (undefined === b ? 0 : 1);
+    }
+    const order = compareIdentifier(a, b);
+    return order || comparePrerelease(leftRest, rightRest);
+}
+function compareIdentifier(a, b) {
+    const aNumeric = /^\d+$/.test(a);
+    const bNumeric = /^\d+$/.test(b);
+    if (aNumeric && bNumeric) {
+        return Number(a) - Number(b);
+    }
+    if (aNumeric || bNumeric) {
+        return aNumeric ? -1 : 1;
+    }
+    return Number(a > b) - Number(a < b);
 }

package/dist/changesets.d.ts

@@ -53,6 +53,13 @@ export declare function parseChangeset(contents: string, fileName?: string): Cha
  * @return Markdown contents with a trailing newline.
  */
 export declare function formatChangeset(changeset: Omit<Changeset, 'fileName'>): string;
+/**
+ * Format the summaries of changesets as a Markdown list of changelog entries.
+ *
+ * @param changesets Changesets of a release.
+ * @return Markdown list, empty without summaries.
+ */
+export declare function formatChangelogEntries(changesets: Changeset[]): string;
 /**
  * Return the strongest bump requested for a package across changesets.
  *

package/dist/changesets.js

@@ -64,6 +64,19 @@ export function formatChangeset(changeset) {
         .join('\n');
     return `---\n${frontmatter}\n---\n\n${changeset.summary.trim()}\n`;
 }
+/**
+ * Format the summaries of changesets as a Markdown list of changelog entries.
+ *
+ * @param changesets Changesets of a release.
+ * @return Markdown list, empty without summaries.
+ */
+export function formatChangelogEntries(changesets) {
+    return changesets
+        .map((item) => item.summary.trim())
+        .filter(Boolean)
+        .map((item) => `- ${item.replaceAll(/\r?\n/g, '\n  ')}`)
+        .join('\n');
+}
 /**
  * Return the strongest bump requested for a package across changesets.
  *

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { appendFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import zip from "./commands/zip.js";
 import checksums from "./commands/checksums.js";
@@ -5,6 +6,7 @@ import sign from "./commands/sign.js";
 import verify from "./commands/verify.js";
 import versionCheck from "./commands/version-check.js";
 import deploySvn from "./commands/deploy-svn.js";
+import deployGit from "./commands/deploy-git.js";
 import { Logger, TextWriter } from "./logger.js";
 import { getBoolean, getString } from "./commands/command.js";
 import { ValidationError } from "./errors.js";
@@ -24,6 +26,7 @@ export const commands = [
     verify,
     versionCheck,
     deploySvn,
+    deployGit,
     changesetAdd,
     changesetStatus,
     changesetVersion,
@@ -36,6 +39,7 @@ const globalArgs = {
     'log-format': { type: 'string' },
     ci: { type: 'boolean' },
     json: { type: 'boolean' },
+    'github-output': { type: 'boolean' },
     config: { type: 'string' },
 };
 const globalOptions = `Global options:
@@ -47,6 +51,8 @@ const globalOptions = `Global options:
                            when GITHUB_ACTIONS=true, otherwise text)
       --ci                 Same as --log-format github
       --json               Print the result as JSON
+      --github-output      Set the result as JSON to the "result" output of
+                           the GitHub Actions step
       --config <path>      Path to a JavaScript release config file`;
 /**
  * Get the top-level help text listing all commands.
@@ -143,6 +149,21 @@ function createLogWriter(values, streams) {
     }
     return create(streams);
 }
+/**
+ * Get the GitHub Actions step output file for --github-output, checked before
+ * the command runs.
+ *
+ * @param  values Parsed option values.
+ * @return Output file path, or undefined without --github-output.
+ * @throws {ValidationError} For --github-output without GITHUB_OUTPUT.
+ */
+function getGitHubOutputFile(values) {
+    const file = process.env.GITHUB_OUTPUT;
+    if (getBoolean(values, 'github-output') && !file) {
+        throw new ValidationError('--github-output requires the GITHUB_OUTPUT environment variable of GitHub Actions.');
+    }
+    return getBoolean(values, 'github-output') ? file : undefined;
+}
 /**
  * Parse the arguments of a command and run it.
  *
@@ -169,6 +190,7 @@ async function runCommand(command, args, io) {
         if ('' === configFile?.trim()) {
             throw new ValidationError('--config <path> must not be empty.');
         }
+        const githubOutputFile = getGitHubOutputFile(values);
         logger = new Logger({
             writer: createLogWriter(values, { stdout, stderr }),
             quiet: getBoolean(values, 'quiet') || getBoolean(values, 'json'),
@@ -184,6 +206,10 @@ async function runCommand(command, args, io) {
         if (getBoolean(values, 'json')) {
             stdout.write(JSON.stringify(result, null, '\t') + '\n');
         }
+        if (githubOutputFile) {
+            // Compact JSON has no line breaks, so it fits a single output line.
+            appendFileSync(githubOutputFile, `result=${JSON.stringify(result)}\n`);
+        }
         return exitCode;
     }
     catch (error) {

package/dist/commands/changeset-args.d.ts

@@ -61,11 +61,16 @@ export declare const changesetVersionArgs: {
     readonly date: {
         readonly type: "string";
     };
+    readonly package: {
+        readonly type: "string";
+        readonly multiple: true;
+    };
 };
 /** Parsed input for `changeset-version`. */
 export interface ChangesetVersionArgs {
     dryRun: boolean;
     date?: string;
+    packages?: string[];
 }
 /**
  * Validate and normalize a release date option.
@@ -91,19 +96,32 @@ export declare const changesetTagArgs: {
     readonly 'dry-run': {
         readonly type: "boolean";
     };
+    readonly untagged: {
+        readonly type: "boolean";
+    };
     readonly 'github-release': {
         readonly type: "boolean";
     };
     readonly since: {
         readonly type: "string";
     };
+    readonly package: {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly version: {
+        readonly type: "string";
+    };
 };
 /** Parsed input for `changeset-tag`. */
 export interface ChangesetTagArgs {
     push: boolean;
     dryRun: boolean;
+    untagged: boolean;
     githubRelease: boolean;
     since?: string;
+    packages: string[];
+    version?: string;
 }
 /**
  * Parse the `changeset-tag` options.

package/dist/commands/changeset-args.js

@@ -74,6 +74,7 @@ export function parseChangesetStatusArgs(values) {
 export const changesetVersionArgs = {
     'dry-run': { type: 'boolean' },
     date: { type: 'string' },
+    package: { type: 'string', multiple: true },
 };
 /**
  * Validate and normalize a release date option.
@@ -104,17 +105,25 @@ export function parseChangesetDate(value) {
  */
 export function parseChangesetVersionArgs(values) {
     const date = parseChangesetDate(getString(values, 'date'));
+    const packages = getStrings(values, 'package');
+    if (packages.some((name) => !name.trim())) {
+        throw new ValidationError('--package <name> must not be empty.');
+    }
     return {
         dryRun: getBoolean(values, 'dry-run'),
         ...(date ? { date } : {}),
+        ...(packages.length ? { packages } : {}),
     };
 }
 /** Parse-args options for `changeset-tag`. */
 export const changesetTagArgs = {
     push: { type: 'boolean' },
     'dry-run': { type: 'boolean' },
+    untagged: { type: 'boolean' },
     'github-release': { type: 'boolean' },
     since: { type: 'string' },
+    package: { type: 'string', multiple: true },
+    version: { type: 'string' },
 };
 /**
  * Parse the `changeset-tag` options.
@@ -126,14 +135,29 @@ export function parseChangesetTagArgs(values) {
     const args = {
         push: getBoolean(values, 'push'),
         dryRun: getBoolean(values, 'dry-run'),
+        untagged: getBoolean(values, 'untagged'),
         githubRelease: getBoolean(values, 'github-release'),
         since: getString(values, 'since'),
+        packages: getStrings(values, 'package'),
+        version: getString(values, 'version')?.trim(),
     };
     if ('' === args.since?.trim()) {
         throw new ValidationError('--since <ref> must not be empty.');
     }
+    if (args.packages.some((name) => !name.trim())) {
+        throw new ValidationError('--package <name> must not be empty.');
+    }
+    if ('' === args.version) {
+        throw new ValidationError('--version <version> must not be empty.');
+    }
+    if (undefined !== args.version && 1 !== args.packages.length) {
+        throw new ValidationError('--version <version> requires exactly one --package <name>.');
+    }
     if (args.githubRelease && !args.push) {
         throw new ValidationError('--github-release requires --push.');
     }
+    if (args.untagged && args.push) {
+        throw new ValidationError('--untagged cannot be combined with --push.');
+    }
     return args;
 }

package/dist/commands/changeset-tag.d.ts

@@ -10,12 +10,22 @@ declare const _default: {
         readonly 'dry-run': {
             readonly type: "boolean";
         };
+        readonly untagged: {
+            readonly type: "boolean";
+        };
         readonly 'github-release': {
             readonly type: "boolean";
         };
         readonly since: {
             readonly type: "string";
         };
+        readonly package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        readonly version: {
+            readonly type: "string";
+        };
     };
     run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
         exitCode: number;