nx 17.0.3 → 17.0.5

package/src/command-line/release/config/conventional-commits.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = void 0;
+exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = {
+    types: {
+        feat: {
+            semverBump: 'minor',
+            changelog: {
+                title: '🚀 Features',
+                hidden: false,
+            },
+        },
+        fix: {
+            semverBump: 'patch',
+            changelog: {
+                title: '🩹 Fixes',
+                hidden: false,
+            },
+        },
+        perf: {
+            semverBump: 'none',
+            changelog: {
+                title: '🔥 Performance',
+                hidden: false,
+            },
+        },
+        refactor: {
+            semverBump: 'none',
+            changelog: {
+                title: '💅 Refactors',
+                hidden: true,
+            },
+        },
+        docs: {
+            semverBump: 'none',
+            changelog: {
+                title: '📖 Documentation',
+                hidden: true,
+            },
+        },
+        build: {
+            semverBump: 'none',
+            changelog: {
+                title: '📦 Build',
+                hidden: true,
+            },
+        },
+        types: {
+            semverBump: 'none',
+            changelog: {
+                title: '🌊 Types',
+                hidden: true,
+            },
+        },
+        chore: {
+            semverBump: 'none',
+            changelog: {
+                title: '🏡 Chore',
+                hidden: true,
+            },
+        },
+        examples: {
+            semverBump: 'none',
+            changelog: {
+                title: '🏀 Examples',
+                hidden: true,
+            },
+        },
+        test: {
+            semverBump: 'none',
+            changelog: {
+                title: '✅ Tests',
+                hidden: true,
+            },
+        },
+        style: {
+            semverBump: 'none',
+            changelog: {
+                title: '🎨 Styles',
+                hidden: true,
+            },
+        },
+        ci: {
+            semverBump: 'none',
+            changelog: {
+                title: '🤖 CI',
+                hidden: true,
+            },
+        },
+        revert: {
+            semverBump: 'none',
+            changelog: {
+                title: '⏪ Revert',
+                hidden: true,
+            },
+        },
+    },
+};

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

@@ -1,6 +1,6 @@
 import { ProjectGraph } from '../../../config/project-graph';
 import { NxReleaseConfig } from './config';
-type ReleaseGroupWithName = NxReleaseConfig['groups'][string] & {
+export type ReleaseGroupWithName = NxReleaseConfig['groups'][string] & {
     name: string;
 };
 export declare function filterReleaseGroups(projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, projectsFilter?: string[], groupsFilter?: string[]): {
@@ -11,4 +11,3 @@ export declare function filterReleaseGroups(projectGraph: ProjectGraph, nxReleas
     releaseGroups: ReleaseGroupWithName[];
     releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>;
 };
-export {};

package/src/command-line/release/config/filter-release-groups.js

@@ -37,6 +37,12 @@ function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, grou
                 releaseGroupToFilteredProjects,
             };
         }
+        // Remove any non-matching projects from filteredProjectToReleaseGroup
+        for (const project of filteredProjectToReleaseGroup.keys()) {
+            if (!matchingProjectsForFilter.includes(project)) {
+                filteredProjectToReleaseGroup.delete(project);
+            }
+        }
         // Filter out any non-matching projects from the release group to filtered projects map
         for (const releaseGroup of releaseGroups) {
             releaseGroup.projects
@@ -60,11 +66,42 @@ function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, grou
                 };
             }
         }
+        /**
+         * If the user is filtering to a subset of projects, we need to make sure that they are all within release groups
+         * with "independent" configured for their projectsRelationship. If not, the filtering is invalid, and they should instead
+         * be targeting the release groups directly using the --group flag, or they should update their configuration to
+         * make the projects they were trying to filter be independently releasable.
+         */
+        const releaseGroupsForFilteredProjects = Array.from(new Set(Array.from(filteredProjectToReleaseGroup.values())));
+        const releaseGroupsThatAreNotIndependent = releaseGroupsForFilteredProjects.filter((rg) => rg.projectsRelationship !== 'independent');
+        if (releaseGroupsThatAreNotIndependent.length) {
+            // Special handling for IMPLICIT_DEFAULT_RELEASE_GROUP
+            if (releaseGroupsThatAreNotIndependent.length === 1 &&
+                releaseGroupsThatAreNotIndependent[0].name ===
+                    config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                return {
+                    error: {
+                        title: `In order to release specific projects independently with --projects those projects must be configured appropriately. For example, by setting \`"projectsRelationship": "independent"\` in your nx.json config.`,
+                        bodyLines: [],
+                    },
+                    releaseGroups: [],
+                    releaseGroupToFilteredProjects,
+                };
+            }
+            return {
+                error: {
+                    title: `Your --projects filter "${projectsFilter}" matched projects in the following release groups which do not have "independent" configured for their "projectsRelationship":`,
+                    bodyLines: releaseGroupsThatAreNotIndependent.map((rg) => `- ${rg.name}`),
+                },
+                releaseGroups: [],
+                releaseGroupToFilteredProjects,
+            };
+        }
         output_1.output.note({
             title: `Your filter "${projectsFilter}" matched the following projects:`,
             bodyLines: matchingProjectsForFilter.map((p) => {
                 const releaseGroupForProject = filteredProjectToReleaseGroup.get(p);
-                if (releaseGroupForProject.name === config_1.CATCH_ALL_RELEASE_GROUP) {
+                if (releaseGroupForProject.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
                     return `- ${p}`;
                 }
                 return `- ${p} (release group "${releaseGroupForProject.name}")`;

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

@@ -0,0 +1,16 @@
+/**
+ * @public
+ */
+export { releaseChangelog } from './changelog';
+/**
+ * @public
+ */
+export { releasePublish } from './publish';
+/**
+ * @public
+ */
+export { releaseVersion } from './version';
+/**
+ * @public
+ */
+export { release } from './release';

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.releaseVersion = exports.releasePublish = exports.releaseChangelog = void 0;
+/**
+ * @public
+ */
+var changelog_1 = require("./changelog");
+Object.defineProperty(exports, "releaseChangelog", { enumerable: true, get: function () { return changelog_1.releaseChangelog; } });
+/**
+ * @public
+ */
+var publish_1 = require("./publish");
+Object.defineProperty(exports, "releasePublish", { enumerable: true, get: function () { return publish_1.releasePublish; } });
+/**
+ * @public
+ */
+var version_1 = require("./version");
+Object.defineProperty(exports, "releaseVersion", { enumerable: true, get: function () { return version_1.releaseVersion; } });
+/**
+ * @public
+ */
+var release_1 = require("./release");
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });

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

@@ -1,4 +1,8 @@
 import { PublishOptions } from './command-object';
-export declare function publishHandler(args: PublishOptions & {
-    __overrides_unparsed__: string[];
-}): Promise<void>;
+export declare const releasePublishCLIHandler: (args: PublishOptions) => Promise<any>;
+/**
+ * NOTE: This function is also exported for programmatic usage and forms part of the public API
+ * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
+ * to have control over their own error handling when using the API.
+ */
+export declare function releasePublish(args: PublishOptions, isCLI?: boolean): Promise<number>;

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

@@ -1,53 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.publishHandler = void 0;
+exports.releasePublish = exports.releasePublishCLIHandler = void 0;
 const nx_json_1 = require("../../config/nx-json");
-const devkit_exports_1 = require("../../devkit-exports");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
 const project_graph_1 = require("../../project-graph/project-graph");
 const run_command_1 = require("../../tasks-runner/run-command");
 const command_line_utils_1 = require("../../utils/command-line-utils");
-const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const params_1 = require("../../utils/params");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
 const graph_1 = require("../graph/graph");
 const config_1 = require("./config/config");
 const filter_release_groups_1 = require("./config/filter-release-groups");
-async function publishHandler(args) {
+const releasePublishCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => releasePublish(args, true));
+exports.releasePublishCLIHandler = releasePublishCLIHandler;
+/**
+ * NOTE: This function is also exported for programmatic usage and forms part of the public API
+ * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
+ * to have control over their own error handling when using the API.
+ */
+async function releasePublish(args, isCLI = false) {
+    /**
+     * When used via the CLI, the args object will contain a __overrides_unparsed__ property that is
+     * important for invoking the relevant executor behind the scenes.
+     *
+     * We intentionally do not include that in the function signature, however, so as not to cause
+     * confusing errors for programmatic consumers of this function.
+     */
+    const _args = args;
     const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
     const nxJson = (0, nx_json_1.readNxJson)();
-    if (args.verbose) {
+    if (_args.verbose) {
         process.env.NX_VERBOSE_LOGGING = 'true';
     }
     // Apply default configuration to any optional user configuration
-    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, nxJson.release, 'nx-release-publish');
+    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), nxJson.release);
     if (configError) {
         return await (0, config_1.handleNxReleaseConfigError)(configError);
     }
-    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, _args.projects, _args.groups);
     if (filterError) {
-        devkit_exports_1.output.error(filterError);
+        output_1.output.error(filterError);
         process.exit(1);
     }
+    /**
+     * If the user is filtering to a subset of projects or groups, we should not run the publish task
+     * for dependencies, because that could cause projects outset of the filtered set to be published.
+     */
+    const shouldExcludeTaskDependencies = _args.projects?.length > 0 || _args.groups?.length > 0;
+    let overallExitStatus = 0;
     if (args.projects?.length) {
         /**
          * Run publishing for all remaining release groups and filtered projects within them
          */
         for (const releaseGroup of releaseGroups) {
-            await runPublishOnProjects(args, projectGraph, nxJson, Array.from(releaseGroupToFilteredProjects.get(releaseGroup)));
+            const status = await runPublishOnProjects(_args, projectGraph, nxJson, Array.from(releaseGroupToFilteredProjects.get(releaseGroup)), shouldExcludeTaskDependencies, isCLI);
+            if (status !== 0) {
+                overallExitStatus = status || 1;
+            }
         }
-        return process.exit(0);
+        return overallExitStatus;
     }
     /**
      * Run publishing for all remaining release groups
      */
     for (const releaseGroup of releaseGroups) {
-        await runPublishOnProjects(args, projectGraph, nxJson, releaseGroup.projects);
-    }
-    if (args.dryRun) {
-        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no projects were actually published.`);
+        const status = await runPublishOnProjects(_args, projectGraph, nxJson, releaseGroup.projects, shouldExcludeTaskDependencies, isCLI);
+        if (status !== 0) {
+            overallExitStatus = status || 1;
+        }
     }
-    process.exit(0);
+    return overallExitStatus;
 }
-exports.publishHandler = publishHandler;
-async function runPublishOnProjects(args, projectGraph, nxJson, projectNames) {
+exports.releasePublish = releasePublish;
+async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, shouldExcludeTaskDependencies, isCLI) {
     const projectsToRun = projectNames.map((projectName) => projectGraph.nodes[projectName]);
     const overrides = (0, command_line_utils_1.createOverrides)(args.__overrides_unparsed__);
     if (args.registry) {
@@ -56,40 +82,66 @@ async function runPublishOnProjects(args, projectGraph, nxJson, projectNames) {
     if (args.tag) {
         overrides.tag = args.tag;
     }
+    if (args.otp) {
+        overrides.otp = args.otp;
+    }
     if (args.dryRun) {
         overrides.dryRun = args.dryRun;
+        /**
+         * Ensure the env var is set too, so that any and all publish executors triggered
+         * indirectly via dependsOn can also pick up on the fact that this is a dry run.
+         */
+        process.env.NX_DRY_RUN = 'true';
     }
     if (args.verbose) {
         process.env.NX_VERBOSE_LOGGING = 'true';
     }
-    const targets = ['nx-release-publish'];
+    if (args.firstRelease) {
+        overrides.firstRelease = args.firstRelease;
+    }
+    const requiredTargetName = 'nx-release-publish';
     if (args.graph) {
         const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(args);
-        const projectNames = projectsToRun.map((t) => t.name);
-        return await (0, graph_1.generateGraph)({
+        const projectNamesWithTarget = projectsToRun
+            .map((t) => t.name)
+            .filter((projectName) => (0, project_graph_utils_1.projectHasTarget)(projectGraph.nodes[projectName], requiredTargetName));
+        await (0, graph_1.generateGraph)({
             watch: false,
             all: false,
             open: true,
             view: 'tasks',
-            targets,
-            projects: projectNames,
+            targets: [requiredTargetName],
+            projects: projectNamesWithTarget,
             file,
-        }, projectNames);
+        }, projectNamesWithTarget);
+        return 0;
     }
-    else {
-        /**
-         * Run the relevant nx-release-publish executor on each of the selected projects.
-         */
-        const status = await (0, run_command_1.runCommand)(projectsToRun, projectGraph, { nxJson }, {
-            targets,
-            outputStyle: 'static',
-            ...args,
-        }, overrides, null, {}, { excludeTaskDependencies: false, loadDotEnvFiles: true });
-        if (status !== 0) {
-            // fix for https://github.com/nrwl/nx/issues/1666
-            if (process.stdin['unref'])
-                process.stdin.unref();
-            process.exit(status);
+    const projectsWithTarget = projectsToRun.filter((project) => (0, project_graph_utils_1.projectHasTarget)(project, requiredTargetName));
+    if (projectsWithTarget.length === 0) {
+        throw new Error(`Based on your config, the following projects were matched for publishing but do not have the "${requiredTargetName}" target specified:\n${[
+            ...projectsToRun.map((p) => `- ${p.name}`),
+            '',
+            `This is usually caused by not having an appropriate plugin, such as "@nx/js" installed, which will add the appropriate "${requiredTargetName}" target for you automatically.`,
+        ].join('\n')}\n`);
+    }
+    /**
+     * Run the relevant nx-release-publish executor on each of the selected projects.
+     */
+    const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, {
+        targets: [requiredTargetName],
+        outputStyle: 'static',
+        ...args,
+    }, overrides, null, {}, {
+        excludeTaskDependencies: shouldExcludeTaskDependencies,
+        loadDotEnvFiles: true,
+    });
+    if (status !== 0) {
+        // In order to not add noise to the overall CLI output, do not throw an additional error
+        if (isCLI) {
+            return status;
         }
+        // Throw an additional error for programmatic API usage
+        throw new Error('One or more of the selected projects could not be published');
     }
+    return 0;
 }

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

@@ -0,0 +1,4 @@
+import { ReleaseOptions, VersionOptions } from './command-object';
+import { NxReleaseVersionResult } from './version';
+export declare const releaseCLIHandler: (args: VersionOptions) => Promise<any>;
+export declare function release(args: ReleaseOptions): Promise<NxReleaseVersionResult | number>;

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.releaseCLIHandler = void 0;
+const enquirer_1 = require("enquirer");
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const output_1 = require("../../utils/output");
+const params_1 = require("../../utils/params");
+const changelog_1 = require("./changelog");
+const config_1 = require("./config/config");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const publish_1 = require("./publish");
+const git_1 = require("./utils/git");
+const github_1 = require("./utils/github");
+const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
+const shared_1 = require("./utils/shared");
+const version_1 = require("./version");
+const releaseCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => release(args));
+exports.releaseCLIHandler = releaseCLIHandler;
+async function release(args) {
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const nxJson = (0, nx_json_1.readNxJson)();
+    if (args.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    const hasVersionGitConfig = Object.keys(nxJson.release?.version?.git ?? {}).length > 0;
+    const hasChangelogGitConfig = Object.keys(nxJson.release?.changelog?.git ?? {}).length > 0;
+    if (hasVersionGitConfig || hasChangelogGitConfig) {
+        const jsonConfigErrorPath = hasVersionGitConfig
+            ? ['release', 'version', 'git']
+            : ['release', 'changelog', 'git'];
+        const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)(jsonConfigErrorPath);
+        output_1.output.error({
+            title: `The "release" top level command cannot be used with granular git configuration. Instead, configure git options in the "release.git" property in nx.json, or use the version, changelog, and publish subcommands or programmatic API directly.`,
+            bodyLines: [nxJsonMessage],
+        });
+        process.exit(1);
+    }
+    // Apply default configuration to any optional user configuration
+    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), nxJson.release);
+    if (configError) {
+        return await (0, config_1.handleNxReleaseConfigError)(configError);
+    }
+    // These properties must never be undefined as this command should
+    // always explicitly override the git operations of the subcommands.
+    const shouldCommit = nxJson.release?.git?.commit ?? true;
+    const shouldStage = (shouldCommit || nxJson.release?.git?.stageChanges) ?? false;
+    const shouldTag = nxJson.release?.git?.tag ?? true;
+    const versionResult = await (0, version_1.releaseVersion)({
+        ...args,
+        stageChanges: shouldStage,
+        gitCommit: false,
+        gitTag: false,
+    });
+    const changelogResult = await (0, changelog_1.releaseChangelog)({
+        ...args,
+        versionData: versionResult.projectsVersionData,
+        version: versionResult.workspaceVersion,
+        stageChanges: shouldStage,
+        gitCommit: false,
+        gitTag: false,
+        createRelease: false,
+    });
+    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+    if (filterError) {
+        output_1.output.error(filterError);
+        process.exit(1);
+    }
+    if (shouldCommit) {
+        output_1.output.logSingleLine(`Committing changes with git`);
+        const commitMessage = nxReleaseConfig.git.commitMessage;
+        const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionResult.projectsVersionData, commitMessage);
+        await (0, git_1.gitCommit)({
+            messages: commitMessageValues,
+            additionalArgs: nxReleaseConfig.git.commitArgs,
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+    }
+    if (shouldTag) {
+        output_1.output.logSingleLine(`Tagging commit with git`);
+        // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
+        const gitTagValues = (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionResult.projectsVersionData);
+        (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+        for (const tag of gitTagValues) {
+            await (0, git_1.gitTag)({
+                tag,
+                message: nxReleaseConfig.git.tagMessage,
+                additionalArgs: nxReleaseConfig.git.tagArgs,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
+    }
+    const shouldCreateWorkspaceRelease = (0, changelog_1.shouldCreateGitHubRelease)(nxReleaseConfig.changelog.workspaceChangelog);
+    let hasPushedChanges = false;
+    let latestCommit;
+    if (shouldCreateWorkspaceRelease && changelogResult.workspaceChangelog) {
+        output_1.output.logSingleLine(`Pushing to git remote`);
+        // Before we can create/update the release we need to ensure the commit exists on the remote
+        await (0, git_1.gitPush)({
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+        hasPushedChanges = true;
+        output_1.output.logSingleLine(`Creating GitHub Release`);
+        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+        await (0, github_1.createOrUpdateGithubRelease)(changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+    }
+    for (const releaseGroup of releaseGroups) {
+        const shouldCreateProjectReleases = (0, changelog_1.shouldCreateGitHubRelease)(releaseGroup.changelog);
+        if (shouldCreateProjectReleases && changelogResult.projectChangelogs) {
+            const projects = args.projects?.length
+                ? // If the user has passed a list of projects, we need to use the filtered list of projects within the release group
+                    Array.from(releaseGroupToFilteredProjects.get(releaseGroup))
+                : // Otherwise, we use the full list of projects within the release group
+                    releaseGroup.projects;
+            const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+            for (const project of projectNodes) {
+                const changelog = changelogResult.projectChangelogs[project.name];
+                if (!changelog) {
+                    continue;
+                }
+                if (!hasPushedChanges) {
+                    output_1.output.logSingleLine(`Pushing to git remote`);
+                    // Before we can create/update the release we need to ensure the commit exists on the remote
+                    await (0, git_1.gitPush)({
+                        dryRun: args.dryRun,
+                        verbose: args.verbose,
+                    });
+                    hasPushedChanges = true;
+                }
+                output_1.output.logSingleLine(`Creating GitHub Release`);
+                if (!latestCommit) {
+                    latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                }
+                await (0, github_1.createOrUpdateGithubRelease)(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
+            }
+        }
+    }
+    let hasNewVersion = false;
+    // null means that all projects are versioned together but there were no changes
+    if (versionResult.workspaceVersion !== null) {
+        hasNewVersion = Object.values(versionResult.projectsVersionData).some((version) => version.newVersion !== null);
+    }
+    let shouldPublish = !!args.yes && !args.skipPublish && hasNewVersion;
+    const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun && hasNewVersion;
+    if (shouldPromptPublishing) {
+        shouldPublish = await promptForPublish();
+    }
+    if (shouldPublish) {
+        await (0, publish_1.releasePublish)(args);
+    }
+    else {
+        output_1.output.logSingleLine('Skipped publishing packages.');
+    }
+    return versionResult;
+}
+exports.release = release;
+async function promptForPublish() {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'confirmation',
+                message: 'Do you want to publish these versions?',
+                type: 'confirm',
+            },
+        ]);
+        return reply.confirmation;
+    }
+    catch (e) {
+        // Handle the case where the user exits the prompt with ctrl+c
+        return false;
+    }
+}

package/src/command-line/release/utils/batch-projects-by-generator-config.d.ts

@@ -0,0 +1,7 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+/**
+ * To be most efficient with our invocations of runVersionOnProjects, we want to batch projects by their generator and generator options
+ * within any given release group.
+ */
+export declare function batchProjectsByGeneratorConfig(projectGraph: ProjectGraph, releaseGroup: ReleaseGroupWithName, projectNamesToBatch: string[]): Map<string, string[]>;

package/src/command-line/release/utils/batch-projects-by-generator-config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchProjectsByGeneratorConfig = void 0;
+const json_diff_1 = require("../../../utils/json-diff");
+/**
+ * To be most efficient with our invocations of runVersionOnProjects, we want to batch projects by their generator and generator options
+ * within any given release group.
+ */
+function batchProjectsByGeneratorConfig(projectGraph, releaseGroup, projectNamesToBatch) {
+    const configBatches = new Map();
+    for (const projectName of projectNamesToBatch) {
+        const project = projectGraph.nodes[projectName];
+        const generator = project.data.release?.version?.generator ||
+            releaseGroup.version.generator;
+        const generatorOptions = {
+            ...releaseGroup.version.generatorOptions,
+            ...project.data.release?.version?.generatorOptions,
+        };
+        let found = false;
+        for (const [key, projects] of configBatches) {
+            const [existingGenerator, existingOptions] = JSON.parse(key);
+            if (generator === existingGenerator &&
+                (0, json_diff_1.deepEquals)(generatorOptions, existingOptions)) {
+                projects.push(projectName);
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            configBatches.set(JSON.stringify([generator, generatorOptions]), [
+                projectName,
+            ]);
+        }
+    }
+    return configBatches;
+}
+exports.batchProjectsByGeneratorConfig = batchProjectsByGeneratorConfig;

package/src/command-line/release/utils/exec-command.d.ts

@@ -0,0 +1 @@
+export declare function execCommand(cmd: string, args: string[], options?: any): Promise<string>;