@wpelevator/wp-release 0.12.0 → 0.13.0

package/dist/commands/changeset-args.js

@@ -7,48 +7,76 @@ export const changesetAddArgs = {
     bump: { type: 'string', multiple: true },
     summary: { type: 'string' },
     empty: { type: 'boolean' },
+    since: { type: 'string' },
     name: { type: 'string' },
 };
 /**
- * Parse and validate the `changeset-add` options.
+ * Check that a bump is patch, minor or major.
+ *
+ * @param  bump        Bump option value.
+ * @param  packageName Package of the bump, for the error.
+ * @return The bump.
+ * @throws {ValidationError} For another value.
+ */
+function parseBump(bump, packageName) {
+    if (!CHANGESET_BUMPS.includes(bump)) {
+        const target = packageName ? ` for package "${packageName}"` : '';
+        throw new ValidationError(`Invalid bump "${bump}"${target}; expected patch, minor or major.`);
+    }
+    return bump;
+}
+/**
+ * Parse and validate the `changeset-add` options. Without --package, a
+ * single --bump applies to the changed packages without a changeset, and
+ * without --bump either the command asks for the changeset in a terminal.
  *
  * @param  values Parsed CLI options.
  * @return Normalized changeset input.
- * @throws {ValidationError} If required options are missing or conflicting.
+ * @throws {ValidationError} If options are conflicting or incomplete.
  */
 export function parseChangesetAddArgs(values) {
     const names = getStrings(values, 'package');
     const bumps = getStrings(values, 'bump');
     const summary = getString(values, 'summary')?.trim();
     const empty = getBoolean(values, 'empty');
+    const since = getString(values, 'since');
     const name = getString(values, 'name');
-    if (empty && (names.length || bumps.length || summary)) {
-        throw new ValidationError('--empty cannot be combined with --package, --bump or --summary.');
+    if (empty && (names.length || bumps.length || summary || since)) {
+        throw new ValidationError('--empty cannot be combined with --package, --bump, --summary or --since.');
     }
-    if (!empty && (!names.length || names.length !== bumps.length)) {
+    if (names.length && names.length !== bumps.length) {
         throw new ValidationError('Pass matching repeated --package <name> and --bump <patch|minor|major> options, or use --empty.');
     }
-    if (!empty && !summary) {
-        throw new ValidationError('--summary <text> is required unless --empty is set.');
+    if (!names.length && bumps.length > 1) {
+        throw new ValidationError('Pass a single --bump without --package to release the changed packages, or pair each --bump with a --package.');
+    }
+    if (names.length && undefined !== since) {
+        throw new ValidationError('--since selects the changed packages, so it cannot be combined with --package.');
+    }
+    if ('' === since?.trim()) {
+        throw new ValidationError('--since <ref> must not be empty.');
+    }
+    if (bumps.length && !summary) {
+        throw new ValidationError('--summary <text> is required with --bump.');
     }
     if (name && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
         throw new ValidationError('--name must contain only letters, numbers, dots, underscores or hyphens.');
     }
     const packages = {};
     names.forEach((packageName, index) => {
-        const bump = bumps[index];
         if (Object.hasOwn(packages, packageName)) {
             throw new ValidationError(`Package "${packageName}" was passed more than once.`);
         }
-        if (!CHANGESET_BUMPS.includes(bump)) {
-            throw new ValidationError(`Invalid bump "${bump}" for package "${packageName}"; expected patch, minor or major.`);
-        }
-        packages[packageName] = bump;
+        packages[packageName] = parseBump(bumps[index] ?? '', packageName);
     });
     return {
         packages,
-        summary: summary ?? '',
         empty,
+        ...(!names.length && bumps.length
+            ? { bump: parseBump(bumps[0] ?? '') }
+            : {}),
+        ...(summary ? { summary } : {}),
+        ...(since ? { since } : {}),
         ...(name ? { name } : {}),
     };
 }
@@ -76,6 +104,8 @@ export const changesetVersionArgs = {
     date: { type: 'string' },
     package: { type: 'string', multiple: true },
     'no-dependents': { type: 'boolean' },
+    prerelease: { type: 'string' },
+    snapshot: { type: 'string' },
 };
 /**
  * Validate and normalize a release date option.
@@ -102,19 +132,32 @@ export function parseChangesetDate(value) {
  *
  * @param  values Parsed CLI options.
  * @return Normalized versioning input.
- * @throws {ValidationError} If --date is invalid.
+ * @throws {ValidationError} If --date is invalid, or an option is empty or conflicting.
  */
 export function parseChangesetVersionArgs(values) {
     const date = parseChangesetDate(getString(values, 'date'));
     const packages = getStrings(values, 'package');
+    const prerelease = getString(values, 'prerelease')?.trim();
     if (packages.some((name) => !name.trim())) {
         throw new ValidationError('--package <name> must not be empty.');
     }
+    const snapshot = getString(values, 'snapshot')?.trim();
+    if ('' === prerelease) {
+        throw new ValidationError('--prerelease <id> must not be empty.');
+    }
+    if ('' === snapshot) {
+        throw new ValidationError('--snapshot <id> must not be empty.');
+    }
+    if (prerelease && snapshot) {
+        throw new ValidationError('--prerelease cannot be combined with --snapshot.');
+    }
     return {
         dryRun: getBoolean(values, 'dry-run'),
         dependents: !getBoolean(values, 'no-dependents'),
         ...(date ? { date } : {}),
         ...(packages.length ? { packages } : {}),
+        ...(prerelease ? { prerelease } : {}),
+        ...(snapshot ? { snapshot } : {}),
     };
 }
 /** Parse-args options for `changeset-tag`. */

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

@@ -1,4 +1,5 @@
 export interface ChangesetStatusResult {
+    since?: string;
     changesets: Array<{
         fileName: string;
         packages: Record<string, string>;
@@ -34,6 +35,7 @@ declare const _default: {
                 currentVersion: string;
                 nextVersion: string;
             }[];
+            since?: string;
             changesets: import("../changesets.ts").Changeset[];
             changedPackages: string[];
             changedPackageFiles: Record<string, string[]>;

package/dist/commands/changeset-tag.js

@@ -10,7 +10,8 @@ export default {
                          creating them
   --untagged             List only releases without a tag, without creating tags
   --since <ref>          Tag packages changed since this git ref
-  --package <name>       Tag only this package (repeatable)
+  --package <name>       Tag only this package, by identifier or path under
+                         the configured root (repeatable)
   --version <version>    Fail unless the single --package is at this version;
                          the version to tag for packages versioned by git tags
   --push                 Push newly created tags to origin, one at a time

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

@@ -29,6 +29,12 @@ declare const _default: {
         readonly 'no-dependents': {
             readonly type: "boolean";
         };
+        readonly prerelease: {
+            readonly type: "string";
+        };
+        readonly snapshot: {
+            readonly type: "string";
+        };
     };
     run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
         exitCode: number;

package/dist/commands/changeset-version.js

@@ -3,18 +3,30 @@ import { getChangesetVersionSummary } from "../summary.js";
 import { parseChangesetVersionArgs, changesetVersionArgs, } from "./changeset-args.js";
 export default {
     name: 'changeset-version',
-    usage: 'changeset-version [--dry-run] [--date <YYYY-MM-DD>] [--package <name>] [--no-dependents]',
+    usage: 'changeset-version [--dry-run] [--date <YYYY-MM-DD>] [--package <name>] [--no-dependents] [--prerelease <id> | --snapshot <id>]',
     summary: 'Apply pending version bumps and changelog entries.',
     help: `Options:
   --dry-run              Print the release plan without writing files
   --date <YYYY-MM-DD>    Changelog date (default: today)
-  --package <name>       Version only this package (repeatable)
+  --package <name>       Version only this package, by identifier or path
+                         under the configured root (repeatable)
   --no-dependents        Leave the configured dependents of the selected sources out
+  --prerelease <id>      Release pre-releases like 1.3.0-rc.1, with an identifier
+                         like rc (numbered from the tags) or rc.1
+  --snapshot <id>        Release snapshots like 1.3.0-pr-251.20261012183000,
+                         with an identifier like pr-251 and the UTC time
 
 Updates configured version files, prepends changelog entries and removes the
 applied changeset files. With --package, a changeset that also names other
 packages keeps only their entries, so it still applies to their releases, and
-changesets without packages are left for a run without --package.`,
+changesets without packages are left for a run without --package.
+
+With --prerelease, run it on a branch that isn't merged and tag that branch,
+since the pre-release consumes the changesets that the stable release needs.
+The readme Stable tag keeps the last stable version.
+
+With --snapshot, build and publish the versioned files without committing
+them, for example to test a pull request.`,
     options: changesetVersionArgs,
     async run({ values, cwd, configFile, logger }) {
         const args = parseChangesetVersionArgs(values);

package/dist/commands/command.d.ts

@@ -1,4 +1,5 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
+import type { PromptTerminal } from '../changeset-prompt.ts';
 import type { Logger } from '../logger.ts';
 /**
  * Parsed option values from node:util parseArgs().
@@ -15,6 +16,8 @@ export interface CommandContext {
     configFile?: string;
     /** Logger for the command output. */
     logger: Logger;
+    /** Terminal for interactive prompts, only when the CLI runs in one and prints no JSON. */
+    terminal?: PromptTerminal;
 }
 export interface CommandOutcome<Result = unknown> {
     /** Process exit code. */

package/dist/commands/deploy-git.d.ts

@@ -15,12 +15,22 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
-        message: {
-            type: "string";
-        };
         'dry-run': {
             type: "boolean";
         };
+        'release-ref': {
+            readonly type: "string";
+        };
+        package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        list: {
+            readonly type: "boolean";
+        };
+        message: {
+            type: "string";
+        };
         'git-url': {
             type: "string";
         };
@@ -37,7 +47,17 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, logger }: import("./command.ts").CommandContext): Promise<{
+    run({ values, positionals, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            packages: import("../package-deploy.ts").PackageDeployPlanItem[];
+        };
+    } | {
+        exitCode: number;
+        result: {
+            deploys: import("./package-deploys.ts").PackageDeployOutcome<import("../git-deploy.ts").GitDeployResult>[];
+        };
+    } | {
         exitCode: number;
         result: import("../git-deploy.ts").GitDeployResult;
     }>;

package/dist/commands/deploy-git.js

@@ -1,6 +1,22 @@
 import { GitDeploy, resolveGitDeployOptions } from "../git-deploy.js";
+import { getGitDeploys } from "../package-deploy.js";
 import { fileSelectionArgs, getFileSelectionInput, getSourceDirArg, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
+import { getPackageDeployArgs, listPackageDeploys, packageDeployArgs, runPackageDeploys, } from "./package-deploys.js";
+/** Options of a single deploy target, which --release-ref takes from the config. */
+const TARGET_FLAGS = [
+    'source-dir',
+    'git-url',
+    'branch',
+    'tag',
+    'split-prefix',
+    'source-ref',
+    'distignore',
+    'no-distignore',
+    'exclude',
+    'exclude-gitattributes',
+    'message',
+];
 /**
  * Map the parsed "deploy-git" arguments to resolveGitDeployOptions() input.
  *
@@ -25,7 +41,7 @@ export function getGitDeployInputFromArgs(values, positionals, cwd) {
 }
 export default {
     name: 'deploy-git',
-    usage: 'deploy-git [<source-dir>] --git-url <url> [options]',
+    usage: 'deploy-git [<source-dir>] --git-url <url> [options] | deploy-git --release-ref <ref> [--package <name>] [--list] [--dry-run]',
     summary: 'Deploy the files of a plugin, theme or package to a Git repository as a release commit.',
     help: `Arguments:
   <source-dir>            Directory with the files to release (default: .),
@@ -37,6 +53,17 @@ Writes (none by default):
   --tag <name>            Create this tag for the release, on top of --branch
                           or the default branch of the repository
 
+Configured packages (instead of the options above):
+  --release-ref <ref>     Deploy the packages that this ref releases to the Git
+                          targets in the config: the package of a release tag,
+                          like refs/tags/plugins/alpha/1.2.0, or every package
+                          for a branch, like refs/heads/main
+  --package <name>        Deploy only this package (repeatable), for example
+                          in a CI job for each package or to retry one
+  --list                  List the deploys without running them, with the
+                          deploys of each package as the result for --json
+                          and --github-output, for a CI matrix
+
 Options:
   --git-url <url>         Repository to deploy to
   --split-prefix <dir>    Use the history of this directory of the source
@@ -56,9 +83,21 @@ branch only moves forward, a release without changes isn't pushed again, an
 older build doesn't move a branch that has newer source history, a tag that
 already has the same files is reused, and a tag with other files
 fails with exit code 2 (delete it in the repository to release it again). The source directory must be inside a Git repository.
-Credentials come from git, like a token in the URL or an SSH key.
+Credentials come from git, like a credential helper or an SSH key. For an
+HTTPS repository on github.com, or on the host of GITHUB_SERVER_URL, the
+GITHUB_TOKEN environment variable is sent as an authorization header, so the
+token stays out of the URL.
+
+With --release-ref, each package deploys to every Git target of its
+deploy.git config, with the history of its directory, in one log group for
+each package, and a failed deploy doesn't stop the others but exits with 1. A release tag creates the tag of each target on top
+of its default branch, and a branch releases to the same branch.
 
 Examples:
+  wp-release deploy-git --release-ref "$GITHUB_REF"
+      Deploy the configured packages of a tag or branch push
+  wp-release deploy-git --release-ref refs/heads/main --list
+      Preview what a push to main deploys
   wp-release deploy-git build --git-url git@github.com:me/my-plugin-dist.git --branch main --tag 1.2.0
       Release a build to a distribution repository and tag it
   wp-release deploy-git packages/my-plugin --split-prefix packages/my-plugin --git-url … --branch main
@@ -72,9 +111,23 @@ Examples:
         'source-ref': { type: 'string' },
         ...fileSelectionArgs,
         message: { type: 'string' },
+        ...packageDeployArgs,
         'dry-run': { type: 'boolean' },
     },
-    async run({ values, positionals, cwd, logger }) {
+    async run({ values, positionals, cwd, configFile, logger }) {
+        const { ref, packages, list } = getPackageDeployArgs(values, positionals, TARGET_FLAGS);
+        if (ref) {
+            const deploys = await getGitDeploys({
+                cwd,
+                ref,
+                packages,
+                dryRun: getBoolean(values, 'dry-run'),
+                ...(configFile ? { configFile } : {}),
+            });
+            return list
+                ? listPackageDeploys(deploys, logger, ref)
+                : runPackageDeploys(deploys, (input) => new GitDeploy(resolveGitDeployOptions(input), logger).run(), logger, ref);
+        }
         const options = resolveGitDeployOptions(getGitDeployInputFromArgs(values, positionals, cwd));
         const result = await new GitDeploy(options, logger).run();
         return { exitCode: 0, result };

package/dist/commands/deploy-svn.d.ts

@@ -23,6 +23,19 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
+        'dry-run': {
+            type: "boolean";
+        };
+        'release-ref': {
+            readonly type: "string";
+        };
+        package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        list: {
+            readonly type: "boolean";
+        };
         'svn-url': {
             type: "string";
         };
@@ -35,9 +48,6 @@ declare const _default: {
         force: {
             type: "boolean";
         };
-        'dry-run': {
-            type: "boolean";
-        };
         trunk: {
             type: "boolean";
         };
@@ -66,7 +76,17 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, logger }: import("./command.ts").CommandContext): Promise<{
+    run({ values, positionals, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            packages: import("../package-deploy.ts").PackageDeployPlanItem[];
+        };
+    } | {
+        exitCode: number;
+        result: {
+            deploys: import("./package-deploys.ts").PackageDeployOutcome<import("../svn-deploy.ts").DeployResult>[];
+        };
+    } | {
         exitCode: number;
         result: import("../svn-deploy.ts").DeployResult;
     }>;

package/dist/commands/deploy-svn.js

@@ -1,7 +1,28 @@
 import { resolveDeployOptions } from "../deploy-options.js";
+import { getSvnDeploys } from "../package-deploy.js";
 import { SvnDeploy } from "../svn-deploy.js";
 import { fileSelectionArgs, getFileSelectionInput, getSourceDirArg, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
+import { getPackageDeployArgs, listPackageDeploys, packageDeployArgs, runPackageDeploys, } from "./package-deploys.js";
+/** Options of a single deploy, which --release-ref takes from the config. */
+const TARGET_FLAGS = [
+    'source-dir',
+    'trunk',
+    'readme-only',
+    'svn-tag',
+    'assets-dir',
+    'no-assets',
+    'slug',
+    'version',
+    'readme',
+    'from-zip',
+    'distignore',
+    'no-distignore',
+    'exclude',
+    'exclude-gitattributes',
+    'svn-url',
+    'message',
+];
 /**
  * Map the parsed "deploy-svn" arguments to resolveDeployOptions() input.
  * Flags that aren't passed stay undefined, so that the same defaults apply
@@ -35,7 +56,7 @@ export function getDeployInputFromArgs(input) {
 }
 export default {
     name: 'deploy-svn',
-    usage: 'deploy-svn [<source-dir>] [options]',
+    usage: 'deploy-svn [<source-dir>] [options] | deploy-svn --release-ref <ref> [--package <name>] [--list] [--dry-run]',
     summary: 'Deploy a plugin to the WordPress.org plugin SVN repository.',
     help: `Arguments:
   <source-dir>            Directory with the plugin files (default: .), also
@@ -51,6 +72,15 @@ Writes (none by default, assets only with --assets-dir):
                           screenshots to assets/
   --no-assets             Don't sync --assets-dir for this run
 
+Configured packages (instead of the writes and the source options):
+  --release-ref <ref>     Deploy the package that this release tag releases,
+                          like refs/tags/plugins/alpha/1.2.0, to the SVN
+                          targets in the config. Branches aren't deployed.
+  --package <name>        Deploy only this package (repeatable)
+  --list                  List the deploys without running them, with the
+                          deploys of each package as the result for --json
+                          and --github-output, for a CI matrix
+
 Options:
   --slug <slug>           Plugin slug (default: project directory name)
   --version <version>     Version to check (default: --svn-tag, then the Version header)
@@ -71,7 +101,13 @@ Options:
 Credentials are only needed to commit. Exits with 3 when they're missing
 or rejected.
 
+With --release-ref, a stable release syncs trunk/, creates its tag and syncs
+the assetsDir of each deploy.svn target, while a pre-release only creates its
+tag. A failed deploy doesn't stop the others and exits with 1.
+
 Examples:
+  wp-release deploy-svn --release-ref "$GITHUB_REF"
+      Deploy the configured plugin of a release tag push
   wp-release deploy-svn dist --trunk --svn-tag 1.2.0 --assets-dir .wordpress-org
       Deploy 1.2.0 to trunk and the tag, and update the assets
   wp-release deploy-svn dist --svn-tag 1.2.0-rc.1
@@ -96,9 +132,27 @@ Examples:
         'svn-username': { type: 'string' },
         message: { type: 'string' },
         force: { type: 'boolean' },
+        ...packageDeployArgs,
         'dry-run': { type: 'boolean' },
     },
-    async run({ values, positionals, cwd, logger }) {
+    async run({ values, positionals, cwd, configFile, logger }) {
+        const { ref, packages, list } = getPackageDeployArgs(values, positionals, TARGET_FLAGS);
+        if (ref) {
+            const deploys = await getSvnDeploys({
+                cwd,
+                ref,
+                packages,
+                dryRun: getBoolean(values, 'dry-run'),
+                ...(configFile ? { configFile } : {}),
+            });
+            return list
+                ? listPackageDeploys(deploys, logger, ref)
+                : runPackageDeploys(deploys, (input) => new SvnDeploy(resolveDeployOptions({
+                    ...input,
+                    svnUsername: getString(values, 'svn-username'),
+                    force: getBoolean(values, 'force'),
+                }), logger).run(), logger, ref);
+        }
         const options = resolveDeployOptions(getDeployInputFromArgs({ values, positionals, cwd }));
         const result = await new SvnDeploy(options, logger).run();
         return { exitCode: 0, result };

package/dist/commands/package-deploys.d.ts

@@ -0,0 +1,78 @@
+import type { Logger } from '../logger.ts';
+import type { PackageDeploy, PackageDeployPlanItem } from '../package-deploy.ts';
+import type { ParsedValues } from './command.ts';
+/**
+ * Options of the deploy commands that deploy the configured packages of a
+ * ref, in node:util parseArgs() format.
+ */
+export declare const packageDeployArgs: {
+    readonly 'release-ref': {
+        readonly type: "string";
+    };
+    readonly package: {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly list: {
+        readonly type: "boolean";
+    };
+};
+/** Result of one deploy of a configured package. */
+export interface PackageDeployOutcome<Result> {
+    package: string;
+    /** Package, target and ref, with credentials redacted. */
+    label: string;
+    version?: string;
+    branch?: string;
+    /** Deploy result, unless it failed. */
+    result?: Result;
+    /** Error message of a failed deploy. */
+    error?: string;
+}
+/**
+ * Get the ref and the packages to deploy from the config, failing for the
+ * options that set a single deploy target instead.
+ *
+ * @param  values      Parsed CLI values.
+ * @param  positionals Positional arguments.
+ * @param  targetFlags Options of a single deploy target.
+ * @return The ref and the selected packages.
+ * @throws {ValidationError} For --package without --release-ref, or a single target option with it.
+ */
+export declare function getPackageDeployArgs(values: ParsedValues, positionals: string[], targetFlags: string[]): {
+    ref?: string;
+    packages: string[];
+    list: boolean;
+};
+/**
+ * Run the deploys of the configured packages one at a time, in one log group
+ * for each package, continuing after a failed deploy so that one package or
+ * target doesn't block the others.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param deploy  Runs one deploy.
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 1 when a deploy failed, and the result of each deploy.
+ */
+export declare function runPackageDeploys<Input, Result>(deploys: PackageDeploy<Input>[], deploy: (input: Input) => Promise<Result>, logger: Logger, ref: string): Promise<{
+    exitCode: number;
+    result: {
+        deploys: PackageDeployOutcome<Result>[];
+    };
+}>;
+/**
+ * List the deploys of the configured packages without running them, one line
+ * for each deploy, with the plan as the result for --json and --github-output.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 0 and the deploys of each package.
+ */
+export declare function listPackageDeploys(deploys: PackageDeploy<unknown>[], logger: Logger, ref: string): {
+    exitCode: number;
+    result: {
+        packages: PackageDeployPlanItem[];
+    };
+};