nx 21.0.0-beta.1 → 21.0.0-beta.2

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

@@ -22,7 +22,7 @@ export interface GitCommit extends RawGitCommit {
     affectedFiles: string[];
     revertedHashes: string[];
 }
-export declare function getLatestGitTagForPattern(releaseTagPattern: string, additionalInterpolationData?: {}): Promise<{
+export declare function getLatestGitTagForPattern(releaseTagPattern: string, additionalInterpolationData?: {}, checkAllBranchesWhen?: boolean | string[]): Promise<{
     tag: string;
     extractedVersion: string;
 } | null>;
@@ -50,10 +50,11 @@ export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose,
     verbose?: boolean;
     logFn?: (message: string) => void;
 }): Promise<string>;
-export declare function gitPush({ gitRemote, dryRun, verbose, }: {
+export declare function gitPush({ gitRemote, dryRun, verbose, additionalArgs, }: {
     gitRemote?: string;
     dryRun?: boolean;
     verbose?: boolean;
+    additionalArgs?: string | string[];
 }): Promise<void>;
 export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
 export declare function parseConventionalCommitsMessage(message: string): {

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

@@ -16,6 +16,7 @@ exports.getFirstGitCommit = getFirstGitCommit;
  * https://github.com/unjs/changelogen
  */
 const node_path_1 = require("node:path");
+const minimatch_1 = require("minimatch");
 const utils_1 = require("../../../tasks-runner/utils");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const exec_command_1 = require("./exec-command");
@@ -24,22 +25,69 @@ function escapeRegExp(string) {
 }
 // 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 = {}) {
+async function getLatestGitTagForPattern(releaseTagPattern, additionalInterpolationData = {}, checkAllBranchesWhen) {
+    /**
+     * By default, we will try and resolve the latest match for the releaseTagPattern from the current branch,
+     * falling back to all branches if no match is found on the current branch.
+     *
+     * - If checkAllBranchesWhen is true it will cause us to ALWAYS check all branches for the latest match.
+     * - If checkAllBranchesWhen is explicitly set to false it will cause us to ONLY check the current branch for the latest match.
+     * - If checkAllBranchesWhen is an array of strings it will cause us to check all branches WHEN the current branch is one of the strings in the array.
+     */
+    let alwaysCheckAllBranches = false;
+    if (typeof checkAllBranchesWhen !== 'undefined') {
+        if (typeof checkAllBranchesWhen === 'boolean') {
+            alwaysCheckAllBranches = checkAllBranchesWhen;
+        }
+        else if (Array.isArray(checkAllBranchesWhen)) {
+            /**
+             * Get the current git branch and determine whether to check all branches based on the checkAllBranchesWhen parameter
+             */
+            const currentBranch = await (0, exec_command_1.execCommand)('git', [
+                'rev-parse',
+                '--abbrev-ref',
+                'HEAD',
+            ]).then((r) => r.trim());
+            // Check exact match first
+            alwaysCheckAllBranches = checkAllBranchesWhen.includes(currentBranch);
+            // Check if any glob pattern matches next
+            if (!alwaysCheckAllBranches) {
+                alwaysCheckAllBranches = checkAllBranchesWhen.some((pattern) => {
+                    const r = minimatch_1.minimatch.makeRe(pattern, { dot: true });
+                    if (!r) {
+                        return false;
+                    }
+                    return r.test(currentBranch);
+                });
+            }
+        }
+    }
+    const defaultGitArgs = [
+        // Apply git config to take version suffixes into account when sorting, e.g. 1.0.0 is newer than 1.0.0-beta.1
+        '-c',
+        'versionsort.suffix=-',
+        'tag',
+        '--sort',
+        '-v:refname',
+    ];
     try {
         let tags;
         tags = await (0, exec_command_1.execCommand)('git', [
-            'tag',
-            '--sort',
-            '-v:refname',
-            '--merged',
+            ...defaultGitArgs,
+            ...(alwaysCheckAllBranches ? [] : ['--merged']),
         ]).then((r) => r
             .trim()
             .split('\n')
             .map((t) => t.trim())
             .filter(Boolean));
-        if (!tags.length) {
+        if (
+        // Do not run this fallback if the user explicitly set checkAllBranchesWhen to false
+        checkAllBranchesWhen !== false &&
+            !tags.length &&
+            // There is no point in running this fallback if we already checked against all branches
+            !alwaysCheckAllBranches) {
             // try again, but include all tags on the repo instead of just --merged ones
-            tags = await (0, exec_command_1.execCommand)('git', ['tag', '--sort', '-v:refname']).then((r) => r
+            tags = await (0, exec_command_1.execCommand)('git', defaultGitArgs).then((r) => r
                 .trim()
                 .split('\n')
                 .map((t) => t.trim())
@@ -260,7 +308,7 @@ async function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, })
         throw new Error(`Unexpected error when creating tag ${tag}:\n\n${err}`);
     }
 }
-async function gitPush({ gitRemote, dryRun, verbose, }) {
+async function gitPush({ gitRemote, dryRun, verbose, additionalArgs, }) {
     const commandArgs = [
         'push',
         // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
@@ -270,6 +318,14 @@ async function gitPush({ gitRemote, dryRun, verbose, }) {
         // Set custom git remote if provided
         ...(gitRemote ? [gitRemote] : []),
     ];
+    if (additionalArgs) {
+        if (Array.isArray(additionalArgs)) {
+            commandArgs.push(...additionalArgs);
+        }
+        else {
+            commandArgs.push(...additionalArgs.split(' '));
+        }
+    }
     if (verbose) {
         console.log(dryRun
             ? `Would push the current branch to the remote with the following command, but --dry-run was set:`
@@ -348,7 +404,7 @@ function parseGitCommit(commit, isVersionPlanCommit = false) {
             scope: '',
             references: extractReferencesFromCommitMessage(commit.message, commit.shortHash),
             // The commit message is not the source of truth for a breaking (major) change in version plans, so the value is not relevant
-            // TODO(v20): Make the current GitCommit interface more clearly tied to conventional commits
+            // TODO(v22): Make the current GitCommit interface more clearly tied to conventional commits
             isBreaking: false,
             authors: getAllAuthorsForCommit(commit),
             // Not applicable to version plans

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

@@ -198,7 +198,9 @@ async function promptForContinueInGitHub() {
         ]);
         return reply.open === 'Yes';
     }
-    catch (e) {
+    catch {
+        // Ensure the cursor is always restored before exiting
+        process.stdout.write('\u001b[?25h');
         // Handle the case where the user exits the prompt with ctrl+c
         process.exit(1);
     }

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

@@ -1,4 +1,5 @@
 import { ProjectGraph } from '../../../config/project-graph';
 import { NxReleaseConfig } from '../config/config';
+import { SemverBumpType } from '../version/version-actions';
 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>;
+export declare function resolveSemverSpecifierFromPrompt(selectionMessage: string, customVersionMessage: string): Promise<SemverBumpType | string>;

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

@@ -50,7 +50,8 @@ async function resolveSemverSpecifierFromPrompt(selectionMessage, customVersionM
         }
     }
     catch {
-        // TODO: log the error to the user?
+        // 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/src/command-line/release/utils/semver.d.ts

@@ -7,5 +7,13 @@ 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;
+/**
+ * TODO: We would be able to make the logging for the conventional commits use-case
+ * for fixed release groups more clear/precise if we passed through which project
+ * the conventional commits were detected for.
+ *
+ * It would then flow up through deriveSpecifierFromConventionalCommits back to
+ * ReleaseGroupProcessor.
+ */
 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

@@ -15,6 +15,14 @@ function isRelativeVersionKeyword(val) {
 function isValidSemverSpecifier(specifier) {
     return (specifier && !!((0, semver_1.valid)(specifier) || isRelativeVersionKeyword(specifier)));
 }
+/**
+ * TODO: We would be able to make the logging for the conventional commits use-case
+ * for fixed release groups more clear/precise if we passed through which project
+ * the conventional commits were detected for.
+ *
+ * It would then flow up through deriveSpecifierFromConventionalCommits back to
+ * ReleaseGroupProcessor.
+ */
 // https://github.com/unjs/changelogen/blob/main/src/semver.ts
 function determineSemverChange(commits, config) {
     let [hasMajor, hasMinor, hasPatch] = [false, false, false];

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

@@ -0,0 +1,25 @@
+import { Tree } from '../../../generators/tree';
+export type ReleaseVersionGeneratorResult = {
+    data: VersionData;
+    callback: (tree: Tree, opts: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        generatorOptions?: Record<string, unknown>;
+    }) => Promise<string[] | {
+        changedFiles: string[];
+        deletedFiles: 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;
+    /**
+     * The list of projects which depend upon the current project.
+     * NOTE: This is more strictly typed in versioning v2.
+     */
+    dependentProjects: any[];
+}>;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,32 +1,26 @@
 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[] | {
-        changedFiles: string[];
-        deletedFiles: string[];
-    }>;
-};
-export type VersionData = Record<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;
-    currentVersion: string;
     /**
      * The list of projects which depend upon the current project.
-     * TODO: investigate generic type for this once more ecosystems are explored
      */
-    dependentProjects: any[];
-}>;
+    dependentProjects: {
+        source: string;
+        target: string;
+        type: string;
+        dependencyCollection: string;
+        rawVersionSpec: string;
+    }[];
+}
 export declare class ReleaseVersion {
     rawVersion: string;
     gitTag: string;

package/src/command-line/release/version/derive-specifier-from-conventional-commits.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectGraph, ProjectGraphProjectNode } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { getLatestGitTagForPattern } from '../utils/git';
+import { ProjectLogger } from './project-logger';
+import { SemverBumpType } from './version-actions';
+export declare function deriveSpecifierFromConventionalCommits(nxReleaseConfig: NxReleaseConfig, projectGraph: ProjectGraph, projectLogger: ProjectLogger, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, isPrerelease: boolean, latestMatchingGitTag: Awaited<ReturnType<typeof getLatestGitTagForPattern>> | undefined, fallbackCurrentVersionResolver?: 'disk', preid?: string): Promise<SemverBumpType>;

package/src/command-line/release/version/derive-specifier-from-conventional-commits.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSpecifierFromConventionalCommits = deriveSpecifierFromConventionalCommits;
+const git_1 = require("../utils/git");
+const resolve_semver_specifier_1 = require("../utils/resolve-semver-specifier");
+async function deriveSpecifierFromConventionalCommits(nxReleaseConfig, projectGraph, projectLogger, releaseGroup, projectGraphNode, 
+// NOTE: This TODO was carried over from the original version generator.
+//
+// TODO: reevaluate this prerelease logic/workflow for independent projects
+// Always assume that if the current version is a prerelease, then the next version should be a prerelease.
+// Users must manually graduate from a prerelease to a release by providing an explicit specifier.
+isPrerelease, latestMatchingGitTag, fallbackCurrentVersionResolver, preid) {
+    const affectedProjects = releaseGroup.projectsRelationship === 'independent'
+        ? [projectGraphNode.name]
+        : releaseGroup.projects;
+    // latestMatchingGitTag will be undefined if the current version was resolved from the disk fallback.
+    // In this case, we want to use the first commit as the ref to be consistent with the changelog command.
+    const previousVersionRef = latestMatchingGitTag
+        ? latestMatchingGitTag.tag
+        : fallbackCurrentVersionResolver === 'disk'
+            ? await (0, git_1.getFirstGitCommit)()
+            : undefined;
+    if (!previousVersionRef) {
+        // This should never happen since the checks above should catch if the current version couldn't be resolved
+        throw new Error(`Unable to determine previous version ref for the projects ${affectedProjects.join(', ')}. This is likely a bug in Nx.`);
+    }
+    let specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, projectGraph, affectedProjects, nxReleaseConfig.conventionalCommits);
+    if (!specifier) {
+        projectLogger.buffer(`🚫 No changes were detected using git history and the conventional commits standard`);
+        return 'none';
+    }
+    // NOTE: This TODO was carried over from the original version generator.
+    // TODO: reevaluate this prerelease logic/workflow for independent projects
+    if (isPrerelease) {
+        specifier = 'prerelease';
+        projectLogger.buffer(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease`);
+    }
+    else {
+        let extraText = '';
+        if (preid && !specifier.startsWith('pre')) {
+            specifier = `pre${specifier}`;
+            extraText = `, combined with your given preid "${preid}"`;
+        }
+        projectLogger.buffer(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard${extraText}`);
+    }
+    return specifier;
+}

package/src/command-line/release/version/deriver-specifier-from-version-plans.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectGraphProjectNode } from '../../../config/project-graph';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { SemverBumpType } from './version-actions';
+import { ProjectLogger } from './project-logger';
+export declare function deriveSpecifierFromVersionPlan(projectLogger: ProjectLogger, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, currentVersion: string): Promise<{
+    bumpType: SemverBumpType;
+    versionPlanPath: string;
+}>;

package/src/command-line/release/version/deriver-specifier-from-version-plans.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSpecifierFromVersionPlan = deriveSpecifierFromVersionPlan;
+const semver_1 = require("semver");
+async function deriveSpecifierFromVersionPlan(projectLogger, releaseGroup, projectGraphNode, currentVersion) {
+    const projectName = projectGraphNode.name;
+    let bumpType = null;
+    let versionPlanPath = null;
+    if (releaseGroup.projectsRelationship === 'independent') {
+        const result = releaseGroup.resolvedVersionPlans.reduce((acc, plan) => {
+            if (!acc.spec) {
+                return {
+                    spec: plan.projectVersionBumps[projectName],
+                    path: plan.relativePath,
+                };
+            }
+            if (plan.projectVersionBumps[projectName]) {
+                const prevNewVersion = (0, semver_1.inc)(currentVersion, acc.spec);
+                const nextNewVersion = (0, semver_1.inc)(currentVersion, plan.projectVersionBumps[projectName]);
+                return (0, semver_1.gt)(nextNewVersion, prevNewVersion)
+                    ? {
+                        spec: plan.projectVersionBumps[projectName],
+                        path: plan.relativePath,
+                    }
+                    : acc;
+            }
+            return acc;
+        }, { spec: null, path: null });
+        bumpType = result.spec;
+        versionPlanPath = result.path;
+    }
+    else {
+        const result = releaseGroup.resolvedVersionPlans.reduce((acc, plan) => {
+            if (!acc.spec) {
+                return {
+                    spec: plan.groupVersionBump,
+                    path: plan.relativePath,
+                };
+            }
+            const prevNewVersion = (0, semver_1.inc)(currentVersion, acc.spec);
+            const nextNewVersion = (0, semver_1.inc)(currentVersion, plan.groupVersionBump);
+            return (0, semver_1.gt)(nextNewVersion, prevNewVersion)
+                ? {
+                    spec: plan.groupVersionBump,
+                    path: plan.relativePath,
+                }
+                : acc;
+        }, { spec: null, path: null });
+        bumpType = result.spec;
+        versionPlanPath = result.path;
+    }
+    if (!bumpType) {
+        projectLogger.buffer(`🚫 No changes were detected within version plans`);
+    }
+    return {
+        bumpType: bumpType ?? 'none',
+        versionPlanPath,
+    };
+}

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

@@ -0,0 +1,8 @@
+export declare class ProjectLogger {
+    private projectName;
+    private logs;
+    private color;
+    constructor(projectName: string);
+    buffer(msg: string): void;
+    flush(): void;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLogger = void 0;
+const chalk = require("chalk");
+const output_1 = require("../../../utils/output");
+const colors = [
+    { instance: chalk.green, spinnerColor: 'green' },
+    { instance: chalk.greenBright, spinnerColor: 'green' },
+    { instance: chalk.red, spinnerColor: 'red' },
+    { instance: chalk.redBright, spinnerColor: 'red' },
+    { instance: chalk.cyan, spinnerColor: 'cyan' },
+    { instance: chalk.cyanBright, spinnerColor: 'cyan' },
+    { instance: chalk.yellow, spinnerColor: 'yellow' },
+    { instance: chalk.yellowBright, spinnerColor: 'yellow' },
+    { instance: chalk.magenta, spinnerColor: 'magenta' },
+    { instance: chalk.magentaBright, spinnerColor: 'magenta' },
+];
+function getColor(projectName) {
+    let code = 0;
+    for (let i = 0; i < projectName.length; ++i) {
+        code += projectName.charCodeAt(i);
+    }
+    const colorIndex = code % colors.length;
+    return colors[colorIndex];
+}
+class ProjectLogger {
+    constructor(projectName) {
+        this.projectName = projectName;
+        this.logs = [];
+        this.color = getColor(projectName);
+    }
+    buffer(msg) {
+        this.logs.push(msg);
+    }
+    flush() {
+        if (this.logs.length === 0) {
+            return;
+        }
+        output_1.output.logSingleLine(`Running release version for project: ${this.color.instance.bold(this.projectName)}`);
+        this.logs.forEach((msg) => {
+            console.log(this.color.instance.bold(this.projectName) + ' ' + msg);
+        });
+    }
+}
+exports.ProjectLogger = ProjectLogger;