nx 17.0.3 → 17.0.5

package/src/command-line/release/utils/print-changes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printChanges = exports.printDiff = void 0;
+exports.printAndFlushChanges = exports.printDiff = void 0;
 const chalk = require("chalk");
 const jest_diff_1 = require("jest-diff");
 const node_fs_1 = require("node:fs");
@@ -27,7 +27,7 @@ function printDiff(before, after, contextLines = 1, noDiffMessage = NO_DIFF_MESS
     console.log('');
 }
 exports.printDiff = printDiff;
-function printChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMessage = true, noDiffMessage, changePredicate) {
+function printAndFlushChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMessage = true, noDiffMessage, changePredicate) {
     changePredicate = changePredicate || (() => true);
     const changes = tree.listChanges();
     console.log('');
@@ -57,4 +57,4 @@ function printChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMes
         devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
     }
 }
-exports.printChanges = printChanges;
+exports.printAndFlushChanges = printAndFlushChanges;

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,4 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+export declare function resolveSemverSpecifierFromConventionalCommits(from: string, projectGraph: ProjectGraph, projectNames: string[], conventionalCommitsConfig: NxReleaseConfig['conventionalCommits']): 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,58 @@
+"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 git_1 = require("./git");
+const semver_2 = require("./semver");
+const shared_1 = require("./shared");
+async function resolveSemverSpecifierFromConventionalCommits(from, projectGraph, projectNames, conventionalCommitsConfig) {
+    const commits = await (0, git_1.getGitDiff)(from);
+    const parsedCommits = (0, git_1.parseCommits)(commits);
+    const relevantCommits = await (0, shared_1.getCommitsRelevantToProjects)(projectGraph, parsedCommits, projectNames);
+    return (0, semver_2.determineSemverChange)(relevantCommits, conventionalCommitsConfig);
+}
+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,11 @@
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
 import { ReleaseType } from 'semver';
+import { NxReleaseConfig } from '../config/config';
+import { GitCommit } from './git';
 export declare function isRelativeVersionKeyword(val: string): val is ReleaseType;
+export declare function isValidSemverSpecifier(specifier: string): boolean;
+export declare function determineSemverChange(commits: GitCommit[], config: NxReleaseConfig['conventionalCommits']): '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,40 @@
 "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]?.semverBump;
+        if (semverType === 'major' || commit.isBreaking) {
+            hasMajor = true;
+        }
+        else if (semverType === 'minor') {
+            hasMinor = true;
+        }
+        else if (semverType === 'patch') {
+            hasPatch = true;
+        }
+        else if (semverType === 'none' || !semverType) {
+            // do not report a change
+        }
+    }
+    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/utils/shared.d.ts

@@ -0,0 +1,39 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { Tree } from '../../../generators/tree';
+import type { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { GitCommit } from './git';
+export declare const noDiffInChangelogMessage: string;
+export type ReleaseVersionGeneratorResult = {
+    data: VersionData;
+    callback: (tree: Tree, opts: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        generatorOptions?: Record<string, unknown>;
+    }) => Promise<string[]>;
+};
+export type VersionData = Record<string, {
+    /**
+     * newVersion will be null in the case that no changes are detected for the project,
+     * e.g. when using conventional commits
+     */
+    newVersion: string | null;
+    currentVersion: string;
+    dependentProjects: any[];
+}>;
+export declare class ReleaseVersion {
+    rawVersion: string;
+    gitTag: string;
+    isPrerelease: boolean;
+    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
+    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
+    projectName, }: {
+        version: string;
+        releaseTagPattern: string;
+        projectName?: string;
+    });
+}
+export declare function commitChanges(changedFiles: string[], isDryRun: boolean, isVerbose: boolean, gitCommitMessages: string[], gitCommitArgs?: string): Promise<void>;
+export declare function createCommitMessageValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData, commitMessage: string): string[];
+export declare function createGitTagValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData): string[];
+export declare function handleDuplicateGitTags(gitTagValues: string[]): void;
+export declare function getCommitsRelevantToProjects(projectGraph: ProjectGraph, commits: GitCommit[], projects: string[]): Promise<GitCommit[]>;

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommitsRelevantToProjects = exports.handleDuplicateGitTags = exports.createGitTagValues = exports.createCommitMessageValues = exports.commitChanges = exports.ReleaseVersion = exports.noDiffInChangelogMessage = void 0;
+const chalk = require("chalk");
+const semver_1 = require("semver");
+const file_map_utils_1 = require("../../../project-graph/file-map-utils");
+const utils_1 = require("../../../tasks-runner/utils");
+const output_1 = require("../../../utils/output");
+const git_1 = require("./git");
+exports.noDiffInChangelogMessage = chalk.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
+function isPrerelease(version) {
+    // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
+    return (0, semver_1.prerelease)(version) !== null;
+}
+class ReleaseVersion {
+    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
+    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
+    projectName, // optional project name to interpolate into the releaseTagPattern
+     }) {
+        this.rawVersion = version;
+        this.gitTag = (0, utils_1.interpolate)(releaseTagPattern, {
+            version,
+            projectName,
+        });
+        this.isPrerelease = isPrerelease(version);
+    }
+}
+exports.ReleaseVersion = ReleaseVersion;
+async function commitChanges(changedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs) {
+    if (!changedFiles.length) {
+        throw new Error('Error: No changed files to commit');
+    }
+    output_1.output.logSingleLine(`Committing changes with git`);
+    await (0, git_1.gitAdd)({
+        changedFiles,
+        dryRun: isDryRun,
+        verbose: isVerbose,
+    });
+    // The extra logs need something breathing room
+    if (isVerbose) {
+        console.log('');
+    }
+    await (0, git_1.gitCommit)({
+        messages: gitCommitMessages,
+        additionalArgs: gitCommitArgs,
+        dryRun: isDryRun,
+        verbose: isVerbose,
+    });
+}
+exports.commitChanges = commitChanges;
+function createCommitMessageValues(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage) {
+    const commitMessageValues = [commitMessage];
+    if (releaseGroups.length === 0) {
+        return commitMessageValues;
+    }
+    // If we have exactly one release group, with a fixed relationship, then interpolate {version} as the new version for the release group
+    if (releaseGroups.length === 1 &&
+        releaseGroups[0].projectsRelationship === 'fixed') {
+        const releaseGroup = releaseGroups[0];
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
+        const releaseVersion = new ReleaseVersion({
+            version: projectVersionData.newVersion,
+            releaseTagPattern: releaseGroup.releaseTagPattern,
+        });
+        commitMessageValues[0] = (0, utils_1.interpolate)(commitMessageValues[0], {
+            version: releaseVersion.rawVersion,
+        }).trim();
+        return commitMessageValues;
+    }
+    /**
+     * There is another special case for interpolation: if, after all filtering, we have a single independent release group with a single project,
+     * and the user has provided {projectName} within the custom message.
+     * In this case we will directly interpolate both {version} and {projectName} within the commit message.
+     */
+    if (releaseGroups.length === 1 &&
+        releaseGroups[0].projectsRelationship === 'independent' &&
+        commitMessage.includes('{projectName}')) {
+        const releaseGroup = releaseGroups[0];
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        if (releaseGroupProjectNames.length === 1) {
+            const projectVersionData = versionData[releaseGroupProjectNames[0]];
+            const releaseVersion = new ReleaseVersion({
+                version: projectVersionData.newVersion,
+                releaseTagPattern: releaseGroup.releaseTagPattern,
+                projectName: releaseGroupProjectNames[0],
+            });
+            commitMessageValues[0] = (0, utils_1.interpolate)(commitMessageValues[0], {
+                version: releaseVersion.rawVersion,
+                projectName: releaseGroupProjectNames[0],
+            }).trim();
+            return commitMessageValues;
+        }
+    }
+    /**
+     * At this point we have multiple release groups for a single commit, we will not interpolate an overall {version} or {projectName} because that won't be
+     * appropriate (for any {version} or {projectName} value within the string, we will replace it with an empty string so that it doesn't end up in the final output).
+     *
+     * Instead for fixed groups we will add one bullet point the release group, and for independent groups we will add one bullet point per project.
+     */
+    commitMessageValues[0] = stripPlaceholders(commitMessageValues[0], [
+        // for cleanest possible final result try and replace the common pattern of a v prefix in front of the version first
+        'v{version}',
+        '{version}',
+        '{projectName}',
+    ]);
+    for (const releaseGroup of releaseGroups) {
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        // One entry per project for independent groups
+        if (releaseGroup.projectsRelationship === 'independent') {
+            for (const project of releaseGroupProjectNames) {
+                const projectVersionData = versionData[project];
+                if (projectVersionData.newVersion !== null) {
+                    const releaseVersion = new ReleaseVersion({
+                        version: projectVersionData.newVersion,
+                        releaseTagPattern: releaseGroup.releaseTagPattern,
+                        projectName: project,
+                    });
+                    commitMessageValues.push(`- project: ${project} ${releaseVersion.rawVersion}`);
+                }
+            }
+            continue;
+        }
+        // One entry for the whole group for fixed groups
+        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
+        const releaseVersion = new ReleaseVersion({
+            version: projectVersionData.newVersion,
+            releaseTagPattern: releaseGroup.releaseTagPattern,
+        });
+        commitMessageValues.push(`- release-group: ${releaseGroup.name} ${releaseVersion.rawVersion}`);
+    }
+    return commitMessageValues;
+}
+exports.createCommitMessageValues = createCommitMessageValues;
+function stripPlaceholders(str, placeholders) {
+    for (const placeholder of placeholders) {
+        // for cleanest possible final result try and replace relevant spacing around placeholders first
+        str = str
+            .replace(` ${placeholder}`, '')
+            .replace(`${placeholder} `, '')
+            .replace(placeholder, '')
+            .trim();
+    }
+    return str;
+}
+function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
+    const tags = [];
+    for (const releaseGroup of releaseGroups) {
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        // For independent groups we want one tag per project, not one for the overall group
+        if (releaseGroup.projectsRelationship === 'independent') {
+            for (const project of releaseGroupProjectNames) {
+                const projectVersionData = versionData[project];
+                if (projectVersionData.newVersion !== null) {
+                    tags.push((0, utils_1.interpolate)(releaseGroup.releaseTagPattern, {
+                        version: projectVersionData.newVersion,
+                        projectName: project,
+                    }));
+                }
+            }
+            continue;
+        }
+        // For fixed groups we want one tag for the overall group
+        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
+        tags.push((0, utils_1.interpolate)(releaseGroup.releaseTagPattern, {
+            version: projectVersionData.newVersion,
+        }));
+    }
+    return tags;
+}
+exports.createGitTagValues = createGitTagValues;
+function findDuplicates(arr) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const item of arr) {
+        if (seen.has(item)) {
+            duplicates.add(item);
+        }
+        else {
+            seen.add(item);
+        }
+    }
+    return Array.from(duplicates);
+}
+function handleDuplicateGitTags(gitTagValues) {
+    // If any of the gitTagValues are identical we should hard error upfront to avoid an awkward git error later
+    const duplicateGitTagValues = findDuplicates(gitTagValues);
+    if (duplicateGitTagValues.length) {
+        output_1.output.error({
+            title: `Your current configuration would generate the following duplicate git tags:`,
+            bodyLines: [
+                ...duplicateGitTagValues.map((v) => `- ${v}`),
+                '',
+                `Please ensure that for "independent" release groups the {projectName} placeholder is used so that all dynamically created project tags are unique.`,
+            ],
+        });
+        process.exit(1);
+    }
+}
+exports.handleDuplicateGitTags = handleDuplicateGitTags;
+async function getCommitsRelevantToProjects(projectGraph, commits, projects) {
+    const { fileMap } = await (0, file_map_utils_1.createFileMapUsingProjectGraph)(projectGraph);
+    const filesInReleaseGroup = new Set(projects.reduce((files, p) => [...files, ...fileMap.projectFileMap[p].map((f) => f.file)], []));
+    /**
+     * The relevant commits are those that either:
+     * - touch project files which are contained within the list of projects directly
+     * - touch non-project files and the commit is not scoped
+     */
+    return commits.filter((c) => c.affectedFiles.some((f) => filesInReleaseGroup.has(f) ||
+        (!c.scope &&
+            fileMap.nonProjectFiles.some((nonProjectFile) => nonProjectFile.file === f))));
+}
+exports.getCommitsRelevantToProjects = getCommitsRelevantToProjects;

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

@@ -1,13 +1,47 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
 import { VersionOptions } from './command-object';
+import { NxReleaseConfig } from './config/config';
+import { ReleaseGroupWithName } from './config/filter-release-groups';
+import { VersionData } from './utils/shared';
 export { deriveNewSemverVersion } from './utils/semver';
+export type { ReleaseVersionGeneratorResult, VersionData, } from './utils/shared';
+export declare const validReleaseVersionPrefixes: readonly ["auto", "", "~", "^", "="];
 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>;
+    fallbackCurrentVersionResolver?: 'disk';
+    firstRelease?: boolean;
+    versionPrefix?: typeof validReleaseVersionPrefixes[number];
+    skipLockFileUpdate?: boolean;
+    installArgs?: string;
+    installIgnoreScripts?: boolean;
+    conventionalCommitsConfig?: NxReleaseConfig['conventionalCommits'];
 }
-export declare function versionHandler(args: VersionOptions): Promise<void>;
+export interface NxReleaseVersionResult {
+    /**
+     * In one specific (and very common) case, an overall workspace version is relevant, for example when there is
+     * only a single release group in which all projects have a fixed relationship to each other. In this case, the
+     * overall workspace version is the same as the version of the release group (and every project within it). This
+     * version could be a `string`, or it could be `null` if using conventional commits and no changes were detected.
+     *
+     * In all other cases (independent versioning, multiple release groups etc), the overall workspace version is
+     * not applicable and will be `undefined` here. If a user attempts to use this value later when it is `undefined`
+     * (for example in the changelog command), we will throw an appropriate error.
+     */
+    workspaceVersion: (string | null) | undefined;
+    projectsVersionData: VersionData;
+}
+export declare const releaseVersionCLIHandler: (args: VersionOptions) => Promise<any>;
+/**
+ * NOTE: This function is also exported for programmatic usage and forms part of the public API
+ * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
+ * to have control over their own error handling when using the API.
+ */
+export declare function releaseVersion(args: VersionOptions): Promise<NxReleaseVersionResult>;