nx 17.0.3 → 17.0.5

package/src/command-line/release/command-object.d.ts

@@ -1,25 +1,47 @@
 import { CommandModule } from 'yargs';
-import { RunManyOptions } from '../yargs-utils/shared-options';
+import { OutputStyle, RunManyOptions } from '../yargs-utils/shared-options';
+import { VersionData } from './utils/shared';
 export interface NxReleaseArgs {
     groups?: string[];
     projects?: string[];
     dryRun?: boolean;
     verbose?: boolean;
+    firstRelease?: boolean;
 }
-export type VersionOptions = NxReleaseArgs & {
+interface GitCommitAndTagOptions {
+    stageChanges?: boolean;
+    gitCommit?: boolean;
+    gitCommitMessage?: string;
+    gitCommitArgs?: string;
+    gitTag?: boolean;
+    gitTagMessage?: string;
+    gitTagArgs?: string;
+}
+export type VersionOptions = NxReleaseArgs & GitCommitAndTagOptions & {
     specifier?: string;
     preid?: string;
+    stageChanges?: boolean;
+    generatorOptionsOverrides?: Record<string, unknown>;
 };
-export type ChangelogOptions = NxReleaseArgs & {
-    version: string;
-    to: string;
+export type ChangelogOptions = NxReleaseArgs & GitCommitAndTagOptions & {
+    version?: string | null;
+    versionData?: VersionData;
+    to?: string;
     from?: string;
     interactive?: string;
     gitRemote?: string;
-    tagVersionPrefix?: string;
+    createRelease?: false | 'github';
 };
-export type PublishOptions = NxReleaseArgs & RunManyOptions & {
+export type PublishOptions = NxReleaseArgs & Partial<RunManyOptions> & {
+    outputStyle?: OutputStyle;
+} & {
     registry?: string;
     tag?: string;
+    otp?: number;
+};
+export type ReleaseOptions = NxReleaseArgs & {
+    yes?: boolean;
+    skipPublish?: boolean;
 };
 export declare const yargsReleaseCommand: CommandModule<Record<string, unknown>, NxReleaseArgs>;
+export {};

package/src/command-line/release/command-object.js

@@ -3,15 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsReleaseCommand = void 0;
 const yargs_1 = require("yargs");
 const file_utils_1 = require("../../project-graph/file-utils");
+const logger_1 = require("../../utils/logger");
 const shared_options_1 = require("../yargs-utils/shared-options");
 exports.yargsReleaseCommand = {
     command: 'release',
-    describe: '**ALPHA**: Orchestrate versioning and publishing of applications and libraries',
+    describe: 'Orchestrate versioning and publishing of applications and libraries',
     builder: (yargs) => yargs
+        .command(releaseCommand)
         .command(versionCommand)
         .command(changelogCommand)
         .command(publishCommand)
         .demandCommand()
+        // Error on typos/mistyped CLI args, there is no reason to support arbitrary unknown args for these commands
+        .strictOptions()
         .option('groups', {
         description: 'One or more release groups to target with the current command.',
         type: 'string',
@@ -24,7 +28,7 @@ exports.yargsReleaseCommand = {
         coerce: shared_options_1.parseCSV,
         describe: 'Projects to run. (comma/space delimited project names and/or patterns)',
     })
-        .option('dryRun', {
+        .option('dry-run', {
         describe: 'Preview the changes without updating files/creating releases',
         alias: 'd',
         type: 'boolean',
@@ -33,6 +37,10 @@ exports.yargsReleaseCommand = {
         .option('verbose', {
         type: 'boolean',
         describe: 'Prints additional information about the commands (e.g., stack traces)',
+    })
+        .option('first-release', {
+        type: 'boolean',
+        description: 'Indicates that this is the first release for the selected release group. If the current version cannot be determined as usual, the version on disk will be used as a fallback. This is useful when using git or the registry to determine the current version of packages, since those sources are only available after the first release. Also indicates that changelog generation should not assume a previous git tag exists and that publishing should not check for the existence of the package before running.',
     })
         .check((argv) => {
         if (argv.groups && argv.projects) {
@@ -47,17 +55,52 @@ exports.yargsReleaseCommand = {
             }
         }
         return true;
-    }),
+    }), // the type: 'string' and coerce: parseCSV combo isn't enough to produce the string[] type for projects and groups
     handler: async () => {
         (0, yargs_1.showHelp)();
         process.exit(1);
     },
 };
+const releaseCommand = {
+    command: '$0 [specifier]',
+    describe: 'Create a version and release for the workspace, generate a changelog, and optionally publish the packages',
+    builder: (yargs) => yargs
+        .positional('specifier', {
+        type: 'string',
+        describe: 'Exact version or semver keyword to apply to the selected release group.',
+    })
+        .option('yes', {
+        type: 'boolean',
+        alias: 'y',
+        description: 'Automatically answer yes to the confirmation prompt for publishing',
+    })
+        .option('skip-publish', {
+        type: 'boolean',
+        description: 'Skip publishing by automatically answering no to the confirmation prompt for publishing',
+    })
+        .check((argv) => {
+        if (argv.yes !== undefined && argv.skipPublish !== undefined) {
+            throw new Error('The --yes and --skip-publish options are mutually exclusive, please use one or the other.');
+        }
+        return true;
+    }),
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./release'));
+        const result = await release.releaseCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        if (typeof result === 'number') {
+            process.exit(result);
+        }
+        process.exit(0);
+    },
+};
 const versionCommand = {
     command: 'version [specifier]',
     aliases: ['v'],
     describe: 'Create a version and release for one or more applications and libraries',
-    builder: (yargs) => yargs
+    builder: (yargs) => withGitCommitAndGitTagOptions(yargs
         .positional('specifier', {
         type: 'string',
         describe: 'Exact version or semver keyword to apply to the selected release group.',
@@ -66,14 +109,28 @@ const versionCommand = {
         type: 'string',
         describe: 'The optional prerelease identifier to apply to the version, in the case that specifier has been set to prerelease.',
         default: '',
-    }),
-    handler: (args) => Promise.resolve().then(() => require('./version')).then((m) => m.versionHandler(args)),
+    })
+        .option('stage-changes', {
+        type: 'boolean',
+        describe: 'Whether or not to stage the changes made by this command. Useful when combining this command with changelog generation.',
+    })),
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./version'));
+        const result = await release.releaseVersionCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        if (typeof result === 'number') {
+            process.exit(result);
+        }
+        process.exit(0);
+    },
 };
 const changelogCommand = {
     command: 'changelog [version]',
     aliases: ['c'],
     describe: 'Generate a changelog for one or more projects, and optionally push to Github',
-    builder: (yargs) => yargs
+    builder: (yargs) => withGitCommitAndGitTagOptions(yargs
         // Disable default meaning of yargs version for this command
         .version(false)
         .positional('version', {
@@ -95,26 +152,28 @@ const changelogCommand = {
         description: 'Interactively modify changelog markdown contents in your code editor before applying the changes. You can set it to be interactive for all changelogs, or only the workspace level, or only the project level',
         choices: ['all', 'workspace', 'projects'],
     })
-        .option('gitRemote', {
+        .option('git-remote', {
         type: 'string',
         description: 'Alternate git remote in the form {user}/{repo} on which to create the Github release (useful for testing)',
         default: 'origin',
-    })
-        .option('tagVersionPrefix', {
-        type: 'string',
-        description: 'Prefix to apply to the version when creating the Github release tag',
-        default: 'v',
     })
         .check((argv) => {
         if (!argv.version) {
-            throw new Error('A target version must be specified');
-        }
-        if (argv.file === false && argv.createRelease !== 'github') {
-            throw new Error('The --file option can only be set to false when --create-release is set to github.');
+            throw new Error('An explicit target version must be specified when using the changelog command directly');
         }
         return true;
-    }),
-    handler: (args) => Promise.resolve().then(() => require('./changelog')).then((m) => m.changelogHandler(args)),
+    })),
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./changelog'));
+        const result = await release.releaseChangelogCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        if (typeof result === 'number') {
+            process.exit(result);
+        }
+        process.exit(0);
+    },
 };
 const publishCommand = {
     command: 'publish',
@@ -128,8 +187,18 @@ const publishCommand = {
         .option('tag', {
         type: 'string',
         description: 'The distribution tag to apply to the published package',
+    })
+        .option('otp', {
+        type: 'number',
+        description: 'A one-time password for publishing to a registry that requires 2FA',
     }),
-    handler: (args) => Promise.resolve().then(() => require('./publish')).then((m) => m.publishHandler(coerceParallelOption((0, shared_options_1.withOverrides)(args, 2)))),
+    handler: async (args) => {
+        const status = await (await Promise.resolve().then(() => require('./publish'))).releasePublishCLIHandler(coerceParallelOption((0, shared_options_1.withOverrides)(args, 2)));
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        process.exit(status);
+    },
 };
 function coerceParallelOption(args) {
     if (args['parallel'] === 'false' || args['parallel'] === false) {
@@ -154,3 +223,34 @@ function coerceParallelOption(args) {
     }
     return args;
 }
+function withGitCommitAndGitTagOptions(yargs) {
+    return yargs
+        .option('git-commit', {
+        describe: 'Whether or not to automatically commit the changes made by this command',
+        type: 'boolean',
+    })
+        .option('git-commit-message', {
+        describe: 'Custom git commit message to use when committing the changes made by this command. {version} will be dynamically interpolated when performing fixed releases, interpolated tags will be appended to the commit body when performing independent releases.',
+        type: 'string',
+    })
+        .option('git-commit-args', {
+        describe: 'Additional arguments (added after the --message argument, which may or may not be customized with --git-commit-message) to pass to the `git commit` command invoked behind the scenes',
+        type: 'string',
+    })
+        .option('git-tag', {
+        describe: 'Whether or not to automatically tag the changes made by this command',
+        type: 'boolean',
+    })
+        .option('git-tag-message', {
+        describe: 'Custom git tag message to use when tagging the changes made by this command. This defaults to be the same value as the tag itself.',
+        type: 'string',
+    })
+        .option('git-tag-args', {
+        describe: 'Additional arguments to pass to the `git tag` command invoked behind the scenes',
+        type: 'string',
+    })
+        .option('stage-changes', {
+        describe: 'Whether or not to stage the changes made by this command. Always treated as true if git-commit is true.',
+        type: 'boolean',
+    });
+}

package/src/command-line/release/config/config.d.ts

@@ -1,18 +1,5 @@
-/**
- * `nx release` is a powerful feature which spans many possible use cases. The possible variations
- * of configuration are therefore quite complex, particularly when you consider release groups.
- *
- * We want to provide the best possible DX for users so that they can harness the power of `nx release`
- * most effectively, therefore we need to both provide sensible defaults for common scenarios (to avoid
- * verbose nx.json files wherever possible), and proactively handle potential sources of config issues
- * in more complex use-cases.
- *
- * This file is the source of truth for all `nx release` configuration reconciliation, including sensible
- * defaults and user overrides, as well as handling common errors, up front to produce a single, consistent,
- * and easy to consume config object for all the `nx release` command implementations.
- */
 import { NxJsonConfiguration } from '../../../config/nx-json';
-import { type ProjectGraph } from '../../../devkit-exports';
+import { ProjectFileMap, ProjectGraph } from '../../../config/project-graph';
 type DeepRequired<T> = Required<{
     [K in keyof T]: T[K] extends Required<T[K]> ? T[K] : DeepRequired<T[K]>;
 }>;
@@ -23,7 +10,21 @@ type EnsureProjectsArray<T> = {
         projects: string[];
     } : T[K];
 };
-export declare const CATCH_ALL_RELEASE_GROUP = "__default__";
+type RemoveTrueFromType<T> = T extends true ? never : T;
+type RemoveTrueFromProperties<T, K extends keyof T> = {
+    [P in keyof T]: P extends K ? RemoveTrueFromType<T[P]> : T[P];
+};
+type RemoveTrueFromPropertiesOnEach<T, K extends keyof T[keyof T]> = {
+    [U in keyof T]: RemoveTrueFromProperties<T[U], K>;
+};
+type RemoveBooleanFromType<T> = T extends boolean ? never : T;
+type RemoveBooleanFromProperties<T, K extends keyof T> = {
+    [P in keyof T]: P extends K ? RemoveBooleanFromType<T[P]> : T[P];
+};
+type RemoveBooleanFromPropertiesOnEach<T, K extends keyof T[keyof T]> = {
+    [U in keyof T]: RemoveBooleanFromProperties<T[U], K>;
+};
+export declare const IMPLICIT_DEFAULT_RELEASE_GROUP = "__default__";
 /**
  * Our source of truth is a deeply required variant of the user-facing config interface, so that command
  * implementations can be sure that properties will exist and do not need to repeat the same checks over
@@ -33,16 +34,20 @@ export declare const CATCH_ALL_RELEASE_GROUP = "__default__";
  * it easier to work with (the user could be specifying a single string, and they can also use any valid matcher
  * pattern such as directories and globs).
  */
-export type NxReleaseConfig = DeepRequired<NxJsonConfiguration['release'] & {
-    groups: DeepRequired<EnsureProjectsArray<NxJsonConfiguration['release']['groups']>>;
-}>;
+export type NxReleaseConfig = Omit<DeepRequired<NxJsonConfiguration['release'] & {
+    groups: DeepRequired<RemoveTrueFromPropertiesOnEach<EnsureProjectsArray<NxJsonConfiguration['release']['groups']>, 'changelog'>>;
+    changelog: RemoveTrueFromProperties<DeepRequired<NxJsonConfiguration['release']['changelog']>, 'workspaceChangelog' | 'projectChangelogs'>;
+    conventionalCommits: {
+        types: RemoveBooleanFromPropertiesOnEach<DeepRequired<RemoveBooleanFromProperties<DeepRequired<NxJsonConfiguration['release']['conventionalCommits']['types']>, string>>, 'changelog'>;
+    };
+}>, 'projects'>;
 export interface CreateNxReleaseConfigError {
-    code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'PROJECTS_MISSING_TARGET';
+    code: 'PROJECTS_AND_GROUPS_DEFINED' | 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'CONVENTIONAL_COMMITS_SHORTHAND_MIXED_WITH_OVERLAPPING_GENERATOR_OPTIONS' | 'GLOBAL_GIT_CONFIG_MIXED_WITH_GRANULAR_GIT_CONFIG';
     data: Record<string, string | string[]>;
 }
-export declare function createNxReleaseConfig(projectGraph: ProjectGraph, userConfig?: NxJsonConfiguration['release'], requiredTargetName?: 'nx-release-publish'): Promise<{
+export declare function createNxReleaseConfig(projectGraph: ProjectGraph, projectFileMap: ProjectFileMap, userConfig?: NxJsonConfiguration['release']): Promise<{
     error: null | CreateNxReleaseConfigError;
     nxReleaseConfig: NxReleaseConfig | null;
 }>;
-export declare function handleNxReleaseConfigError(error: CreateNxReleaseConfigError): Promise<void>;
+export declare function handleNxReleaseConfigError(error: CreateNxReleaseConfigError): Promise<never>;
 export {};