nx 19.6.0-beta.2 → 19.6.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.6.0-beta.2",
+  "version": "19.6.0-beta.3",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -71,7 +71,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.6.0-beta.2"
+    "@nrwl/tao": "19.6.0-beta.3"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.6.0-beta.2",
-    "@nx/nx-darwin-arm64": "19.6.0-beta.2",
-    "@nx/nx-linux-x64-gnu": "19.6.0-beta.2",
-    "@nx/nx-linux-x64-musl": "19.6.0-beta.2",
-    "@nx/nx-win32-x64-msvc": "19.6.0-beta.2",
-    "@nx/nx-linux-arm64-gnu": "19.6.0-beta.2",
-    "@nx/nx-linux-arm64-musl": "19.6.0-beta.2",
-    "@nx/nx-linux-arm-gnueabihf": "19.6.0-beta.2",
-    "@nx/nx-win32-arm64-msvc": "19.6.0-beta.2",
-    "@nx/nx-freebsd-x64": "19.6.0-beta.2"
+    "@nx/nx-darwin-x64": "19.6.0-beta.3",
+    "@nx/nx-darwin-arm64": "19.6.0-beta.3",
+    "@nx/nx-linux-x64-gnu": "19.6.0-beta.3",
+    "@nx/nx-linux-x64-musl": "19.6.0-beta.3",
+    "@nx/nx-win32-x64-msvc": "19.6.0-beta.3",
+    "@nx/nx-linux-arm64-gnu": "19.6.0-beta.3",
+    "@nx/nx-linux-arm64-musl": "19.6.0-beta.3",
+    "@nx/nx-linux-arm-gnueabihf": "19.6.0-beta.3",
+    "@nx/nx-win32-arm64-msvc": "19.6.0-beta.3",
+    "@nx/nx-freebsd-x64": "19.6.0-beta.3"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/schemas/nx-schema.json

@@ -186,8 +186,15 @@
                 "type": "string"
               },
               "versionPlans": {
-                "type": "boolean",
-                "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+                "oneOf": [
+                  {
+                    "$ref": "#/definitions/NxReleaseVersionPlansConfiguration"
+                  },
+                  {
+                    "type": "boolean",
+                    "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+                  }
+                ]
               }
             },
             "required": ["projects"]
@@ -239,8 +246,15 @@
           "$ref": "#/definitions/NxReleaseVersionConfiguration"
         },
         "versionPlans": {
-          "type": "boolean",
-          "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+          "oneOf": [
+            {
+              "$ref": "#/definitions/NxReleaseVersionPlansConfiguration"
+            },
+            {
+              "type": "boolean",
+              "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+            }
+          ]
         },
         "releaseTagPattern": {
           "type": "string"
@@ -698,6 +712,18 @@
         }
       }
     },
+    "NxReleaseVersionPlansConfiguration": {
+      "type": "object",
+      "properties": {
+        "ignorePatternsForPlanCheck": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Changes to files matching any of these optional patterns will be excluded from the affected project logic within the `nx release plan:check` command. This is useful for ignoring files that are not relevant to the versioning process, such as documentation or configuration files."
+        }
+      }
+    },
     "ChangelogRenderOptions": {
       "type": "object",
       "additionalProperties": true

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) {

package/src/command-line/release/version.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 not delete version plans after versioning as they may be needed for changelog generation
             args.deleteVersionPlans = false;

package/src/config/nx-json.d.ts

@@ -145,6 +145,13 @@ export interface NxReleaseConventionalCommitsConfiguration {
         } | boolean;
     } | boolean>;
 }
+export interface NxReleaseVersionPlansConfiguration {
+    /**
+     * Changes to files matching any of these optional patterns will be excluded from the affected project logic within the `nx release plan:check`
+     * command. This is useful for ignoring files that are not relevant to the versioning process, such as documentation or configuration files.
+     */
+    ignorePatternsForPlanCheck?: string[];
+}
 export interface NxReleaseConfiguration {
     /**
      * Shorthand for amending the projects which will be included in the implicit default release group (all projects by default).
@@ -193,7 +200,7 @@ export interface NxReleaseConfiguration {
          * Enables using version plans as a specifier source for versioning and
          * to determine changes for changelog generation.
          */
-        versionPlans?: boolean;
+        versionPlans?: NxReleaseVersionPlansConfiguration | boolean;
     }>;
     /**
      * Configures the default value for all groups that don't explicitly state their own projectsRelationship.
@@ -264,7 +271,7 @@ export interface NxReleaseConfiguration {
      * Enables using version plans as a specifier source for versioning and
      * to determine changes for changelog generation.
      */
-    versionPlans?: boolean;
+    versionPlans?: NxReleaseVersionPlansConfiguration | boolean;
 }
 export interface NxSyncConfiguration {
     /**

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

@@ -70,7 +70,7 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
                 ],
             });
         }
-        // Allow setting base and head via environment variables (lower priority then direct command arguments)
+        // Allow setting base and head via environment variables (lower priority than direct command arguments)
         if (!nxArgs.base && process.env.NX_BASE) {
             nxArgs.base = process.env.NX_BASE;
             if (options.printWarnings) {