nx 17.0.3 → 17.0.5

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

@@ -1,109 +1,294 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.versionHandler = exports.deriveNewSemverVersion = void 0;
+exports.releaseVersion = exports.releaseVersionCLIHandler = exports.validReleaseVersionPrefixes = exports.deriveNewSemverVersion = void 0;
 const chalk = require("chalk");
-const enquirer = require("enquirer");
+const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const semver_1 = require("semver");
 const nx_json_1 = require("../../config/nx-json");
-const devkit_exports_1 = require("../../devkit-exports");
 const tree_1 = require("../../generators/tree");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
 const project_graph_1 = require("../../project-graph/project-graph");
+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 filter_release_groups_1 = require("./config/filter-release-groups");
+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 semver_2 = require("./utils/semver");
-// Reexport for use in plugin release-version generator implementations
-var semver_3 = require("./utils/semver");
-Object.defineProperty(exports, "deriveNewSemverVersion", { enumerable: true, get: function () { return semver_3.deriveNewSemverVersion; } });
-async function versionHandler(args) {
+const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
+const shared_1 = require("./utils/shared");
+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, params_1.handleErrors)(args.verbose, () => releaseVersion(args));
+exports.releaseVersionCLIHandler = releaseVersionCLIHandler;
+/**
+ * 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.
+ */
+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)();
     if (args.verbose) {
         process.env.NX_VERBOSE_LOGGING = 'true';
     }
     // Apply default configuration to any optional user configuration
-    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, nxJson.release, 'nx-release-publish');
+    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), nxJson.release);
     if (configError) {
         return await (0, config_1.handleNxReleaseConfigError)(configError);
     }
+    // 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,
+    // as all of the git options would be overridden anyway.
+    if ((args.gitCommit === undefined ||
+        args.gitTag === undefined ||
+        args.stageChanges === undefined) &&
+        nxJson.release?.git) {
+        const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+            'release',
+            'git',
+        ]);
+        output_1.output.error({
+            title: `The "release.git" property in nx.json may not be used with the "nx release version" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`,
+            bodyLines: [nxJsonMessage],
+        });
+        process.exit(1);
+    }
     const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
     if (filterError) {
-        devkit_exports_1.output.error(filterError);
+        output_1.output.error(filterError);
         process.exit(1);
     }
-    const tree = new tree_1.FsTree(devkit_exports_1.workspaceRoot, args.verbose);
+    runPreVersionCommand(nxReleaseConfig.version.preVersionCommand, {
+        dryRun: args.dryRun,
+        verbose: args.verbose,
+    });
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+    const versionData = {};
+    const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
+    const additionalChangedFiles = new Set();
+    const generatorCallbacks = [];
     if (args.projects?.length) {
         /**
-         * Run semver versioning for all remaining release groups and filtered projects within them
+         * Run versioning for all remaining release groups and filtered projects within them
          */
         for (const releaseGroup of releaseGroups) {
             const releaseGroupName = releaseGroup.name;
-            // Resolve the generator data for the current release group
-            const generatorData = resolveGeneratorData({
-                ...extractGeneratorCollectionAndName(`release-group "${releaseGroupName}"`, releaseGroup.version.generator),
-                configGeneratorOptions: releaseGroup.version.generatorOptions,
+            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 changedFiles = await generatorCallback(tree, {
+                        dryRun: !!args.dryRun,
+                        verbose: !!args.verbose,
+                        generatorOptions: {
+                            ...generatorOptions,
+                            ...args.generatorOptionsOverrides,
+                        },
+                    });
+                    changedFiles.forEach((f) => additionalChangedFiles.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, !!args.dryRun, !!args.verbose, (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage), 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,
             });
-            const semverSpecifier = await resolveSemverSpecifier(args.specifier, `What kind of change is this for the ${releaseGroupToFilteredProjects.get(releaseGroup).size} matched project(s) within release group "${releaseGroupName}"?`, `What is the exact version for the ${releaseGroupToFilteredProjects.get(releaseGroup).size} matched project(s) within release group "${releaseGroupName}"?`);
-            await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, Array.from(releaseGroupToFilteredProjects.get(releaseGroup)), semverSpecifier);
         }
-        printChanges(tree, !!args.dryRun);
-        return process.exit(0);
+        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,
+                });
+            }
+        }
+        return {
+            // An overall workspace version cannot be relevant when filtering to independent projects
+            workspaceVersion: undefined,
+            projectsVersionData: versionData,
+        };
     }
     /**
-     * Run semver versioning for all remaining release groups
+     * Run versioning for all remaining release groups
      */
     for (const releaseGroup of releaseGroups) {
         const releaseGroupName = releaseGroup.name;
-        // Resolve the generator data for the current release group
-        const generatorData = resolveGeneratorData({
-            ...extractGeneratorCollectionAndName(`release-group "${releaseGroupName}"`, releaseGroup.version.generator),
-            configGeneratorOptions: releaseGroup.version.generatorOptions,
-        });
-        const semverSpecifier = await resolveSemverSpecifier(args.specifier, releaseGroupName === config_1.CATCH_ALL_RELEASE_GROUP
-            ? `What kind of change is this for all packages?`
-            : `What kind of change is this for release group "${releaseGroupName}"?`, releaseGroupName === config_1.CATCH_ALL_RELEASE_GROUP
-            ? `What is the exact version for all packages?`
-            : `What is the exact version for release group "${releaseGroupName}"?`);
-        await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, releaseGroup.projects, semverSpecifier);
-    }
-    printChanges(tree, !!args.dryRun);
-    process.exit(0);
-}
-exports.versionHandler = versionHandler;
-async function runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, projectNames, newVersionSpecifier) {
-    // Should be impossible state
-    if (!newVersionSpecifier) {
-        devkit_exports_1.output.error({
-            title: `No version or semver keyword could be determined`,
-        });
-        process.exit(1);
+        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 changedFiles = await generatorCallback(tree, {
+                    dryRun: !!args.dryRun,
+                    verbose: !!args.verbose,
+                    generatorOptions: {
+                        ...generatorOptions,
+                        ...args.generatorOptionsOverrides,
+                    },
+                });
+                changedFiles.forEach((f) => additionalChangedFiles.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();
+    }
+    // Only applicable when there is a single release group with a fixed relationship
+    let workspaceVersion = undefined;
+    if (releaseGroups.length === 1) {
+        const releaseGroup = releaseGroups[0];
+        if (releaseGroup.projectsRelationship === 'fixed') {
+            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+            workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion; // all projects have the same version so we can just grab the first
+        }
+    }
+    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 {
+            workspaceVersion,
+            projectsVersionData: versionData,
+        };
+    }
+    if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
+        await (0, shared_1.commitChanges)(changedFiles, !!args.dryRun, !!args.verbose, (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage), args.gitCommitArgs || nxReleaseConfig.version.git.commitArgs);
     }
-    // Specifier could be user provided so we need to validate it
-    if (!(0, semver_1.valid)(newVersionSpecifier) &&
-        !(0, semver_2.isRelativeVersionKeyword)(newVersionSpecifier)) {
-        devkit_exports_1.output.error({
-            title: `The given version specifier "${newVersionSpecifier}" is not valid. You provide an exact version or a valid semver keyword such as "major", "minor", "patch", etc.`,
+    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,
         });
-        process.exit(1);
     }
+    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,
+            });
+        }
+    }
+    return {
+        workspaceVersion,
+        projectsVersionData: versionData,
+    };
+}
+exports.releaseVersion = releaseVersion;
+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.`);
+        }
+        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,
-        specifier: newVersionSpecifier,
-        preid: args.preid,
-        ...generatorData.configGeneratorOptions,
+        releaseGroup,
+        firstRelease: args.firstRelease ?? false,
+        conventionalCommitsConfig,
     };
     // 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(), devkit_exports_1.workspaceRoot), args.verbose);
+    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();
-    await releaseVersionGenerator(tree, combinedOpts);
+    // 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 printChanges(tree, isDryRun) {
+function printAndFlushChanges(tree, isDryRun) {
     const changes = tree.listChanges();
     console.log('');
     // Print the changes
@@ -114,7 +299,7 @@ function printChanges(tree, isDryRun) {
         }
         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, devkit_exports_1.joinPathFragments)(tree.root, f.path)).toString();
+            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') {
@@ -122,56 +307,7 @@ function printChanges(tree, isDryRun) {
         }
     });
     if (!isDryRun) {
-        (0, tree_1.flushChanges)(devkit_exports_1.workspaceRoot, changes);
-    }
-    if (isDryRun) {
-        devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
-    }
-}
-async function resolveSemverSpecifier(cliArgSpecifier, selectionMessage, customVersionMessage) {
-    try {
-        let newVersionSpecifier = cliArgSpecifier;
-        // If the user didn't provide a new version specifier directly on the CLI, prompt for one
-        if (!newVersionSpecifier) {
-            const reply = await enquirer.prompt([
-                {
-                    name: 'specifier',
-                    message: selectionMessage,
-                    type: 'select',
-                    choices: [
-                        ...semver_1.RELEASE_TYPES.map((t) => ({ name: t, message: t })),
-                        {
-                            name: 'custom',
-                            message: 'Custom exact version',
-                        },
-                    ],
-                },
-            ]);
-            if (reply.specifier !== 'custom') {
-                newVersionSpecifier = reply.specifier;
-            }
-            else {
-                const reply = await enquirer.prompt([
-                    {
-                        name: 'specifier',
-                        message: customVersionMessage,
-                        type: 'input',
-                        validate: (input) => {
-                            if ((0, semver_1.valid)(input)) {
-                                return true;
-                            }
-                            return 'Please enter a valid semver version';
-                        },
-                    },
-                ]);
-                newVersionSpecifier = reply.specifier;
-            }
-        }
-        return newVersionSpecifier;
-    }
-    catch {
-        // We need to catch the error from enquirer prompt, otherwise yargs will print its help
-        process.exit(1);
+        (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
     }
 }
 function extractGeneratorCollectionAndName(description, generatorString) {
@@ -185,14 +321,73 @@ function extractGeneratorCollectionAndName(description, generatorString) {
     }
     return { collectionName, generatorName };
 }
-function resolveGeneratorData({ collectionName, generatorName, configGeneratorOptions, }) {
-    const { normalizedGeneratorName, schema, implementationFactory } = (0, generator_utils_1.getGeneratorInformation)(collectionName, generatorName, devkit_exports_1.workspaceRoot);
-    return {
-        collectionName,
-        generatorName,
-        configGeneratorOptions,
-        normalizedGeneratorName,
-        schema,
-        implementationFactory,
+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`);
+            }
+            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. Please install it and try again.');
+                }
+                throw new Error(`Unable to resolve the package ${collectionName} in order to load the generator called ${generatorName}. Is the package installed?`);
+            }
+        }
+        // Unexpected error, rethrow
+        throw err;
+    }
+}
+function runPreVersionCommand(preVersionCommand, { dryRun, verbose }) {
+    if (!preVersionCommand) {
+        return;
+    }
+    output_1.output.logSingleLine(`Executing pre-version command`);
+    if (verbose) {
+        console.log(`Executing the following pre-version command:`);
+        console.log(preVersionCommand);
+    }
+    let env = {
+        ...process.env,
     };
+    if (dryRun) {
+        env.NX_DRY_RUN = 'true';
+    }
+    const stdio = verbose ? 'inherit' : 'pipe';
+    try {
+        (0, node_child_process_1.execSync)(preVersionCommand, {
+            encoding: 'utf-8',
+            maxBuffer: LARGE_BUFFER,
+            stdio,
+            env,
+        });
+    }
+    catch (e) {
+        const title = verbose
+            ? `The pre-version command failed. See the full output above.`
+            : `The pre-version command failed. Retry with --verbose to see the full output of the pre-version command.`;
+        output_1.output.error({
+            title,
+            bodyLines: [preVersionCommand, e],
+        });
+        process.exit(1);
+    }
 }

package/src/command-line/repair/repair.js

@@ -11,15 +11,19 @@ async function repair(args, extraMigrations = []) {
     }
     const verbose = process.env.NX_VERBOSE_LOGGING === 'true';
     return (0, params_1.handleErrors)(verbose, async () => {
-        const nxMigrations = Object.entries(migrationsJson.generators).map(([name, migration]) => {
-            return {
-                package: 'nx',
-                cli: 'nx',
-                name,
-                description: migration.description,
-                version: migration.version,
-            };
-        });
+        const nxMigrations = Object.entries(migrationsJson.generators).reduce((agg, [name, migration]) => {
+            const skip = migration['x-repair-skip'];
+            if (!skip) {
+                agg.push({
+                    package: 'nx',
+                    cli: 'nx',
+                    name,
+                    description: migration.description,
+                    version: migration.version,
+                });
+            }
+            return agg;
+        }, []);
         const migrations = [...nxMigrations, ...extraMigrations];
         const migrationsThatMadeNoChanges = await (0, migrate_1.executeMigrations)(process.cwd(), migrations, verbose, false, '');
         if (migrationsThatMadeNoChanges.length < migrations.length) {

package/src/command-line/report/report.d.ts

@@ -1,5 +1,6 @@
 import { PackageManager } from '../../utils/package-manager';
 import { PackageJson } from '../../utils/package-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
 export declare const packagesWeCareAbout: string[];
 export declare const patternsWeIgnoreInCommunityReport: Array<string | RegExp>;
 /**
@@ -16,6 +17,7 @@ export interface ReportData {
     pmVersion: string;
     localPlugins: string[];
     communityPlugins: PackageJson[];
+    registeredPlugins: string[];
     packageVersionsWeCareAbout: {
         package: string;
         version: string;
@@ -41,6 +43,7 @@ interface OutOfSyncPackageGroup {
 }
 export declare function findMisalignedPackagesForPackage(base: PackageJson): undefined | OutOfSyncPackageGroup;
 export declare function findInstalledCommunityPlugins(): PackageJson[];
+export declare function findRegisteredPluginsBeingUsed(nxJson: NxJsonConfiguration): string[];
 export declare function findInstalledPackagesWeCareAbout(): {
     package: string;
     version: string;

package/src/command-line/report/report.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findInstalledPackagesWeCareAbout = exports.findInstalledCommunityPlugins = exports.findMisalignedPackagesForPackage = exports.getReportData = exports.reportHandler = exports.patternsWeIgnoreInCommunityReport = exports.packagesWeCareAbout = void 0;
+exports.findInstalledPackagesWeCareAbout = exports.findRegisteredPluginsBeingUsed = exports.findInstalledCommunityPlugins = exports.findMisalignedPackagesForPackage = exports.getReportData = exports.reportHandler = exports.patternsWeIgnoreInCommunityReport = exports.packagesWeCareAbout = void 0;
 const chalk = require("chalk");
 const output_1 = require("../../utils/output");
 const path_1 = require("path");
@@ -17,7 +17,7 @@ const nxPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(__dirname,
 exports.packagesWeCareAbout = [
     'lerna',
     ...nxPackageJson['nx-migrations'].packageGroup.map((x) => typeof x === 'string' ? x : x.package),
-    '@nrwl/schematics',
+    '@nrwl/schematics', // manually added since we don't publish it anymore.
     'typescript',
 ];
 exports.patternsWeIgnoreInCommunityReport = [
@@ -36,7 +36,7 @@ const LINE_SEPARATOR = '---------------------------------------';
  *
  */
 async function reportHandler() {
-    const { pm, pmVersion, localPlugins, communityPlugins, packageVersionsWeCareAbout, outOfSyncPackageGroup, projectGraphError, } = await getReportData();
+    const { pm, pmVersion, localPlugins, communityPlugins, registeredPlugins, packageVersionsWeCareAbout, outOfSyncPackageGroup, projectGraphError, } = await getReportData();
     const bodyLines = [
         `Node   : ${process.versions.node}`,
         `OS     : ${process.platform}-${process.arch}`,
@@ -47,6 +47,13 @@ async function reportHandler() {
     packageVersionsWeCareAbout.forEach((p) => {
         bodyLines.push(`${chalk.green(p.package.padEnd(padding))} : ${chalk.bold(p.version)}`);
     });
+    if (registeredPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('Registered Plugins:');
+        for (const plugin of registeredPlugins) {
+            bodyLines.push(`${chalk.green(plugin)}`);
+        }
+    }
     if (communityPlugins.length) {
         bodyLines.push(LINE_SEPARATOR);
         padding = Math.max(...communityPlugins.map((x) => x.name.length)) + 1;
@@ -86,8 +93,10 @@ exports.reportHandler = reportHandler;
 async function getReportData() {
     const pm = (0, package_manager_1.detectPackageManager)();
     const pmVersion = (0, package_manager_1.getPackageManagerVersion)(pm);
-    const localPlugins = await findLocalPlugins((0, nx_json_1.readNxJson)());
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const localPlugins = await findLocalPlugins(nxJson);
     const communityPlugins = findInstalledCommunityPlugins();
+    const registeredPlugins = findRegisteredPluginsBeingUsed(nxJson);
     let projectGraphError = null;
     if (isNativeAvailable()) {
         try {
@@ -114,6 +123,7 @@ async function getReportData() {
         pmVersion,
         localPlugins,
         communityPlugins,
+        registeredPlugins,
         packageVersionsWeCareAbout,
         outOfSyncPackageGroup,
         projectGraphError,
@@ -178,9 +188,16 @@ function findInstalledCommunityPlugins() {
             : pattern.test(dep.name)));
 }
 exports.findInstalledCommunityPlugins = findInstalledCommunityPlugins;
+function findRegisteredPluginsBeingUsed(nxJson) {
+    if (!nxJson.plugins) {
+        return [];
+    }
+    return nxJson.plugins.map((plugin) => typeof plugin === 'object' ? plugin.plugin : plugin);
+}
+exports.findRegisteredPluginsBeingUsed = findRegisteredPluginsBeingUsed;
 function findInstalledPackagesWeCareAbout() {
     const packagesWeMayCareAbout = {};
-    // TODO (v18): Remove workaround for hiding @nrwl packages when matching @nx package is found.
+    // TODO (v19): Remove workaround for hiding @nrwl packages when matching @nx package is found.
     const packageChangeMap = {
         '@nrwl/nx-plugin': '@nx/plugin',
         '@nx/plugin': '@nrwl/nx-plugin',

package/src/command-line/run/command-object.d.ts

@@ -1,2 +1,6 @@
 import { CommandModule } from 'yargs';
 export declare const yargsRunCommand: CommandModule;
+/**
+ * Handles the infix notation for running a target.
+ */
+export declare const yargsNxInfixCommand: CommandModule;