nx 19.6.0-beta.2 → 19.6.0-beta.4

package/src/command-line/nx-commands.js

@@ -10,21 +10,22 @@ const command_object_4 = require("./graph/command-object");
 const command_object_5 = require("./exec/command-object");
 const command_object_6 = require("./format/command-object");
 const command_object_7 = require("./generate/command-object");
-const command_object_8 = require("./init/command-object");
-const command_object_9 = require("./list/command-object");
-const command_object_10 = require("./migrate/command-object");
-const command_object_11 = require("./new/command-object");
-const command_object_12 = require("./repair/command-object");
-const command_object_13 = require("./report/command-object");
-const command_object_14 = require("./run/command-object");
-const command_object_15 = require("./run-many/command-object");
-const command_object_16 = require("./show/command-object");
-const command_object_17 = require("./watch/command-object");
-const command_object_18 = require("./reset/command-object");
-const command_object_19 = require("./release/command-object");
-const command_object_20 = require("./add/command-object");
+const command_object_8 = require("./import/command-object");
+const command_object_9 = require("./init/command-object");
+const command_object_10 = require("./list/command-object");
+const command_object_11 = require("./migrate/command-object");
+const command_object_12 = require("./new/command-object");
+const command_object_13 = require("./repair/command-object");
+const command_object_14 = require("./report/command-object");
+const command_object_15 = require("./run/command-object");
+const command_object_16 = require("./run-many/command-object");
+const command_object_17 = require("./show/command-object");
+const command_object_18 = require("./watch/command-object");
+const command_object_19 = require("./reset/command-object");
+const command_object_20 = require("./release/command-object");
+const command_object_21 = require("./add/command-object");
 const command_objects_1 = require("./deprecated/command-objects");
-const command_object_21 = require("./sync/command-object");
+const command_object_22 = require("./sync/command-object");
 // Ensure that the output takes up the available width of the terminal.
 yargs.wrap(yargs.terminalWidth());
 exports.parserConfiguration = {
@@ -41,7 +42,7 @@ exports.commandsObject = yargs
     .parserConfiguration(exports.parserConfiguration)
     .usage(chalk.bold('Smart Monorepos · Fast CI'))
     .demandCommand(1, '')
-    .command(command_object_20.yargsAddCommand)
+    .command(command_object_21.yargsAddCommand)
     .command(command_object_1.yargsAffectedBuildCommand)
     .command(command_object_1.yargsAffectedCommand)
     .command(command_object_1.yargsAffectedE2ECommand)
@@ -55,24 +56,25 @@ exports.commandsObject = yargs
     .command(command_object_6.yargsFormatCheckCommand)
     .command(command_object_6.yargsFormatWriteCommand)
     .command(command_object_7.yargsGenerateCommand)
-    .command(command_object_8.yargsInitCommand)
-    .command(command_object_10.yargsInternalMigrateCommand)
-    .command(command_object_9.yargsListCommand)
-    .command(command_object_10.yargsMigrateCommand)
-    .command(command_object_11.yargsNewCommand)
+    .command(command_object_8.yargsImportCommand)
+    .command(command_object_9.yargsInitCommand)
+    .command(command_object_11.yargsInternalMigrateCommand)
+    .command(command_object_10.yargsListCommand)
+    .command(command_object_11.yargsMigrateCommand)
+    .command(command_object_12.yargsNewCommand)
     .command(command_objects_1.yargsPrintAffectedCommand)
-    .command(command_object_19.yargsReleaseCommand)
-    .command(command_object_12.yargsRepairCommand)
-    .command(command_object_13.yargsReportCommand)
-    .command(command_object_18.yargsResetCommand)
-    .command(command_object_14.yargsRunCommand)
-    .command(command_object_15.yargsRunManyCommand)
-    .command(command_object_16.yargsShowCommand)
-    .command(command_object_21.yargsSyncCommand)
-    .command(command_object_21.yargsSyncCheckCommand)
+    .command(command_object_20.yargsReleaseCommand)
+    .command(command_object_13.yargsRepairCommand)
+    .command(command_object_14.yargsReportCommand)
+    .command(command_object_19.yargsResetCommand)
+    .command(command_object_15.yargsRunCommand)
+    .command(command_object_16.yargsRunManyCommand)
+    .command(command_object_17.yargsShowCommand)
+    .command(command_object_22.yargsSyncCommand)
+    .command(command_object_22.yargsSyncCheckCommand)
     .command(command_object_2.yargsViewLogsCommand)
-    .command(command_object_17.yargsWatchCommand)
-    .command(command_object_14.yargsNxInfixCommand)
+    .command(command_object_18.yargsWatchCommand)
+    .command(command_object_15.yargsNxInfixCommand)
     .scriptName('nx')
     .help()
     // NOTE: we handle --version in nx.ts, this just tells yargs that the option exists

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

@@ -84,7 +84,7 @@ function createAPI(overrideReleaseConfig) {
             process.exit(1);
         }
         const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
         if (args.deleteVersionPlans === undefined) {
             // default to deleting version plans in this command instead of after versioning
             args.deleteVersionPlans = true;
@@ -140,12 +140,12 @@ function createAPI(overrideReleaseConfig) {
         // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
         let workspaceChangelogCommits = [];
         // If there are multiple release groups, we'll just skip the workspace changelog anyway.
-        const versionPlansEnabledForWorkspaceChangelog = releaseGroups[0].versionPlans;
+        const versionPlansEnabledForWorkspaceChangelog = releaseGroups[0].resolvedVersionPlans;
         if (versionPlansEnabledForWorkspaceChangelog) {
             if (releaseGroups.length === 1) {
                 const releaseGroup = releaseGroups[0];
                 if (releaseGroup.projectsRelationship === 'fixed') {
-                    const versionPlans = releaseGroup.versionPlans;
+                    const versionPlans = releaseGroup.resolvedVersionPlans;
                     workspaceChangelogChanges = versionPlans
                         .flatMap((vp) => {
                         const releaseType = versionPlanSemverReleaseTypeToChangelogType(vp.groupVersionBump);
@@ -296,8 +296,8 @@ function createAPI(overrideReleaseConfig) {
                     let changes = null;
                     // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
                     let commits;
-                    if (releaseGroup.versionPlans) {
-                        changes = releaseGroup.versionPlans
+                    if (releaseGroup.resolvedVersionPlans) {
+                        changes = releaseGroup.resolvedVersionPlans
                             .map((vp) => {
                             const bumpForProject = vp.projectVersionBumps[project.name];
                             if (!bumpForProject) {
@@ -396,8 +396,8 @@ function createAPI(overrideReleaseConfig) {
                 let changes = [];
                 // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
                 let commits = [];
-                if (releaseGroup.versionPlans) {
-                    changes = releaseGroup.versionPlans
+                if (releaseGroup.resolvedVersionPlans) {
+                    changes = releaseGroup.resolvedVersionPlans
                         .flatMap((vp) => {
                         const releaseType = versionPlanSemverReleaseTypeToChangelogType(vp.groupVersionBump);
                         const changes = !vp.triggeredByProjects
@@ -585,8 +585,8 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     if (args.deleteVersionPlans && !args.dryRun) {
         const planFiles = new Set();
         releaseGroups.forEach((group) => {
-            if (group.versionPlans) {
-                group.versionPlans.forEach((plan) => {
+            if (group.resolvedVersionPlans) {
+                group.resolvedVersionPlans.forEach((plan) => {
                     (0, fs_extra_1.removeSync)(plan.absolutePath);
                     planFiles.add(plan.relativePath);
                 });

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

@@ -1,12 +1,14 @@
 import { CommandModule } from 'yargs';
 import { OutputStyle, RunManyOptions } from '../yargs-utils/shared-options';
 import { VersionData } from './utils/shared';
-export interface NxReleaseArgs {
+export interface BaseNxReleaseArgs {
+    verbose?: boolean;
+    printConfig?: boolean | 'debug';
+}
+export interface NxReleaseArgs extends BaseNxReleaseArgs {
     groups?: string[];
     projects?: string[];
     dryRun?: boolean;
-    verbose?: boolean;
-    printConfig?: boolean | 'debug';
 }
 interface GitCommitAndTagOptions {
     stageChanges?: boolean;
@@ -43,6 +45,13 @@ export type PlanOptions = NxReleaseArgs & {
     bump?: string;
     message?: string;
 };
+export type PlanCheckOptions = BaseNxReleaseArgs & {
+    base?: string;
+    head?: string;
+    files?: string;
+    uncommitted?: boolean;
+    untracked?: boolean;
+};
 export type ReleaseOptions = NxReleaseArgs & FirstReleaseArgs & {
     yes?: boolean;
     skipPublish?: boolean;

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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsReleaseCommand = void 0;
 const yargs_1 = require("yargs");
 const nx_json_1 = require("../../config/nx-json");
+const command_line_utils_1 = require("../../utils/command-line-utils");
 const logger_1 = require("../../utils/logger");
 const shared_options_1 = require("../yargs-utils/shared-options");
-const command_line_utils_1 = require("../../utils/command-line-utils");
 exports.yargsReleaseCommand = {
     command: 'release',
     describe: 'Orchestrate versioning and publishing of applications and libraries',
@@ -15,6 +15,7 @@ exports.yargsReleaseCommand = {
         .command(changelogCommand)
         .command(publishCommand)
         .command(planCommand)
+        .command(planCheckCommand)
         .demandCommand()
         // Error on typos/mistyped CLI args, there is no reason to support arbitrary unknown args for these commands
         .strictOptions()
@@ -206,6 +207,7 @@ const publishCommand = {
 const planCommand = {
     command: 'plan [bump]',
     aliases: ['pl'],
+    // TODO: Remove this when docs are added
     // Create a plan to pick a new version and generate a changelog entry.
     // Hidden for now until the feature is more stable
     describe: false,
@@ -237,6 +239,19 @@ const planCommand = {
         process.exit(result);
     },
 };
+const planCheckCommand = {
+    command: 'plan:check',
+    // TODO: Remove this when docs are added
+    // Create a plan to pick a new version and generate a changelog entry.
+    // Hidden for now until the feature is more stable
+    describe: false,
+    builder: (yargs) => (0, shared_options_1.withAffectedOptions)(yargs),
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./plan-check'));
+        const result = await release.releasePlanCheckCLIHandler(args);
+        process.exit(result);
+    },
+};
 function coerceParallelOption(args) {
     return {
         ...args,

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

@@ -144,7 +144,8 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
                 ? defaultIndependentReleaseTagPattern
                 : defaultFixedReleaseTagPattern),
         conventionalCommits: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG,
-        versionPlans: false,
+        versionPlans: (userConfig.versionPlans ||
+            false),
     };
     const groupProjectsRelationship = userConfig.projectsRelationship || WORKSPACE_DEFAULTS.projectsRelationship;
     const GROUP_DEFAULTS = {
@@ -200,7 +201,8 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             git: userConfig.git,
         },
     ], normalizeTrueToEmptyObject(userConfig.changelog));
-    const rootVersionPlansConfig = userConfig.versionPlans ?? WORKSPACE_DEFAULTS.versionPlans;
+    const rootVersionPlansConfig = (userConfig.versionPlans ??
+        WORKSPACE_DEFAULTS.versionPlans);
     const rootConventionalCommitsConfig = deepMergeDefaults([WORKSPACE_DEFAULTS.conventionalCommits], fillUnspecifiedConventionalCommitsProperties(normalizeConventionalCommitsConfig(userConfig.conventionalCommits)));
     // these options are not supported at the group level, only the root/command level
     const rootVersionWithoutGlobalOptions = { ...rootVersionConfig };

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

@@ -1,9 +1,9 @@
 import { ProjectGraph } from '../../../config/project-graph';
 import { NxReleaseConfig } from './config';
 import { GroupVersionPlan, ProjectsVersionPlan } from './version-plans';
-export type ReleaseGroupWithName = Omit<NxReleaseConfig['groups'][string], 'versionPlans'> & {
+export type ReleaseGroupWithName = NxReleaseConfig['groups'][string] & {
     name: string;
-    versionPlans: (ProjectsVersionPlan | GroupVersionPlan)[] | false;
+    resolvedVersionPlans: (ProjectsVersionPlan | GroupVersionPlan)[] | false;
 };
 export declare function filterReleaseGroups(projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, projectsFilter?: string[], groupsFilter?: string[]): {
     error: null | {

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

@@ -9,7 +9,7 @@ function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, grou
         return {
             ...group,
             name,
-            versionPlans: group.versionPlans ? [] : false,
+            resolvedVersionPlans: group.versionPlans ? [] : false,
         };
     });
     const filteredProjectToReleaseGroup = new Map();

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

@@ -25,5 +25,5 @@ export interface ProjectsVersionPlan extends VersionPlan {
     projectVersionBumps: Record<string, ReleaseType>;
 }
 export declare function readRawVersionPlans(): Promise<RawVersionPlan[]>;
-export declare function setVersionPlansOnGroups(rawVersionPlans: RawVersionPlan[], releaseGroups: ReleaseGroupWithName[], allProjectNamesInWorkspace: string[]): ReleaseGroupWithName[];
+export declare function setResolvedVersionPlansOnGroups(rawVersionPlans: RawVersionPlan[], releaseGroups: ReleaseGroupWithName[], allProjectNamesInWorkspace: string[]): ReleaseGroupWithName[];
 export declare function getVersionPlansAbsolutePath(): string;

package/src/command-line/release/config/version-plans.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readRawVersionPlans = readRawVersionPlans;
-exports.setVersionPlansOnGroups = setVersionPlansOnGroups;
+exports.setResolvedVersionPlansOnGroups = setResolvedVersionPlansOnGroups;
 exports.getVersionPlansAbsolutePath = getVersionPlansAbsolutePath;
 const fs_1 = require("fs");
 const fs_extra_1 = require("fs-extra");
@@ -35,7 +35,7 @@ async function readRawVersionPlans() {
     }
     return versionPlans;
 }
-function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNamesInWorkspace) {
+function setResolvedVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNamesInWorkspace) {
     const groupsByName = releaseGroups.reduce((acc, group) => acc.set(group.name, group), new Map());
     const isDefaultGroup = isDefault(releaseGroups);
     for (const rawVersionPlan of rawVersionPlans) {
@@ -45,7 +45,7 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
         for (const [key, value] of Object.entries(rawVersionPlan.content)) {
             if (groupsByName.has(key)) {
                 const group = groupsByName.get(key);
-                if (!group.versionPlans) {
+                if (!group.resolvedVersionPlans) {
                     if (isDefaultGroup) {
                         throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
                     }
@@ -69,7 +69,7 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
                         throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of ${semver_1.RELEASE_TYPES.join(', ')}.`);
                     }
                 }
-                const existingPlan = (group.versionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                const existingPlan = (group.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
                 if (existingPlan) {
                     if (existingPlan.groupVersionBump !== value) {
                         if (isDefaultGroup) {
@@ -81,7 +81,7 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
                     }
                 }
                 else {
-                    group.versionPlans.push({
+                    group.resolvedVersionPlans.push({
                         absolutePath: rawVersionPlan.absolutePath,
                         relativePath: rawVersionPlan.relativePath,
                         fileName: rawVersionPlan.fileName,
@@ -104,7 +104,7 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
                         throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not in any configured release groups.`);
                     }
                 }
-                if (!groupForProject.versionPlans) {
+                if (!groupForProject.resolvedVersionPlans) {
                     if (isDefaultGroup) {
                         throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
                     }
@@ -116,12 +116,12 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
                     throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of ${semver_1.RELEASE_TYPES.join(', ')}.`);
                 }
                 if (groupForProject.projectsRelationship === 'independent') {
-                    const existingPlan = (groupForProject.versionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                    const existingPlan = (groupForProject.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
                     if (existingPlan) {
                         existingPlan.projectVersionBumps[key] = value;
                     }
                     else {
-                        groupForProject.versionPlans.push({
+                        groupForProject.resolvedVersionPlans.push({
                             absolutePath: rawVersionPlan.absolutePath,
                             relativePath: rawVersionPlan.relativePath,
                             fileName: rawVersionPlan.fileName,
@@ -134,7 +134,7 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
                     }
                 }
                 else {
-                    const existingPlan = (groupForProject.versionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                    const existingPlan = (groupForProject.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
                     // This can occur if the same fixed release group has multiple entries for different projects within
                     // the same version plan file. This will be the case when users are using the default release group.
                     if (existingPlan) {
@@ -151,7 +151,7 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
                         }
                     }
                     else {
-                        groupForProject.versionPlans.push({
+                        groupForProject.resolvedVersionPlans.push({
                             absolutePath: rawVersionPlan.absolutePath,
                             relativePath: rawVersionPlan.relativePath,
                             fileName: rawVersionPlan.fileName,
@@ -169,8 +169,8 @@ function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNames
     }
     // Order the plans from newest to oldest
     releaseGroups.forEach((group) => {
-        if (group.versionPlans) {
-            group.versionPlans.sort((a, b) => b.createdOnMs - a.createdOnMs);
+        if (group.resolvedVersionPlans) {
+            group.resolvedVersionPlans.sort((a, b) => b.createdOnMs - a.createdOnMs);
         }
     });
     return releaseGroups;

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

@@ -0,0 +1,4 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { PlanCheckOptions, PlanOptions } from './command-object';
+export declare const releasePlanCheckCLIHandler: (args: PlanCheckOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: PlanOptions) => Promise<number>;

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

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePlanCheckCLIHandler = void 0;
+exports.createAPI = createAPI;
+const nx_json_1 = require("../../config/nx-json");
+const workspace_projects_1 = require("../../project-graph/affected/locators/workspace-projects");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const file_utils_1 = require("../../project-graph/file-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const ignore_1 = require("../../utils/ignore");
+const output_1 = require("../../utils/output");
+const params_1 = require("../../utils/params");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
+const print_config_1 = require("./utils/print-config");
+const releasePlanCheckCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releasePlanCheckCLIHandler = releasePlanCheckCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    return async function releasePlanCheck(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        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, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        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 no release groups have version plans enabled, provide an explicit error
+        if (!releaseGroups.some((group) => group.versionPlans)) {
+            output_1.output.error({
+                title: 'Version plans are not enabled',
+                bodyLines: [
+                    'Please ensure at least one release group has version plans enabled in your Nx release configuration if you want to use this command.',
+                    // TODO: Add docs link here once it is available
+                ],
+            });
+            return 1;
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        // Resolve the final values for base, head etc to use when resolving the changes to consider
+        const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+            printWarnings: args.verbose,
+        }, nxJson);
+        const changedFiles = (0, command_line_utils_1.parseFiles)(nxArgs).files;
+        if (nxArgs.verbose) {
+            if (changedFiles.length) {
+                output_1.output.log({
+                    title: `Changed files based on resolved "base" (${nxArgs.base}) and "head" (${nxArgs.head ?? 'HEAD'})`,
+                    bodyLines: changedFiles.map((file) => `  - ${file}`),
+                });
+            }
+            else {
+                output_1.output.warn({
+                    title: 'No changed files found based on resolved "base" and "head"',
+                });
+            }
+        }
+        const resolvedAllFileData = await (0, all_file_data_1.allFileData)();
+        /**
+         * Create a minimal subset of touched projects based on the configured ignore patterns, we only need
+         * to recompute when the ignorePatternsForPlanCheck differs between release groups.
+         */
+        const serializedIgnorePatternsToTouchedProjects = new Map();
+        const NOTE_ABOUT_VERBOSE_LOGGING = 'Run with --verbose to see the full list of changed files used for the touched projects logic.';
+        let hasErrors = false;
+        for (const releaseGroup of releaseGroups) {
+            // The current release group doesn't leverage version plans
+            if (!releaseGroup.versionPlans) {
+                continue;
+            }
+            const resolvedVersionPlans = releaseGroup.resolvedVersionPlans || [];
+            // Check upfront if the release group as a whole is featured in any version plan files
+            const matchingVersionPlanFiles = resolvedVersionPlans.filter((plan) => 'groupVersionBump' in plan);
+            if (matchingVersionPlanFiles.length) {
+                output_1.output.log({
+                    title: `${releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? `There are`
+                        : `Release group "${releaseGroup.name}" has`} pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...matchingVersionPlanFiles.map((plan) => `  - "${plan.groupVersionBump}" in ${plan.fileName}`),
+                    ],
+                });
+                continue;
+            }
+            // Exclude patterns from .nxignore, .gitignore and explicit version plan config
+            let serializedIgnorePatterns = '[]';
+            const ignore = (0, ignore_1.getIgnoreObject)();
+            if (typeof releaseGroup.versionPlans !== 'boolean' &&
+                Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                releaseGroup.versionPlans.ignorePatternsForPlanCheck.length) {
+                output_1.output.note({
+                    title: `Applying configured ignore patterns to changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` for release group "${releaseGroup.name}"`
+                        : ''}`,
+                    bodyLines: [
+                        ...releaseGroup.versionPlans.ignorePatternsForPlanCheck.map((pattern) => `  - ${pattern}`),
+                    ],
+                });
+                ignore.add(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+                serializedIgnorePatterns = JSON.stringify(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+            }
+            let touchedProjects = {};
+            if (serializedIgnorePatternsToTouchedProjects.has(serializedIgnorePatterns)) {
+                touchedProjects = serializedIgnorePatternsToTouchedProjects.get(serializedIgnorePatterns);
+            }
+            else {
+                // We only care about directly touched projects, not implicitly affected ones etc
+                const touchedProjectsArr = await (0, workspace_projects_1.getTouchedProjects)((0, file_utils_1.calculateFileChanges)(changedFiles, resolvedAllFileData, nxArgs, undefined, ignore), projectGraph.nodes);
+                touchedProjects = touchedProjectsArr.reduce((acc, project) => ({ ...acc, [project]: true }), {});
+                serializedIgnorePatternsToTouchedProjects.set(serializedIgnorePatterns, touchedProjects);
+            }
+            const touchedProjectsUnderReleaseGroup = releaseGroup.projects.filter((project) => touchedProjects[project]);
+            if (touchedProjectsUnderReleaseGroup.length) {
+                output_1.output.log({
+                    title: `Touched projects based on changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''}`,
+                    bodyLines: [
+                        ...touchedProjectsUnderReleaseGroup.map((project) => `  - ${project}`),
+                        '',
+                        'NOTE: You can adjust your "versionPlans.ignorePatternsForPlanCheck" config to stop certain files from resulting in projects being classed as touched for the purposes of this command.',
+                    ],
+                });
+            }
+            else {
+                output_1.output.log({
+                    title: `No touched projects found based on changed files${typeof releaseGroup.versionPlans !== 'boolean' &&
+                        Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                        releaseGroup.versionPlans.ignorePatternsForPlanCheck.length
+                        ? ' combined with configured ignore patterns'
+                        : ''}${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''}`,
+                });
+            }
+            const projectsInResolvedVersionPlans = resolvedVersionPlans.reduce((acc, plan) => {
+                if ('projectVersionBumps' in plan) {
+                    for (const project in plan.projectVersionBumps) {
+                        acc[project] = acc[project] || [];
+                        acc[project].push({
+                            bump: plan.projectVersionBumps[project],
+                            fileName: plan.fileName,
+                        });
+                    }
+                }
+                return acc;
+            }, {});
+            // Ensure each touched project under this release group features in at least one version plan file
+            let touchedProjectsNotFoundInVersionPlans = [];
+            for (const touchedProject of touchedProjectsUnderReleaseGroup) {
+                if (!resolvedVersionPlans.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+                const matchingVersionPlanFileEntries = projectsInResolvedVersionPlans[touchedProject];
+                if (!matchingVersionPlanFileEntries?.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+            }
+            // Log any resolved pending bumps, regardless of whether the projects were directly touched or not
+            for (const [projectName, entries] of Object.entries(projectsInResolvedVersionPlans)) {
+                output_1.output.log({
+                    title: `Project "${projectName}" has pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...entries.map(({ bump, fileName }) => `  - "${bump}" in ${fileName}`),
+                    ],
+                });
+            }
+            if (touchedProjectsNotFoundInVersionPlans.length) {
+                const bodyLines = [
+                    `The following touched projects${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''} do not feature in any version plan files:`,
+                    ...touchedProjectsNotFoundInVersionPlans.map((project) => `  - ${project}`),
+                    '',
+                    'Please use `nx release plan` to generate missing version plans, or adjust your "versionPlans.ignorePatternsForPlanCheck" config stop certain files from affecting the projects for the purposes of this command.',
+                ];
+                if (!nxArgs.verbose) {
+                    bodyLines.push('', NOTE_ABOUT_VERBOSE_LOGGING);
+                }
+                output_1.output.error({
+                    title: 'Touched projects missing version plans',
+                    bodyLines,
+                });
+                // At least one project in one release group has an issue
+                hasErrors = true;
+            }
+        }
+        // Do not print success message if any projects are missing version plans
+        if (hasErrors) {
+            return 1;
+        }
+        const bodyLines = [];
+        if (!nxArgs.verbose) {
+            bodyLines.push(NOTE_ABOUT_VERBOSE_LOGGING);
+        }
+        output_1.output.success({
+            title: 'All touched projects have, or do not require, version plans.',
+            bodyLines,
+        });
+        return 0;
+    };
+}

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

@@ -31,7 +31,7 @@ function createAPI(overrideReleaseConfig) {
             process.env.NX_VERBOSE_LOGGING = 'true';
         }
         // 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);
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
         if (configError) {
             return await (0, config_1.handleNxReleaseConfigError)(configError);
         }

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

@@ -88,17 +88,17 @@ function createAPI(overrideReleaseConfig) {
             process.exit(1);
         }
         const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
         const planFiles = new Set();
         releaseGroups.forEach((group) => {
-            if (group.versionPlans) {
+            if (group.resolvedVersionPlans) {
                 if (group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
                     output_1.output.logSingleLine(`Removing version plan files`);
                 }
                 else {
                     output_1.output.logSingleLine(`Removing version plan files for group ${group.name}`);
                 }
-                group.versionPlans.forEach((plan) => {
+                group.resolvedVersionPlans.forEach((plan) => {
                     if (!args.dryRun) {
                         (0, fs_extra_1.removeSync)(plan.absolutePath);
                         if (args.verbose) {