nx 20.7.1 → 20.8.0-beta.0

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

@@ -1,36 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.releaseVersionCLIHandler = exports.validReleaseVersionPrefixes = exports.deriveNewSemverVersion = void 0;
+exports.releaseVersionCLIHandler = exports.validReleaseVersionPrefixes = void 0;
 exports.createAPI = createAPI;
 const chalk = require("chalk");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const nx_json_1 = require("../../config/nx-json");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
 const tree_1 = require("../../generators/tree");
 const file_map_utils_1 = require("../../project-graph/file-map-utils");
 const project_graph_1 = require("../../project-graph/project-graph");
+const handle_errors_1 = require("../../utils/handle-errors");
 const output_1 = require("../../utils/output");
-const params_1 = require("../../utils/params");
 const path_1 = require("../../utils/path");
 const workspace_root_1 = require("../../utils/workspace-root");
-const generate_1 = require("../generate/generate");
-const generator_utils_1 = require("../generate/generator-utils");
 const config_1 = require("./config/config");
 const deep_merge_json_1 = require("./config/deep-merge-json");
 const filter_release_groups_1 = require("./config/filter-release-groups");
 const version_plans_1 = require("./config/version-plans");
-const batch_projects_by_generator_config_1 = require("./utils/batch-projects-by-generator-config");
 const git_1 = require("./utils/git");
 const print_changes_1 = require("./utils/print-changes");
 const print_config_1 = require("./utils/print-config");
 const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
 const shared_1 = require("./utils/shared");
-const handle_errors_1 = require("../../utils/handle-errors");
+const version_legacy_1 = require("./version-legacy");
+const release_group_processor_1 = require("./version/release-group-processor");
+const use_legacy_versioning_1 = require("./config/use-legacy-versioning");
 const LARGE_BUFFER = 1024 * 1000000;
 // Reexport some utils for use in plugin release-version generator implementations
-var semver_1 = require("./utils/semver");
-Object.defineProperty(exports, "deriveNewSemverVersion", { enumerable: true, get: function () { return semver_1.deriveNewSemverVersion; } });
 exports.validReleaseVersionPrefixes = ['auto', '', '~', '^', '='];
 const releaseVersionCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args));
 exports.releaseVersionCLIHandler = releaseVersionCLIHandler;
@@ -42,13 +39,13 @@ function createAPI(overrideReleaseConfig) {
      */
     return async function releaseVersion(args) {
         const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
-        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
         const nxJson = (0, nx_json_1.readNxJson)();
         const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        const USE_LEGACY_VERSIONING = (0, use_legacy_versioning_1.shouldUseLegacyVersioning)(userProvidedReleaseConfig);
         // Apply default configuration to any optional user configuration
         const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
         if (configError) {
-            return await (0, config_1.handleNxReleaseConfigError)(configError);
+            return await (0, config_1.handleNxReleaseConfigError)(configError, USE_LEGACY_VERSIONING);
         }
         // --print-config exits directly as it is not designed to be combined with any other programmatic operations
         if (args.printConfig) {
@@ -58,6 +55,10 @@ function createAPI(overrideReleaseConfig) {
                 isDebug: args.printConfig === 'debug',
             });
         }
+        // TODO(v22): Remove support for the legacy versioning implementation in Nx v22
+        if (USE_LEGACY_VERSIONING) {
+            return await (0, version_legacy_1.releaseVersionLegacy)(projectGraph, args, nxJson, nxReleaseConfig, userProvidedReleaseConfig);
+        }
         // The nx release top level command will always override these three git args. This is how we can tell
         // if the top level release command was used or if the user is using the changelog subcommand.
         // If the user explicitly overrides these args, then it doesn't matter if the top level config is set,
@@ -98,169 +99,71 @@ function createAPI(overrideReleaseConfig) {
             // default to not delete version plans after versioning as they may be needed for changelog generation
             args.deleteVersionPlans = false;
         }
+        /**
+         * Run any configured top level pre-version command
+         */
         runPreVersionCommand(nxReleaseConfig.version.preVersionCommand, {
             dryRun: args.dryRun,
             verbose: args.verbose,
         });
+        /**
+         * Run any configured pre-version command for the selected release groups
+         */
+        for (const releaseGroup of releaseGroups) {
+            runPreVersionCommand(releaseGroup.version.groupPreVersionCommand, {
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            }, releaseGroup);
+        }
         const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-        const versionData = {};
         const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
-        const generatorCallbacks = [];
         /**
          * additionalChangedFiles are files which need to be updated as a side-effect of versioning (such as package manager lock files),
          * and need to get staged and committed as part of the existing commit, if applicable.
          */
         const additionalChangedFiles = new Set();
         const additionalDeletedFiles = new Set();
-        if (args.projects?.length) {
-            /**
-             * Run versioning for all remaining release groups and filtered projects within them
-             */
-            for (const releaseGroup of releaseGroups) {
-                const releaseGroupName = releaseGroup.name;
-                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-                const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
-                // Only batch based on the filtered projects within the release group
-                releaseGroupProjectNames);
-                for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
-                    const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
-                    // Resolve the generator for the batch and run versioning on the projects within the batch
-                    const generatorData = resolveGeneratorData({
-                        ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
-                        configGeneratorOptions: generatorOptions,
-                        // all project data from the project graph (not to be confused with projectNamesToRunVersionOn)
-                        projects,
-                    });
-                    const generatorCallback = await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, args.generatorOptionsOverrides, projectNames, releaseGroup, versionData, nxReleaseConfig.conventionalCommits);
-                    // Capture the callback so that we can run it after flushing the changes to disk
-                    generatorCallbacks.push(async () => {
-                        const result = await generatorCallback(tree, {
-                            dryRun: !!args.dryRun,
-                            verbose: !!args.verbose,
-                            generatorOptions: {
-                                ...generatorOptions,
-                                ...args.generatorOptionsOverrides,
-                            },
-                        });
-                        const { changedFiles, deletedFiles } = parseGeneratorCallbackResult(result);
-                        changedFiles.forEach((f) => additionalChangedFiles.add(f));
-                        deletedFiles.forEach((f) => additionalDeletedFiles.add(f));
-                    });
-                }
-            }
-            // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
-            const gitTagValues = args.gitTag ?? nxReleaseConfig.version.git.tag
-                ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
-                : [];
-            (0, shared_1.handleDuplicateGitTags)(gitTagValues);
-            printAndFlushChanges(tree, !!args.dryRun);
-            for (const generatorCallback of generatorCallbacks) {
-                await generatorCallback();
-            }
-            const changedFiles = [
-                ...tree.listChanges().map((f) => f.path),
-                ...additionalChangedFiles,
-            ];
-            // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
-            if (!changedFiles.length) {
-                return {
-                    // An overall workspace version cannot be relevant when filtering to independent projects
-                    workspaceVersion: undefined,
-                    projectsVersionData: versionData,
-                };
-            }
-            if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
-                await (0, shared_1.commitChanges)({
-                    changedFiles,
-                    deletedFiles: Array.from(additionalDeletedFiles),
-                    isDryRun: !!args.dryRun,
-                    isVerbose: !!args.verbose,
-                    gitCommitMessages: (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
-                    gitCommitArgs: args.gitCommitArgs || nxReleaseConfig.version.git.commitArgs,
-                });
-            }
-            else if (args.stageChanges ??
-                nxReleaseConfig.version.git.stageChanges) {
-                output_1.output.logSingleLine(`Staging changed files with git`);
-                await (0, git_1.gitAdd)({
-                    changedFiles,
-                    dryRun: args.dryRun,
-                    verbose: args.verbose,
-                });
-            }
-            if (args.gitTag ?? nxReleaseConfig.version.git.tag) {
-                output_1.output.logSingleLine(`Tagging commit with git`);
-                for (const tag of gitTagValues) {
-                    await (0, git_1.gitTag)({
-                        tag,
-                        message: args.gitTagMessage || nxReleaseConfig.version.git.tagMessage,
-                        additionalArgs: args.gitTagArgs || nxReleaseConfig.version.git.tagArgs,
-                        dryRun: args.dryRun,
-                        verbose: args.verbose,
-                    });
-                }
-            }
-            if (args.gitPush ?? nxReleaseConfig.version.git.push) {
-                output_1.output.logSingleLine(`Pushing to git remote "${args.gitRemote}"`);
-                await (0, git_1.gitPush)({
-                    gitRemote: args.gitRemote,
-                    dryRun: args.dryRun,
-                    verbose: args.verbose,
-                });
+        const processor = new release_group_processor_1.ReleaseGroupProcessor(tree, projectGraph, nxReleaseConfig, releaseGroups, releaseGroupToFilteredProjects, {
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+            firstRelease: args.firstRelease,
+            preid: args.preid ?? '',
+            userGivenSpecifier: args.specifier,
+            filters: {
+                projects: args.projects,
+                groups: args.groups,
+            },
+        });
+        try {
+            await processor.init();
+            await processor.processGroups();
+            // Delete processed version plan files if applicable
+            if (args.deleteVersionPlans) {
+                processor.deleteProcessedVersionPlanFiles();
             }
-            return {
-                // An overall workspace version cannot be relevant when filtering to independent projects
-                workspaceVersion: undefined,
-                projectsVersionData: versionData,
-            };
+        }
+        catch (err) {
+            // Flush any pending project logs before printing the error to make troubleshooting easier
+            processor.flushAllProjectLoggers();
+            // Bubble up the error so that the CLI can print the error and exit, or the programmatic API can handle it
+            throw err;
         }
         /**
-         * Run versioning for all remaining release groups
+         * Ensure that formatting is applied so that version bump diffs are as minimal as possible
+         * within the context of the user's workspace.
          */
-        for (const releaseGroup of releaseGroups) {
-            const releaseGroupName = releaseGroup.name;
-            runPreVersionCommand(releaseGroup.version.groupPreVersionCommand, {
-                dryRun: args.dryRun,
-                verbose: args.verbose,
-            }, releaseGroup);
-            const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
-            // Batch based on all projects within the release group
-            releaseGroup.projects);
-            for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
-                const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
-                // Resolve the generator for the batch and run versioning on the projects within the batch
-                const generatorData = resolveGeneratorData({
-                    ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
-                    configGeneratorOptions: generatorOptions,
-                    // all project data from the project graph (not to be confused with projectNamesToRunVersionOn)
-                    projects,
-                });
-                const generatorCallback = await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, args.generatorOptionsOverrides, projectNames, releaseGroup, versionData, nxReleaseConfig.conventionalCommits);
-                // Capture the callback so that we can run it after flushing the changes to disk
-                generatorCallbacks.push(async () => {
-                    const result = await generatorCallback(tree, {
-                        dryRun: !!args.dryRun,
-                        verbose: !!args.verbose,
-                        generatorOptions: {
-                            ...generatorOptions,
-                            ...args.generatorOptionsOverrides,
-                        },
-                    });
-                    const { changedFiles, deletedFiles } = parseGeneratorCallbackResult(result);
-                    changedFiles.forEach((f) => additionalChangedFiles.add(f));
-                    deletedFiles.forEach((f) => additionalDeletedFiles.add(f));
-                });
-            }
-        }
+        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, { silent: true });
+        const versionData = processor.getVersionData();
         // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
         const gitTagValues = args.gitTag ?? nxReleaseConfig.version.git.tag
             ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
             : [];
         (0, shared_1.handleDuplicateGitTags)(gitTagValues);
         printAndFlushChanges(tree, !!args.dryRun);
-        for (const generatorCallback of generatorCallbacks) {
-            await generatorCallback();
-        }
+        const { changedFiles: changed, deletedFiles: deleted } = await processor.afterAllProjectsVersioned(nxReleaseConfig.version
+            .versionActionsOptions);
+        changed.forEach((f) => additionalChangedFiles.add(f));
+        deleted.forEach((f) => additionalDeletedFiles.add(f));
         // Only applicable when there is a single release group with a fixed relationship
         let workspaceVersion = undefined;
         if (releaseGroups.length === 1) {
@@ -314,11 +217,12 @@ function createAPI(overrideReleaseConfig) {
             }
         }
         if (args.gitPush ?? nxReleaseConfig.version.git.push) {
-            output_1.output.logSingleLine(`Pushing to git remote "${args.gitRemote}"`);
+            output_1.output.logSingleLine(`Pushing to git remote "${args.gitRemote ?? 'origin'}"`);
             await (0, git_1.gitPush)({
                 gitRemote: args.gitRemote,
                 dryRun: args.dryRun,
                 verbose: args.verbose,
+                additionalArgs: args.gitPushArgs || nxReleaseConfig.version.git.pushArgs,
             });
         }
         return {
@@ -327,109 +231,34 @@ function createAPI(overrideReleaseConfig) {
         };
     };
 }
-function appendVersionData(existingVersionData, newVersionData) {
-    // Mutate the existing version data
-    for (const [key, value] of Object.entries(newVersionData)) {
-        if (existingVersionData[key]) {
-            throw new Error(`Version data key "${key}" already exists in version data. This is likely a bug, please report your use-case on https://github.com/nrwl/nx`);
-        }
-        existingVersionData[key] = value;
-    }
-    return existingVersionData;
-}
-async function runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, generatorOverrides, projectNames, releaseGroup, versionData, conventionalCommitsConfig) {
-    const generatorOptions = {
-        // Always ensure a string to avoid generator schema validation errors
-        specifier: args.specifier ?? '',
-        preid: args.preid ?? '',
-        ...generatorData.configGeneratorOptions,
-        ...(generatorOverrides ?? {}),
-        // The following are not overridable by user config
-        projects: projectNames.map((p) => projectGraph.nodes[p]),
-        projectGraph,
-        releaseGroup,
-        firstRelease: args.firstRelease ?? false,
-        conventionalCommitsConfig,
-        deleteVersionPlans: args.deleteVersionPlans,
-    };
-    // Apply generator defaults from schema.json file etc
-    const combinedOpts = await (0, params_1.combineOptionsForGenerator)(generatorOptions, generatorData.collectionName, generatorData.normalizedGeneratorName, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson, generatorData.schema, false, null, (0, node_path_1.relative)(process.cwd(), workspace_root_1.workspaceRoot), args.verbose);
-    const releaseVersionGenerator = generatorData.implementationFactory();
-    // We expect all version generator implementations to return a ReleaseVersionGeneratorResult object, rather than a GeneratorCallback
-    const versionResult = (await releaseVersionGenerator(tree, combinedOpts));
-    if (typeof versionResult === 'function') {
-        throw new Error(`The version generator ${generatorData.collectionName}:${generatorData.normalizedGeneratorName} returned a function instead of an expected ReleaseVersionGeneratorResult`);
-    }
-    // Merge the extra version data into the existing
-    appendVersionData(versionData, versionResult.data);
-    return versionResult.callback;
-}
 function printAndFlushChanges(tree, isDryRun) {
     const changes = tree.listChanges();
     console.log('');
-    // Print the changes
-    changes.forEach((f) => {
-        if (f.type === 'CREATE') {
-            console.error(`${chalk.green('CREATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
-            (0, print_changes_1.printDiff)('', f.content?.toString() || '');
-        }
-        else if (f.type === 'UPDATE') {
-            console.error(`${chalk.white('UPDATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
-            const currentContentsOnDisk = (0, node_fs_1.readFileSync)((0, path_1.joinPathFragments)(tree.root, f.path)).toString();
-            (0, print_changes_1.printDiff)(currentContentsOnDisk, f.content?.toString() || '');
-        }
-        else if (f.type === 'DELETE' && !f.path.includes('.nx')) {
-            throw new Error('Unexpected DELETE change, please report this as an issue');
-        }
-    });
-    if (!isDryRun) {
-        (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
-    }
-}
-function extractGeneratorCollectionAndName(description, generatorString) {
-    let collectionName;
-    let generatorName;
-    const parsedGeneratorString = (0, generate_1.parseGeneratorString)(generatorString);
-    collectionName = parsedGeneratorString.collection;
-    generatorName = parsedGeneratorString.generator;
-    if (!collectionName || !generatorName) {
-        throw new Error(`Invalid generator string: ${generatorString} used for ${description}. Must be in the format of [collectionName]:[generatorName]`);
-    }
-    return { collectionName, generatorName };
-}
-function resolveGeneratorData({ collectionName, generatorName, configGeneratorOptions, projects, }) {
-    try {
-        const { normalizedGeneratorName, schema, implementationFactory } = (0, generator_utils_1.getGeneratorInformation)(collectionName, generatorName, workspace_root_1.workspaceRoot, projects);
-        return {
-            collectionName,
-            generatorName,
-            configGeneratorOptions,
-            normalizedGeneratorName,
-            schema,
-            implementationFactory,
-        };
-    }
-    catch (err) {
-        if (err.message.startsWith('Unable to resolve')) {
-            // See if it is because the plugin is not installed
-            try {
-                require.resolve(collectionName);
-                // is installed
-                throw new Error(`Unable to resolve the generator called "${generatorName}" within the "${collectionName}" package`);
+    if (changes.length > 0) {
+        // Print the changes
+        changes.forEach((f) => {
+            if (f.type === 'CREATE') {
+                console.error(`${chalk.green('CREATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+                (0, print_changes_1.printDiff)('', f.content?.toString() || '');
             }
-            catch {
-                /**
-                 * Special messaging for the most common case (especially as the user is unlikely to explicitly have
-                 * the @nx/js generator config in their nx.json so we need to be clear about what the problem is)
-                 */
-                if (collectionName === '@nx/js') {
-                    throw new Error('The @nx/js plugin is required in order to version your JavaScript packages. Run "nx add @nx/js" to add it to your workspace.');
-                }
-                throw new Error(`Unable to resolve the package ${collectionName} in order to load the generator called ${generatorName}. Is the package installed?`);
+            else if (f.type === 'UPDATE') {
+                console.error(`${chalk.white('UPDATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+                const currentContentsOnDisk = (0, node_fs_1.readFileSync)((0, path_1.joinPathFragments)(tree.root, f.path)).toString();
+                (0, print_changes_1.printDiff)(currentContentsOnDisk, f.content?.toString() || '');
             }
-        }
-        // Unexpected error, rethrow
-        throw err;
+            else if (f.type === 'DELETE' && !f.path.includes('.nx')) {
+                throw new Error('Unexpected DELETE change, please report this as an issue');
+            }
+        });
+    }
+    else {
+        let text = isDryRun ? ' would be ' : ' ';
+        output_1.output.warn({
+            title: `No files${text}changed as a result of running versioning`,
+        });
+    }
+    if (!isDryRun) {
+        (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
     }
 }
 function runPreVersionCommand(preVersionCommand, { dryRun, verbose }, releaseGroup) {
@@ -470,14 +299,3 @@ function runPreVersionCommand(preVersionCommand, { dryRun, verbose }, releaseGro
         process.exit(1);
     }
 }
-function parseGeneratorCallbackResult(result) {
-    if (Array.isArray(result)) {
-        return {
-            changedFiles: result,
-            deletedFiles: [],
-        };
-    }
-    else {
-        return result;
-    }
-}

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

@@ -1,4 +1,5 @@
 import type { ChangelogRenderOptions } from '../../release/changelog-renderer';
+import { validReleaseVersionPrefixes } from '../command-line/release/version';
 import type { PackageManager } from '../utils/package-manager';
 import type { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
 export type ImplicitDependencyEntry<T = '*' | string[]> = {
@@ -35,6 +36,12 @@ interface NxInstallationConfiguration {
      */
     plugins?: Record<string, string>;
 }
+/**
+ * This named configuration interface will be changing in Nx v21. This interface will be made available
+ * under LegacyNxReleaseVersionConfiguration, which is already available as an alias.
+ *
+ * In Nx v22, this configuration interface will no longer be valid.
+ */
 export interface NxReleaseVersionConfiguration {
     generator?: string;
     generatorOptions?: Record<string, unknown>;
@@ -50,6 +57,100 @@ export interface NxReleaseVersionConfiguration {
      */
     conventionalCommits?: boolean;
 }
+export type LegacyNxReleaseVersionConfiguration = NxReleaseVersionConfiguration;
+export interface NxReleaseVersionV2Configuration {
+    /**
+     * Whether to use the legacy versioning strategy. This value will be true in Nx v20 and false in Nx v21.
+     * The legacy versioning implementation will be removed in Nx v22, as will this flag.
+     */
+    useLegacyVersioning?: boolean;
+    /**
+     * Shorthand for enabling the current version of projects to be resolved from git tags,
+     * and the next version to be determined by analyzing commit messages according to the
+     * Conventional Commits specification.
+     */
+    conventionalCommits?: boolean;
+    /**
+     * A command to run after validation of nx release configuration, but before versioning begins.
+     * Useful for preparing build artifacts. If --dry-run is passed, the command is still executed,
+     * but with the NX_DRY_RUN environment variable set to 'true'.
+     */
+    preVersionCommand?: string;
+    /**
+     * The source to use for determining the specifier to use when versioning.
+     * 'prompt' is the default and will interactively prompt the user for an explicit/imperative specifier.
+     * 'conventional-commits' will attempt determine a specifier from commit messages conforming to the Conventional Commits specification.
+     * 'version-plans' will determine the specifier from the version plan files available on disk.
+     */
+    specifierSource?: 'prompt' | 'conventional-commits' | 'version-plans';
+    /**
+     * A list of directories containing manifest files (such as package.json) to apply updates to when versioning.
+     *
+     * By default, only the project root will be used, but you could customize this to only version a manifest in a
+     * dist directory, or even version multiple manifests in different directories, such as both source and dist.
+     */
+    manifestRootsToUpdate?: string[];
+    /**
+     * The resolver to use for determining the current version of a project during versioning.
+     * This is needed for versioning approaches which involve relatively modifying a current version
+     * to arrive at a new version, such as semver bumps like 'patch', 'minor' etc.
+     *
+     * Using 'none' explicitly declares that the current version is not needed to compute the new version, and
+     * should only be used with appropriate version actions implementations that support it.
+     */
+    currentVersionResolver?: 'registry' | 'disk' | 'git-tag' | 'none';
+    /**
+     * Metadata to provide to the configured currentVersionResolver to help it in determining the current version.
+     * What to pass here is specific to each resolver.
+     */
+    currentVersionResolverMetadata?: Record<string, unknown>;
+    /**
+     * The fallback version resolver to use when the configured currentVersionResolver fails to resolve the current version.
+     */
+    fallbackCurrentVersionResolver?: 'disk';
+    /**
+     * Whether or not this is the first release of one of more projects.
+     * This removes certain validation checks that are not possible to enforce if the project has never been released before.
+     */
+    firstRelease?: boolean;
+    /**
+     * The prefix to use when versioning dependencies.
+     * This can be one of the following: auto, '', '~', '^', '=', where auto means the existing prefix will be preserved.
+     */
+    versionPrefix?: (typeof validReleaseVersionPrefixes)[number];
+    /**
+     * Whether to delete the processed version plans file after versioning is complete. This is false by default because the
+     * version plans are also needed for changelog generation.
+     */
+    deleteVersionPlans?: boolean;
+    /**
+     * When versioning independent projects, this controls whether to update their dependents (i.e. the things that depend on them).
+     * 'never' means no dependents will be updated (unless they happen to be versioned directly as well).
+     * 'auto' is the default and will cause dependents to be updated (a patch version bump) when a dependency is versioned.
+     */
+    updateDependents?: 'auto' | 'never';
+    /**
+     * Whether to log projects that have not changed during versioning.
+     */
+    logUnchangedProjects?: boolean;
+    /**
+     * The path to the version actions implementation to use for releasing all projects by default.
+     * This can also be overridden on the release group and project levels.
+     */
+    versionActions?: string;
+    /**
+     * The specific options that are defined by each version actions implementation.
+     * They will be passed to the version actions implementation when running a release.
+     */
+    versionActionsOptions?: Record<string, unknown>;
+    /**
+     * Whether to preserve local dependency protocols (e.g. file references, or the `workspace:` protocol in package.json files)
+     * of local dependencies when updating them during versioning.
+     *
+     * This was false by default in legacy versioning, but is true by default now.
+     */
+    preserveLocalDependencyProtocols?: boolean;
+}
 export interface NxReleaseChangelogConfiguration {
     /**
      * Optionally create a release containing all relevant changes on a supported version control system, it
@@ -131,6 +232,10 @@ export interface NxReleaseGitConfiguration {
      * Whether or not to automatically push the changes made by this command to the remote git repository.
      */
     push?: boolean;
+    /**
+     * Additional arguments to pass to the `git push` command invoked behind the scenes. May be a string or array of strings.
+     */
+    pushArgs?: string | string[];
 }
 export interface NxReleaseConventionalCommitsConfiguration {
     types?: Record<string, 
@@ -190,7 +295,7 @@ export interface NxReleaseConfiguration {
          *
          * NOTE: git configuration is not supported at the group level, only the root/command level
          */
-        version?: NxReleaseVersionConfiguration & {
+        version?: (LegacyNxReleaseVersionConfiguration | NxReleaseVersionV2Configuration) & {
             /**
              * A command to run after validation of nx release configuration, but before versioning begins.
              * Used for preparing build artifacts. If --dry-run is passed, the command is still executed, but
@@ -264,19 +369,12 @@ export interface NxReleaseConfiguration {
         automaticFromRef?: boolean;
     };
     /**
-     * If no version config is provided, we will assume that @nx/js:release-version
-     * is the desired generator implementation, allowing for terser config for the common case.
+     * If no version configuration is provided, we will assume that TypeScript/JavaScript experience is what is desired,
+     * allowing for terser release configuration for the common case.
      */
-    version?: NxReleaseVersionConfiguration & {
-        /**
-         * Enable or override configuration for git operations as part of the version subcommand
-         */
+    version?: (LegacyNxReleaseVersionConfiguration | NxReleaseVersionV2Configuration) & {
+        useLegacyVersioning?: boolean;
         git?: NxReleaseGitConfiguration;
-        /**
-         * A command to run after validation of nx release configuration, but before versioning begins.
-         * Used for preparing build artifacts. If --dry-run is passed, the command is still executed, but
-         * with the NX_DRY_RUN environment variable set to 'true'.
-         */
         preVersionCommand?: string;
     };
     /**

package/src/config/workspace-json-project-json.d.ts

@@ -1,5 +1,5 @@
 import type { PackageJson } from '../utils/package-json';
-import type { NxJsonConfiguration, NxReleaseVersionConfiguration } from './nx-json';
+import type { NxJsonConfiguration, NxReleaseVersionConfiguration, NxReleaseVersionV2Configuration } from './nx-json';
 /**
  * @deprecated use ProjectsConfigurations or NxJsonConfiguration
  */
@@ -98,7 +98,7 @@ export interface ProjectConfiguration {
      * Project specific configuration for `nx release`
      */
     release?: {
-        version?: Pick<NxReleaseVersionConfiguration, 'generator' | 'generatorOptions'>;
+        version?: Pick<NxReleaseVersionConfiguration, 'generator' | 'generatorOptions'> | Pick<NxReleaseVersionV2Configuration, 'versionActions' | 'versionActionsOptions' | 'manifestRootsToUpdate' | 'currentVersionResolver' | 'currentVersionResolverMetadata' | 'fallbackCurrentVersionResolver' | 'versionPrefix' | 'preserveLocalDependencyProtocols'>;
     };
     /**
      * Metadata about the project