nx 20.8.4 → 22.7.7

package/dist/src/command-line/release/utils/resolve-changelog-renderer.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChangelogRenderer = resolveChangelogRenderer;
+const register_1 = require("../../../plugins/js/utils/register");
+const typescript_1 = require("../../../plugins/js/utils/typescript");
+const utils_1 = require("../../../tasks-runner/utils");
+const workspace_root_1 = require("../../../utils/workspace-root");
+function resolveChangelogRenderer(changelogRendererPathOrImplementation) {
+    // An implementation was provided directly via the programmatic API
+    if (typeof changelogRendererPathOrImplementation === 'function') {
+        return changelogRendererPathOrImplementation;
+    }
+    const interpolatedChangelogRendererPath = (0, utils_1.interpolate)(changelogRendererPathOrImplementation, {
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    });
+    // Try and load the provided (or default) changelog renderer
+    let ChangelogRendererClass;
+    let cleanupTranspiler = () => { };
+    try {
+        const rootTsconfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (rootTsconfigPath) {
+            cleanupTranspiler = (0, register_1.registerTsProject)(rootTsconfigPath);
+        }
+        const r = require(interpolatedChangelogRendererPath);
+        ChangelogRendererClass = r.default || r;
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        cleanupTranspiler();
+    }
+    return ChangelogRendererClass;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNxJsonConfigErrorMessage = resolveNxJsonConfigErrorMessage;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const handle_import_1 = require("../../../utils/handle-import");
+const path_1 = require("../../../utils/path");
+const workspace_root_1 = require("../../../utils/workspace-root");
+async function resolveNxJsonConfigErrorMessage(propPath) {
+    const errorLines = await getJsonConfigLinesForErrorMessage((0, node_fs_1.readFileSync)((0, path_1.joinPathFragments)(workspace_root_1.workspaceRoot, 'nx.json'), 'utf-8'), propPath);
+    let nxJsonMessage = `The relevant config is defined here: ${(0, node_path_1.relative)(process.cwd(), (0, path_1.joinPathFragments)(workspace_root_1.workspaceRoot, 'nx.json'))}`;
+    if (errorLines) {
+        nxJsonMessage +=
+            errorLines.startLine === errorLines.endLine
+                ? `, line ${errorLines.startLine}`
+                : `, lines ${errorLines.startLine}-${errorLines.endLine}`;
+    }
+    return nxJsonMessage + '.';
+}
+async function getJsonConfigLinesForErrorMessage(rawConfig, jsonPath) {
+    try {
+        const jsonParser = await (0, handle_import_1.handleImport)('jsonc-parser');
+        const rootNode = jsonParser.parseTree(rawConfig);
+        const node = jsonParser.findNodeAtLocation(rootNode, jsonPath);
+        return computeJsonLineNumbers(rawConfig, node?.offset, node?.length);
+    }
+    catch {
+        return null;
+    }
+}
+function computeJsonLineNumbers(inputText, startOffset, characterCount) {
+    let lines = inputText.split('\n');
+    let totalChars = 0;
+    let startLine = 0;
+    let endLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        totalChars += lines[i].length + 1; // +1 for '\n' character
+        if (!startLine && totalChars >= startOffset) {
+            startLine = i + 1; // +1 because arrays are 0-based
+        }
+        if (totalChars >= startOffset + characterCount) {
+            endLine = i + 1; // +1 because arrays are 0-based
+            break;
+        }
+    }
+    if (!startLine) {
+        throw new Error('Start offset exceeds the text length');
+    }
+    if (!endLine) {
+        throw new Error('Character count exceeds the text length after start offset');
+    }
+    return { startLine, endLine };
+}

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

@@ -0,0 +1,7 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import { SemverBumpType } from '../version/version-actions';
+import { ReleaseGraph } from './release-graph';
+import { SemverSpecifier } from './semver';
+export declare function resolveSemverSpecifierFromConventionalCommits(from: string, projectGraph: ProjectGraph, projectNames: string[], releaseConfig: NxReleaseConfig, releaseGraph: ReleaseGraph): Promise<Map<string, SemverSpecifier | null>>;
+export declare function resolveSemverSpecifierFromPrompt(selectionMessage: string, customVersionMessage: string): Promise<SemverBumpType | string>;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSemverSpecifierFromConventionalCommits = resolveSemverSpecifierFromConventionalCommits;
+exports.resolveSemverSpecifierFromPrompt = resolveSemverSpecifierFromPrompt;
+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, releaseConfig, releaseGraph) {
+    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, releaseConfig, releaseGraph);
+    return (0, semver_2.determineSemverChange)(relevantCommits, releaseConfig.conventionalCommits);
+}
+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 {
+        // Ensure the cursor is always restored before exiting
+        process.stdout.write('\u001b[?25h');
+        // We need to catch the error from enquirer prompt, otherwise yargs will print its help
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * 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 const enum SemverSpecifier {
+    MAJOR = 3,
+    MINOR = 2,
+    PATCH = 1
+}
+export declare const SemverSpecifierType: {
+    3: string;
+    2: string;
+    1: string;
+};
+export declare function isRelativeVersionKeyword(val: string): val is ReleaseType;
+export declare function isValidSemverSpecifier(specifier: string): boolean;
+export declare function determineSemverChange(relevantCommits: Map<string, {
+    commit: GitCommit;
+    isProjectScopedCommit: boolean;
+}[]>, config: NxReleaseConfig['conventionalCommits']): Map<string, SemverSpecifier | null>;
+export declare function deriveNewSemverVersion(currentSemverVersion: string, semverSpecifier: string, preid?: string, options?: {
+    adjustSemverBumpsForZeroMajorVersion?: boolean;
+}): string;

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

@@ -0,0 +1,111 @@
+"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.SemverSpecifierType = void 0;
+exports.isRelativeVersionKeyword = isRelativeVersionKeyword;
+exports.isValidSemverSpecifier = isValidSemverSpecifier;
+exports.determineSemverChange = determineSemverChange;
+exports.deriveNewSemverVersion = deriveNewSemverVersion;
+const semver_1 = require("semver");
+exports.SemverSpecifierType = {
+    3: 'major',
+    2: 'minor',
+    1: 'patch',
+};
+function isRelativeVersionKeyword(val) {
+    return semver_1.RELEASE_TYPES.includes(val);
+}
+function isValidSemverSpecifier(specifier) {
+    return (specifier && !!((0, semver_1.valid)(specifier) || isRelativeVersionKeyword(specifier)));
+}
+function determineSemverChange(relevantCommits, config) {
+    const semverChangePerProject = new Map();
+    for (const [projectName, relevantCommit] of relevantCommits) {
+        let highestChange = null;
+        for (const { commit, isProjectScopedCommit } of relevantCommit) {
+            if (config.useCommitScope && !isProjectScopedCommit) {
+                // commit is relevant to the project, but not directly, report patch change to match side-effectful bump behavior in update dependents in release-group-processor
+                const indirectSemverType = config.types[commit.type]?.semverBump;
+                // If the commit type has semverBump 'none' and the commit is not breaking,
+                // skip the indirect patch bump as the dependency itself won't be bumped
+                if (indirectSemverType === 'none' && !commit.isBreaking) {
+                    continue;
+                }
+                highestChange = Math.max(1 /* SemverSpecifier.PATCH */, highestChange ?? 0);
+                continue;
+            }
+            const semverType = config.types[commit.type]?.semverBump;
+            if (semverType === 'major' || commit.isBreaking) {
+                highestChange = Math.max(3 /* SemverSpecifier.MAJOR */, highestChange ?? 0);
+                break; // Major is highest priority, no need to check more commits
+            }
+            else if (semverType === 'minor') {
+                highestChange = Math.max(2 /* SemverSpecifier.MINOR */, highestChange ?? 0);
+            }
+            else if (semverType === 'patch') {
+                highestChange = Math.max(1 /* SemverSpecifier.PATCH */, highestChange ?? 0);
+            }
+        }
+        semverChangePerProject.set(projectName, highestChange);
+    }
+    return semverChangePerProject;
+}
+/**
+ * For 0.x versions, shifts semver bump types down to follow
+ * the common convention where breaking changes bump minor, and
+ * new features bump patch.
+ *
+ * - 'major' -> 'minor'
+ * - 'premajor' -> 'preminor'
+ * - 'minor' -> 'patch'
+ * - 'preminor' -> 'prepatch'
+ * - 'patch' -> 'patch' (unchanged)
+ * - 'prepatch' -> 'prepatch' (unchanged)
+ * - 'prerelease' -> 'prerelease' (unchanged)
+ */
+function adjustSpecifierForZeroMajorVersion(specifier, currentVersion) {
+    // Only adjust for 0.x versions
+    if ((0, semver_1.major)(currentVersion) !== 0) {
+        return specifier;
+    }
+    switch (specifier) {
+        case 'major':
+            return 'minor';
+        case 'premajor':
+            return 'preminor';
+        case 'minor':
+            return 'patch';
+        case 'preminor':
+            return 'prepatch';
+        default:
+            return specifier;
+    }
+}
+function deriveNewSemverVersion(currentSemverVersion, semverSpecifier, preid, options) {
+    if (!(0, semver_1.valid)(currentSemverVersion)) {
+        throw new Error(`Invalid semver version "${currentSemverVersion}" provided.`);
+    }
+    let newVersion = semverSpecifier;
+    if (isRelativeVersionKeyword(semverSpecifier)) {
+        // Adjust for 0.x versions if explicitly enabled
+        const adjustedSpecifier = options?.adjustSemverBumpsForZeroMajorVersion
+            ? adjustSpecifierForZeroMajorVersion(semverSpecifier, currentSemverVersion)
+            : semverSpecifier;
+        // Derive the new version from the current version combined with the adjusted version specifier.
+        const derivedVersion = (0, semver_1.inc)(currentSemverVersion, adjustedSpecifier, preid);
+        if (!derivedVersion) {
+            throw new Error(`Unable to derive new version from current version "${currentSemverVersion}" and version specifier "${semverSpecifier}"`);
+        }
+        newVersion = derivedVersion;
+    }
+    else {
+        // Ensure the new version specifier is a valid semver version, given it is not a valid semver keyword
+        if (!(0, semver_1.valid)(semverSpecifier)) {
+            throw new Error(`Invalid semver version specifier "${semverSpecifier}" provided. Please provide either a valid semver version or a valid semver version keyword.`);
+        }
+    }
+    return newVersion;
+}

package/dist/src/command-line/release/utils/shared.d.ts

@@ -0,0 +1,64 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import type { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { GitCommit } from './git';
+import { ReleaseGraph } from './release-graph';
+export declare const noDiffInChangelogMessage: string;
+export type VersionData = Record<string, VersionDataEntry>;
+export interface VersionDataEntry {
+    currentVersion: 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;
+    /**
+     * dockerVersion will be populated if the project is a docker project and has been
+     * included within this release.
+     */
+    dockerVersion?: string | null;
+    /**
+     * The list of projects which depend upon the current project.
+     */
+    dependentProjects: {
+        source: string;
+        target: string;
+        type: string;
+        dependencyCollection: string;
+        rawVersionSpec: string;
+    }[];
+}
+export declare function isPrerelease(version: string): boolean;
+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, // optional project name to interpolate into the releaseTagPattern
+    releaseGroupName, }: {
+        version: string;
+        releaseTagPattern: string;
+        projectName?: string;
+        releaseGroupName?: string;
+    });
+}
+export declare function commitChanges({ changedFiles, deletedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs, }: {
+    changedFiles?: string[];
+    deletedFiles?: string[];
+    isDryRun?: boolean;
+    isVerbose?: boolean;
+    gitCommitMessages?: string[];
+    gitCommitArgs?: string | string[];
+}): Promise<void>;
+export declare function createCommitMessageValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData, commitMessage: string): string[];
+export declare function shouldPreferDockerVersionForReleaseGroup(releaseGroup: ReleaseGroupWithName): boolean | 'both';
+export declare function shouldSkipVersionActions(dockerOptions: {
+    skipVersionActions?: string[] | boolean;
+}, projectName: string): boolean;
+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[], nxReleaseConfig: NxReleaseConfig, releaseGraph: ReleaseGraph): Promise<Map<string, {
+    commit: GitCommit;
+    isProjectScopedCommit: boolean;
+}[]>>;