nx 17.0.3 → 17.1.0-beta.2

package/package.json

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

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

@@ -62,7 +62,8 @@ async function changelogHandler(args) {
         version: args.version,
         releaseTagPattern: nxReleaseConfig.releaseTagPattern,
     });
-    const from = args.from || (await (0, git_1.getLastGitTag)());
+    const from = args.from ||
+        (await (0, git_1.getLatestGitTagForPattern)(nxReleaseConfig.releaseTagPattern))?.tag;
     if (!from) {
         output_1.output.error({
             title: `Unable to determine the previous git tag, please provide an explicit git reference using --from`,

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

@@ -37,7 +37,7 @@ export type NxReleaseConfig = DeepRequired<NxJsonConfiguration['release'] & {
     groups: DeepRequired<EnsureProjectsArray<NxJsonConfiguration['release']['groups']>>;
 }>;
 export interface CreateNxReleaseConfigError {
-    code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'PROJECTS_MISSING_TARGET';
+    code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'PROJECTS_MISSING_TARGET';
     data: Record<string, string | string[]>;
 }
 export declare function createNxReleaseConfig(projectGraph: ProjectGraph, userConfig?: NxJsonConfiguration['release'], requiredTargetName?: 'nx-release-publish'): Promise<{

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

@@ -113,6 +113,16 @@ requiredTargetName) {
                 };
             }
         }
+        // If provided, ensure release tag pattern is valid
+        if (releaseGroup.releaseTagPattern) {
+            const error = ensureReleaseTagPatternIsValid(releaseGroup.releaseTagPattern, releaseGroupName);
+            if (error) {
+                return {
+                    error,
+                    nxReleaseConfig: null,
+                };
+            }
+        }
         for (const project of matchingProjects) {
             if (alreadyMatchedProjects.has(project)) {
                 return {
@@ -194,12 +204,37 @@ async function handleNxReleaseConfigError(error) {
                 });
             }
             break;
+        case 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE':
+            {
+                const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                    'release',
+                    'groups',
+                    error.data.releaseGroupName,
+                    'releaseTagPattern',
+                ]);
+                devkit_exports_1.output.error({
+                    title: `Release group "${error.data.releaseGroupName}" has an invalid releaseTagPattern. Please ensure the pattern contains exactly one instance of the "{version}" placeholder`,
+                    bodyLines: [nxJsonMessage],
+                });
+            }
+            break;
         default:
             throw new Error(`Unhandled error code: ${error.code}`);
     }
     process.exit(1);
 }
 exports.handleNxReleaseConfigError = handleNxReleaseConfigError;
+function ensureReleaseTagPatternIsValid(releaseTagPattern, releaseGroupName) {
+    // ensure that any provided releaseTagPattern contains exactly one instance of {version}
+    return releaseTagPattern.split('{version}').length === 2
+        ? null
+        : {
+            code: 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE',
+            data: {
+                releaseGroupName,
+            },
+        };
+}
 function ensureProjectsConfigIsArray(groups) {
     const result = {};
     for (const [groupName, groupConfig] of Object.entries(groups)) {

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/utils/exec-command.d.ts

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execCommand = void 0;
+const node_child_process_1 = require("node:child_process");
+async function execCommand(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(cmd, args, {
+            ...options,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: 'utf-8',
+        });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Command failed with exit code ${code}`));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+exports.execCommand = execCommand;

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

@@ -19,8 +19,12 @@ export interface GitCommit extends RawGitCommit {
     references: Reference[];
     authors: GitCommitAuthor[];
     isBreaking: boolean;
+    affectedFiles: string[];
 }
-export declare function getLastGitTag(): Promise<any>;
+export declare function getLatestGitTagForPattern(releaseTagPattern: string, additionalInterpolationData?: {}): Promise<{
+    tag: string;
+    extractedVersion: string;
+} | null>;
 export declare function getGitDiff(from: string | undefined, to?: string): Promise<RawGitCommit[]>;
 export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
 export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;

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

@@ -1,21 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGitCommit = exports.parseCommits = exports.getGitDiff = exports.getLastGitTag = void 0;
+exports.parseGitCommit = exports.parseCommits = exports.getGitDiff = exports.getLatestGitTagForPattern = void 0;
 /**
  * Special thanks to changelogen for the original inspiration for many of these utilities:
  * https://github.com/unjs/changelogen
  */
-const node_child_process_1 = require("node:child_process");
-async function getLastGitTag() {
-    const r = await execCommand('git', ['describe', '--tags', '--abbrev=0'])
-        .then((r) => r.split('\n').filter(Boolean))
-        .catch(() => []);
-    return r.at(-1);
+const utils_1 = require("../../../tasks-runner/utils");
+const exec_command_1 = require("./exec-command");
+function escapeRegExp(string) {
+    return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
 }
-exports.getLastGitTag = getLastGitTag;
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/g;
+async function getLatestGitTagForPattern(releaseTagPattern, additionalInterpolationData = {}) {
+    try {
+        const tags = await (0, exec_command_1.execCommand)('git', ['tag', '--sort', '-v:refname']).then((r) => r
+            .trim()
+            .split('\n')
+            .map((t) => t.trim())
+            .filter(Boolean));
+        if (!tags.length) {
+            return null;
+        }
+        const interpolatedTagPattern = (0, utils_1.interpolate)(releaseTagPattern, {
+            version: ' ',
+            ...additionalInterpolationData,
+        });
+        const tagRegexp = `^${escapeRegExp(interpolatedTagPattern).replace(' ', '(.+)')}`;
+        const matchingSemverTags = tags.filter((tag) => 
+        // Do the match against SEMVER_REGEX to ensure that we skip tags that aren't valid semver versions
+        !!tag.match(tagRegexp) && tag.match(tagRegexp)[1]?.match(SEMVER_REGEX));
+        if (!matchingSemverTags.length) {
+            return null;
+        }
+        const [latestMatchingTag, version] = matchingSemverTags[0].match(tagRegexp);
+        return {
+            tag: latestMatchingTag,
+            extractedVersion: version,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.getLatestGitTagForPattern = getLatestGitTagForPattern;
 async function getGitDiff(from, to = 'HEAD') {
     // https://git-scm.com/docs/pretty-formats
-    const r = await execCommand('git', [
+    const r = await (0, exec_command_1.execCommand)('git', [
         '--no-pager',
         'log',
         `${from ? `${from}...` : ''}${to}`,
@@ -48,6 +79,7 @@ const ConventionalCommitRegex = /(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!
 const CoAuthoredByRegex = /co-authored-by:\s*(?<name>.+)(<(?<email>.+)>)/gim;
 const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/gm;
 const IssueRE = /(#\d+)/gm;
+const ChangedFileRegex = /(A|M|D|R\d*|C\d*)\t([^\t\n]*)\t?(.*)?/gm;
 function parseGitCommit(commit) {
     const match = commit.message.match(ConventionalCommitRegex);
     if (!match) {
@@ -78,6 +110,10 @@ function parseGitCommit(commit) {
             email: (match.groups.email || '').trim(),
         });
     }
+    // Extract file changes from commit body
+    const affectedFiles = Array.from(commit.body.matchAll(ChangedFileRegex)).reduce((prev, [fullLine, changeType, file1, file2]) => 
+    // file2 only exists for some change types, such as renames
+    file2 ? [...prev, file1, file2] : [...prev, file1], []);
     return {
         ...commit,
         authors,
@@ -86,30 +122,7 @@ function parseGitCommit(commit) {
         scope,
         references,
         isBreaking,
+        affectedFiles,
     };
 }
 exports.parseGitCommit = parseGitCommit;
-async function execCommand(cmd, args, options) {
-    return new Promise((resolve, reject) => {
-        const child = (0, node_child_process_1.spawn)(cmd, args, {
-            ...options,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            encoding: 'utf-8',
-        });
-        let stdout = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += chunk;
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Command failed with exit code ${code}`));
-            }
-            else {
-                resolve(stdout);
-            }
-        });
-    });
-}

package/src/command-line/release/utils/resolve-nx-json-error-message.js

@@ -8,7 +8,10 @@ async function resolveNxJsonConfigErrorMessage(propPath) {
     const errorLines = await getJsonConfigLinesForErrorMessage((0, node_fs_1.readFileSync)((0, devkit_exports_1.joinPathFragments)(devkit_exports_1.workspaceRoot, 'nx.json'), 'utf-8'), propPath);
     let nxJsonMessage = `The relevant config is defined here: ${(0, node_path_1.relative)(process.cwd(), (0, devkit_exports_1.joinPathFragments)(devkit_exports_1.workspaceRoot, 'nx.json'))}`;
     if (errorLines) {
-        nxJsonMessage += `, lines ${errorLines.startLine}-${errorLines.endLine}`;
+        nxJsonMessage +=
+            errorLines.startLine === errorLines.endLine
+                ? `, line ${errorLines.startLine}`
+                : `, lines ${errorLines.startLine}-${errorLines.endLine}`;
     }
     return nxJsonMessage;
 }

package/src/command-line/release/utils/resolve-semver-specifier.d.ts

@@ -0,0 +1,3 @@
+import { ProjectGraph } from '../../../config/project-graph';
+export declare function resolveSemverSpecifierFromConventionalCommits(from: string, projectGraph: ProjectGraph, projectNames: string[]): Promise<string | null>;
+export declare function resolveSemverSpecifierFromPrompt(selectionMessage: string, customVersionMessage: string): Promise<string>;

package/src/command-line/release/utils/resolve-semver-specifier.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSemverSpecifierFromPrompt = exports.resolveSemverSpecifierFromConventionalCommits = void 0;
+const enquirer_1 = require("enquirer");
+const semver_1 = require("semver");
+const file_map_utils_1 = require("../../../project-graph/file-map-utils");
+const git_1 = require("./git");
+const semver_2 = require("./semver");
+// TODO: Extract config to nx.json configuration when adding changelog customization
+const CONVENTIONAL_COMMITS_CONFIG = {
+    types: {
+        feat: {
+            semver: 'minor',
+        },
+        fix: {
+            semver: 'patch',
+        },
+    },
+};
+async function resolveSemverSpecifierFromConventionalCommits(from, projectGraph, projectNames) {
+    const commits = await (0, git_1.getGitDiff)(from);
+    const parsedCommits = (0, git_1.parseCommits)(commits);
+    const projectFileMap = await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph);
+    const filesInReleaseGroup = new Set(projectNames.reduce((files, p) => [...files, ...projectFileMap[p].map((f) => f.file)], []));
+    const relevantCommits = parsedCommits.filter((c) => c.affectedFiles.some((f) => filesInReleaseGroup.has(f)));
+    return (0, semver_2.determineSemverChange)(relevantCommits, CONVENTIONAL_COMMITS_CONFIG);
+}
+exports.resolveSemverSpecifierFromConventionalCommits = resolveSemverSpecifierFromConventionalCommits;
+async function resolveSemverSpecifierFromPrompt(selectionMessage, customVersionMessage) {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'specifier',
+                message: selectionMessage,
+                type: 'select',
+                choices: [
+                    ...semver_1.RELEASE_TYPES.map((t) => ({ name: t, message: t })),
+                    {
+                        name: 'custom',
+                        message: 'Custom exact version',
+                    },
+                ],
+            },
+        ]);
+        if (reply.specifier !== 'custom') {
+            return reply.specifier;
+        }
+        else {
+            const reply = await (0, enquirer_1.prompt)([
+                {
+                    name: 'specifier',
+                    message: customVersionMessage,
+                    type: 'input',
+                    validate: (input) => {
+                        if ((0, semver_1.valid)(input)) {
+                            return true;
+                        }
+                        return 'Please enter a valid semver version';
+                    },
+                },
+            ]);
+            return reply.specifier;
+        }
+    }
+    catch {
+        // TODO: log the error to the user?
+        // We need to catch the error from enquirer prompt, otherwise yargs will print its help
+        process.exit(1);
+    }
+}
+exports.resolveSemverSpecifierFromPrompt = resolveSemverSpecifierFromPrompt;

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

@@ -1,3 +1,17 @@
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
 import { ReleaseType } from 'semver';
+import { GitCommit } from './git';
 export declare function isRelativeVersionKeyword(val: string): val is ReleaseType;
+export declare function isValidSemverSpecifier(specifier: string): boolean;
+export interface ConventionalCommitsConfig {
+    types: {
+        [type: string]: {
+            semver: 'patch' | 'minor' | 'major';
+        };
+    };
+}
+export declare function determineSemverChange(commits: GitCommit[], config: ConventionalCommitsConfig): 'patch' | 'minor' | 'major' | null;
 export declare function deriveNewSemverVersion(currentSemverVersion: string, semverSpecifier: string, preid?: string): string;

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

@@ -1,11 +1,37 @@
 "use strict";
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deriveNewSemverVersion = exports.isRelativeVersionKeyword = void 0;
+exports.deriveNewSemverVersion = exports.determineSemverChange = exports.isValidSemverSpecifier = exports.isRelativeVersionKeyword = void 0;
 const semver_1 = require("semver");
 function isRelativeVersionKeyword(val) {
     return semver_1.RELEASE_TYPES.includes(val);
 }
 exports.isRelativeVersionKeyword = isRelativeVersionKeyword;
+function isValidSemverSpecifier(specifier) {
+    return (specifier && !!((0, semver_1.valid)(specifier) || isRelativeVersionKeyword(specifier)));
+}
+exports.isValidSemverSpecifier = isValidSemverSpecifier;
+// https://github.com/unjs/changelogen/blob/main/src/semver.ts
+function determineSemverChange(commits, config) {
+    let [hasMajor, hasMinor, hasPatch] = [false, false, false];
+    for (const commit of commits) {
+        const semverType = config.types[commit.type]?.semver;
+        if (semverType === 'major' || commit.isBreaking) {
+            hasMajor = true;
+        }
+        else if (semverType === 'minor') {
+            hasMinor = true;
+        }
+        else if (semverType === 'patch') {
+            hasPatch = true;
+        }
+    }
+    return hasMajor ? 'major' : hasMinor ? 'minor' : hasPatch ? 'patch' : null;
+}
+exports.determineSemverChange = determineSemverChange;
 function deriveNewSemverVersion(currentSemverVersion, semverSpecifier, preid) {
     if (!(0, semver_1.valid)(currentSemverVersion)) {
         throw new Error(`Invalid semver version "${currentSemverVersion}" provided.`);

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

@@ -1,13 +1,16 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
 import { VersionOptions } from './command-object';
+import { ReleaseGroupWithName } from './config/filter-release-groups';
 export { deriveNewSemverVersion } from './utils/semver';
 export interface ReleaseVersionGeneratorSchema {
     projects: ProjectGraphProjectNode[];
+    releaseGroup: ReleaseGroupWithName;
     projectGraph: ProjectGraph;
-    specifier: string;
+    specifier?: string;
+    specifierSource?: 'prompt' | 'conventional-commits';
     preid?: string;
     packageRoot?: string;
-    currentVersionResolver?: 'registry' | 'disk';
+    currentVersionResolver?: 'registry' | 'disk' | 'git-tag';
     currentVersionResolverMetadata?: Record<string, unknown>;
 }
 export declare function versionHandler(args: VersionOptions): Promise<void>;

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

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.versionHandler = exports.deriveNewSemverVersion = void 0;
 const chalk = require("chalk");
-const enquirer = require("enquirer");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const semver_1 = require("semver");
 const nx_json_1 = require("../../config/nx-json");
 const devkit_exports_1 = require("../../devkit-exports");
 const tree_1 = require("../../generators/tree");
@@ -16,10 +14,9 @@ const generator_utils_1 = require("../generate/generator-utils");
 const config_1 = require("./config/config");
 const filter_release_groups_1 = require("./config/filter-release-groups");
 const print_changes_1 = require("./utils/print-changes");
-const semver_2 = require("./utils/semver");
 // Reexport for use in plugin release-version generator implementations
-var semver_3 = require("./utils/semver");
-Object.defineProperty(exports, "deriveNewSemverVersion", { enumerable: true, get: function () { return semver_3.deriveNewSemverVersion; } });
+var semver_1 = require("./utils/semver");
+Object.defineProperty(exports, "deriveNewSemverVersion", { enumerable: true, get: function () { return semver_1.deriveNewSemverVersion; } });
 async function versionHandler(args) {
     const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
     const nxJson = (0, nx_json_1.readNxJson)();
@@ -48,8 +45,8 @@ async function versionHandler(args) {
                 ...extractGeneratorCollectionAndName(`release-group "${releaseGroupName}"`, releaseGroup.version.generator),
                 configGeneratorOptions: releaseGroup.version.generatorOptions,
             });
-            const semverSpecifier = await resolveSemverSpecifier(args.specifier, `What kind of change is this for the ${releaseGroupToFilteredProjects.get(releaseGroup).size} matched project(s) within release group "${releaseGroupName}"?`, `What is the exact version for the ${releaseGroupToFilteredProjects.get(releaseGroup).size} matched project(s) within release group "${releaseGroupName}"?`);
-            await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, Array.from(releaseGroupToFilteredProjects.get(releaseGroup)), semverSpecifier);
+            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+            await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, releaseGroupProjectNames, releaseGroup);
         }
         printChanges(tree, !!args.dryRun);
         return process.exit(0);
@@ -64,37 +61,19 @@ async function versionHandler(args) {
             ...extractGeneratorCollectionAndName(`release-group "${releaseGroupName}"`, releaseGroup.version.generator),
             configGeneratorOptions: releaseGroup.version.generatorOptions,
         });
-        const semverSpecifier = await resolveSemverSpecifier(args.specifier, releaseGroupName === config_1.CATCH_ALL_RELEASE_GROUP
-            ? `What kind of change is this for all packages?`
-            : `What kind of change is this for release group "${releaseGroupName}"?`, releaseGroupName === config_1.CATCH_ALL_RELEASE_GROUP
-            ? `What is the exact version for all packages?`
-            : `What is the exact version for release group "${releaseGroupName}"?`);
-        await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, releaseGroup.projects, semverSpecifier);
+        await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, releaseGroup.projects, releaseGroup);
     }
     printChanges(tree, !!args.dryRun);
     process.exit(0);
 }
 exports.versionHandler = versionHandler;
-async function runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, projectNames, newVersionSpecifier) {
-    // Should be impossible state
-    if (!newVersionSpecifier) {
-        devkit_exports_1.output.error({
-            title: `No version or semver keyword could be determined`,
-        });
-        process.exit(1);
-    }
-    // Specifier could be user provided so we need to validate it
-    if (!(0, semver_1.valid)(newVersionSpecifier) &&
-        !(0, semver_2.isRelativeVersionKeyword)(newVersionSpecifier)) {
-        devkit_exports_1.output.error({
-            title: `The given version specifier "${newVersionSpecifier}" is not valid. You provide an exact version or a valid semver keyword such as "major", "minor", "patch", etc.`,
-        });
-        process.exit(1);
-    }
+async function runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, projectNames, releaseGroup) {
     const generatorOptions = {
         projects: projectNames.map((p) => projectGraph.nodes[p]),
         projectGraph,
-        specifier: newVersionSpecifier,
+        releaseGroup,
+        // Always ensure a string to avoid generator schema validation errors
+        specifier: args.specifier ?? '',
         preid: args.preid,
         ...generatorData.configGeneratorOptions,
     };
@@ -128,52 +107,6 @@ function printChanges(tree, isDryRun) {
         devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
     }
 }
-async function resolveSemverSpecifier(cliArgSpecifier, selectionMessage, customVersionMessage) {
-    try {
-        let newVersionSpecifier = cliArgSpecifier;
-        // If the user didn't provide a new version specifier directly on the CLI, prompt for one
-        if (!newVersionSpecifier) {
-            const reply = await enquirer.prompt([
-                {
-                    name: 'specifier',
-                    message: selectionMessage,
-                    type: 'select',
-                    choices: [
-                        ...semver_1.RELEASE_TYPES.map((t) => ({ name: t, message: t })),
-                        {
-                            name: 'custom',
-                            message: 'Custom exact version',
-                        },
-                    ],
-                },
-            ]);
-            if (reply.specifier !== 'custom') {
-                newVersionSpecifier = reply.specifier;
-            }
-            else {
-                const reply = await enquirer.prompt([
-                    {
-                        name: 'specifier',
-                        message: customVersionMessage,
-                        type: 'input',
-                        validate: (input) => {
-                            if ((0, semver_1.valid)(input)) {
-                                return true;
-                            }
-                            return 'Please enter a valid semver version';
-                        },
-                    },
-                ]);
-                newVersionSpecifier = reply.specifier;
-            }
-        }
-        return newVersionSpecifier;
-    }
-    catch {
-        // We need to catch the error from enquirer prompt, otherwise yargs will print its help
-        process.exit(1);
-    }
-}
 function extractGeneratorCollectionAndName(description, generatorString) {
     let collectionName;
     let generatorName;

package/src/devkit-internals.d.ts

@@ -14,4 +14,5 @@ export { sortObjectByKeys } from './utils/object-sort';
 export { stripIndent } from './utils/logger';
 export { readModulePackageJson } from './utils/package-json';
 export { splitByColons } from './utils/split-target';
+export { hashObject } from './hasher/file-hasher';
 export { createProjectRootMappingsFromProjectConfigurations, findProjectForPath, } from './project-graph/utils/find-project-for-path';

package/src/devkit-internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
+exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
 /**
  * Note to developers: STOP! These exports are available via requireNx in @nx/devkit.
  *
@@ -28,6 +28,8 @@ var package_json_1 = require("./utils/package-json");
 Object.defineProperty(exports, "readModulePackageJson", { enumerable: true, get: function () { return package_json_1.readModulePackageJson; } });
 var split_target_2 = require("./utils/split-target");
 Object.defineProperty(exports, "splitByColons", { enumerable: true, get: function () { return split_target_2.splitByColons; } });
+var file_hasher_1 = require("./hasher/file-hasher");
+Object.defineProperty(exports, "hashObject", { enumerable: true, get: function () { return file_hasher_1.hashObject; } });
 var find_project_for_path_1 = require("./project-graph/utils/find-project-for-path");
 Object.defineProperty(exports, "createProjectRootMappingsFromProjectConfigurations", { enumerable: true, get: function () { return find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations; } });
 Object.defineProperty(exports, "findProjectForPath", { enumerable: true, get: function () { return find_project_for_path_1.findProjectForPath; } });

package/src/generators/testing-utils/create-tree-with-empty-workspace.js

@@ -35,9 +35,6 @@ function addCommonFiles(tree, addAppsAndLibsFolders) {
             lint: {
                 cache: true,
             },
-            test: {
-                cache: true,
-            },
             e2e: {
                 cache: true,
             },

package/src/project-graph/utils/normalize-project-nodes.js

@@ -74,7 +74,7 @@ function normalizeProjectTargets(project, targetDefaults, projectName) {
         const defaults = resolveCommandSyntacticSugar((0, project_configuration_utils_1.readTargetDefaultsForTarget)(target, targetDefaults, executor), `targetDefaults:${target}`);
         targets[target] = resolveCommandSyntacticSugar(targets[target], `${projectName}:${target}`);
         if (defaults) {
-            targets[target] = (0, project_configuration_utils_1.mergeTargetConfigurations)(project, target, defaults);
+            targets[target] = (0, project_configuration_utils_1.mergeTargetConfigurations)(targets[target], defaults);
         }
         targets[target].options = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].options, project, `${projectName}:${target}`);
         targets[target].configurations ??= {};

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -9,6 +9,16 @@ plugins: LoadedNxPlugin[], root?: string): {
     externalNodes: Record<string, ProjectGraphExternalNode>;
 };
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
-export declare function mergeTargetConfigurations(projectConfiguration: ProjectConfiguration, target: string, targetDefaults: TargetDefaults[string]): TargetConfiguration;
+/**
+ * Merges two configurations for a target.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The configuration for the target with higher priority
+ * @param baseTarget The configuration for the target that should be overwritten.
+ * @returns A merged target configuration
+ */
+export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget: TargetConfiguration): TargetConfiguration;
 export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
 export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];

package/src/project-graph/utils/project-configuration-utils.js

@@ -21,16 +21,28 @@ function mergeProjectConfigurationIntoRootMap(projectRootMap, project) {
     };
     // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
     if (project.tags && matchingProject.tags) {
-        updatedProjectConfiguration.tags = matchingProject.tags.concat(project.tags);
+        updatedProjectConfiguration.tags = Array.from(new Set(matchingProject.tags.concat(project.tags)));
     }
     if (project.implicitDependencies && matchingProject.implicitDependencies) {
         updatedProjectConfiguration.implicitDependencies =
             matchingProject.implicitDependencies.concat(project.implicitDependencies);
     }
     if (project.generators && matchingProject.generators) {
-        updatedProjectConfiguration.generators = {
-            ...matchingProject.generators,
-            ...project.generators,
+        // Start with generators config in new project.
+        updatedProjectConfiguration.generators = { ...project.generators };
+        // For each generator that was already defined, shallow merge the options.
+        // Project contains the new info, so it has higher priority.
+        for (const generator in matchingProject.generators) {
+            updatedProjectConfiguration.generators[generator] = {
+                ...matchingProject.generators[generator],
+                ...project.generators[generator],
+            };
+        }
+    }
+    if (project.namedInputs && matchingProject.namedInputs) {
+        updatedProjectConfiguration.namedInputs = {
+            ...matchingProject.namedInputs,
+            ...project.namedInputs,
         };
     }
     if (project.targets && matchingProject.targets) {
@@ -38,6 +50,14 @@ function mergeProjectConfigurationIntoRootMap(projectRootMap, project) {
             ...matchingProject.targets,
             ...project.targets,
         };
+        for (const target in matchingProject.targets) {
+            if (target in matchingProject.targets && target in project.targets) {
+                // If the target is defined in both places, merge the options
+                // Project contains the new info, so it has higher priority.
+                // Options from matchingProject are used as defaults.
+                updatedProjectConfiguration.targets[target] = mergeTargetConfigurations(project.targets[target], matchingProject.targets[target]);
+            }
+        }
     }
     projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
 }
@@ -104,27 +124,41 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
-function mergeTargetConfigurations(projectConfiguration, target, targetDefaults) {
-    const targetConfiguration = projectConfiguration.targets?.[target];
-    if (!targetConfiguration) {
-        throw new Error(`Attempted to merge targetDefaults for ${projectConfiguration.name}.${target}, which doesn't exist.`);
-    }
-    const { configurations: defaultConfigurations, options: defaultOptions, ...defaults } = targetDefaults;
+/**
+ * Merges two configurations for a target.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The configuration for the target with higher priority
+ * @param baseTarget The configuration for the target that should be overwritten.
+ * @returns A merged target configuration
+ */
+function mergeTargetConfigurations(target, baseTarget) {
+    const { configurations: defaultConfigurations, options: defaultOptions, ...defaults } = baseTarget;
     const result = {
         ...defaults,
-        ...targetConfiguration,
+        ...target,
     };
     // Target is "compatible", e.g. executor is defined only once or is the same
     // in both places. This means that it is likely safe to merge options
-    if (!targetDefaults.executor ||
-        !targetConfiguration.executor ||
-        targetDefaults.executor === targetConfiguration.executor) {
-        result.options = { ...defaultOptions, ...targetConfiguration?.options };
-        result.configurations = mergeConfigurations(defaultConfigurations, targetConfiguration.configurations);
+    if (isCompatibleTarget(defaults, target)) {
+        result.options = { ...defaultOptions, ...target?.options };
+        result.configurations = mergeConfigurations(defaultConfigurations, target.configurations);
     }
     return result;
 }
 exports.mergeTargetConfigurations = mergeTargetConfigurations;
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+function isCompatibleTarget(a, b) {
+    return !a.executor || !b.executor || a.executor === b.executor;
+}
 function mergeConfigurations(defaultConfigurations, projectDefinedConfigurations) {
     const result = {};
     const configurations = new Set([