nx 20.5.0-beta.1 → 20.5.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.5.0-beta.1",
+  "version": "20.5.0-beta.3",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -82,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.5.0-beta.1",
-    "@nx/nx-darwin-x64": "20.5.0-beta.1",
-    "@nx/nx-freebsd-x64": "20.5.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "20.5.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "20.5.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "20.5.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "20.5.0-beta.1",
-    "@nx/nx-linux-x64-musl": "20.5.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "20.5.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "20.5.0-beta.1"
+    "@nx/nx-darwin-arm64": "20.5.0-beta.3",
+    "@nx/nx-darwin-x64": "20.5.0-beta.3",
+    "@nx/nx-freebsd-x64": "20.5.0-beta.3",
+    "@nx/nx-linux-arm-gnueabihf": "20.5.0-beta.3",
+    "@nx/nx-linux-arm64-gnu": "20.5.0-beta.3",
+    "@nx/nx-linux-arm64-musl": "20.5.0-beta.3",
+    "@nx/nx-linux-x64-gnu": "20.5.0-beta.3",
+    "@nx/nx-linux-x64-musl": "20.5.0-beta.3",
+    "@nx/nx-win32-arm64-msvc": "20.5.0-beta.3",
+    "@nx/nx-win32-x64-msvc": "20.5.0-beta.3"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/adapter/compat.d.ts

@@ -1,2 +1,2 @@
 export declare const allowedProjectExtensions: readonly ["tags", "implicitDependencies", "configFilePath", "$schema", "generators", "namedInputs", "name", "files", "root", "sourceRoot", "projectType", "release", "includedScripts", "metadata"];
-export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudId", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud", "sync", "useLegacyCache"];
+export declare const allowedWorkspaceExtensions: readonly ["$schema", "implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudId", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud", "sync", "useLegacyCache"];

package/src/adapter/compat.js

@@ -37,6 +37,7 @@ exports.allowedProjectExtensions = [
 // There are some props in here (root) that angular already knows about,
 // but it doesn't hurt to have them in here as well to help static analysis.
 exports.allowedWorkspaceExtensions = [
+    '$schema',
     'implicitDependencies',
     'affected',
     'defaultBase',

package/src/command-line/init/command-object.js

@@ -7,14 +7,21 @@ exports.yargsInitCommand = {
     describe: 'Adds Nx to any type of workspace. It installs nx, creates an nx.json configuration file and optionally sets up remote caching. For more info, check https://nx.dev/recipes/adopting-nx.',
     builder: (yargs) => withInitOptions(yargs),
     handler: async (args) => {
-        const useV2 = await isInitV2();
-        if (useV2) {
-            await require('./init-v2').initHandler(args);
+        try {
+            const useV2 = await isInitV2();
+            if (useV2) {
+                await require('./init-v2').initHandler(args);
+            }
+            else {
+                await require('./init-v1').initHandler(args);
+            }
+            process.exit(0);
         }
-        else {
-            await require('./init-v1').initHandler(args);
+        catch {
+            // Ensure the cursor is always restored just in case the user has bailed during interactive prompts
+            process.stdout.write('\x1b[?25h');
+            process.exit(1);
         }
-        process.exit(0);
     },
 };
 async function isInitV2() {

package/src/command-line/init/implementation/add-nx-to-turborepo.d.ts

@@ -0,0 +1,4 @@
+import { InitArgs } from '../init-v1';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive'>;
+export declare function addNxToTurborepo(_options: Options): Promise<void>;
+export {};

package/src/command-line/init/implementation/add-nx-to-turborepo.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToTurborepo = addNxToTurborepo;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const package_manager_1 = require("../../../utils/package-manager");
+const utils_1 = require("./utils");
+async function addNxToTurborepo(_options) {
+    const repoRoot = process.cwd();
+    output_1.output.log({
+        title: 'Initializing Nx based on your old Turborepo configuration',
+    });
+    output_1.output.log({
+        title: '💡 Did you know?',
+        bodyLines: [
+            '- Turborepo requires you to maintain all your common scripts like "build", "lint", "test" in all your packages, as well as their applicable cache inputs and outputs.',
+            `- Nx is extensible and has plugins for the tools you use to infer all of this for you purely based on that tool's configuration file within your packages.`,
+            '',
+            '  - E.g. the `@nx/vite` plugin will infer the "build" script based on the existence of a vite.config.js file.',
+            '  - Therefore with zero package level config, `nx build my-app` knows to run the `vite build` CLI directly, with all Nx cache inputs and outputs automatically inferred.',
+            '',
+            `NOTE: None of your existing package.json scripts will be modified as part of this initialization process, you can already use them as-is with Nx, but you can learn more about the benefits of Nx's inferred tasks at https://nx.dev/concepts/inferred-tasks`,
+        ],
+    });
+    let nxJson = (0, utils_1.createNxJsonFromTurboJson)((0, fileutils_1.readJsonFile)('turbo.json'));
+    const nxJsonPath = (0, node_path_1.join)(repoRoot, 'nx.json');
+    // Turborepo workspaces usually have prettier installed, so try and match the formatting before writing the file
+    try {
+        const prettier = await Promise.resolve().then(() => require('prettier'));
+        const config = await prettier.resolveConfig(repoRoot);
+        (0, node_fs_1.writeFileSync)(nxJsonPath, 
+        // @ts-ignore - Always await prettier.format, in modern versions it's async
+        await prettier.format(JSON.stringify(nxJson, null, 2), {
+            ...(config ?? {}),
+            parser: 'json',
+        }));
+    }
+    catch (err) {
+        // Apply fallback JSON write
+        (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+    }
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot, pmc);
+}

package/src/command-line/init/implementation/deduce-default-base.d.ts

@@ -0,0 +1 @@
+export declare function deduceDefaultBase(): string;

package/src/command-line/init/implementation/deduce-default-base.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = deduceDefaultBase;
+const node_child_process_1 = require("node:child_process");
+const default_base_1 = require("../../../utils/default-base");
+function deduceDefaultBase() {
+    try {
+        (0, node_child_process_1.execSync)(`git rev-parse --verify main`, {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            windowsHide: false,
+        });
+        return 'main';
+    }
+    catch {
+        try {
+            (0, node_child_process_1.execSync)(`git rev-parse --verify dev`, {
+                stdio: ['ignore', 'ignore', 'ignore'],
+                windowsHide: false,
+            });
+            return 'dev';
+        }
+        catch {
+            try {
+                (0, node_child_process_1.execSync)(`git rev-parse --verify develop`, {
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                    windowsHide: false,
+                });
+                return 'develop';
+            }
+            catch {
+                try {
+                    (0, node_child_process_1.execSync)(`git rev-parse --verify next`, {
+                        stdio: ['ignore', 'ignore', 'ignore'],
+                        windowsHide: false,
+                    });
+                    return 'next';
+                }
+                catch {
+                    try {
+                        (0, node_child_process_1.execSync)(`git rev-parse --verify master`, {
+                            stdio: ['ignore', 'ignore', 'ignore'],
+                            windowsHide: false,
+                        });
+                        return 'master';
+                    }
+                    catch {
+                        return (0, default_base_1.deduceDefaultBase)();
+                    }
+                }
+            }
+        }
+    }
+}

package/src/command-line/init/implementation/utils.d.ts

@@ -1,12 +1,14 @@
+import { NxJsonConfiguration } from '../../../config/nx-json';
 import { PackageJson } from '../../../utils/package-json';
 import { PackageManagerCommands } from '../../../utils/package-manager';
 export declare function createNxJsonFile(repoRoot: string, topologicalTargets: string[], cacheableOperations: string[], scriptOutputs: {
     [name: string]: string;
 }): void;
+export declare function createNxJsonFromTurboJson(turboJson: Record<string, any>): NxJsonConfiguration;
 export declare function addDepsToPackageJson(repoRoot: string, additionalPackages?: string[]): void;
 export declare function updateGitIgnore(root: string): void;
 export declare function runInstall(repoRoot: string, pmc?: PackageManagerCommands): void;
-export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-cra' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo'): Promise<void>;
+export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-cra' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo' | 'nx-init-turborepo'): Promise<void>;
 export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;
 export declare function markRootPackageJsonAsNxProjectLegacy(repoRoot: string, cacheableScripts: string[], pmc: PackageManagerCommands): void;
 export declare function markPackageJsonAsNxProject(packageJsonPath: string): void;

package/src/command-line/init/implementation/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNxJsonFile = createNxJsonFile;
+exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
 exports.addDepsToPackageJson = addDepsToPackageJson;
 exports.updateGitIgnore = updateGitIgnore;
 exports.runInstall = runInstall;
@@ -21,7 +22,7 @@ const fs_1 = require("fs");
 const connect_to_nx_cloud_1 = require("../../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud");
 const url_shorten_1 = require("../../../nx-cloud/utilities/url-shorten");
 const connect_to_nx_cloud_2 = require("../../connect/connect-to-nx-cloud");
-const default_base_1 = require("../../../utils/default-base");
+const deduce_default_base_1 = require("./deduce-default-base");
 function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scriptOutputs) {
     const nxJsonPath = (0, path_2.joinPathFragments)(repoRoot, 'nx.json');
     let nxJson = {};
@@ -53,56 +54,104 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     if (Object.keys(nxJson.targetDefaults).length === 0) {
         delete nxJson.targetDefaults;
     }
-    nxJson.defaultBase ??= deduceDefaultBase();
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
     (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
 }
-function deduceDefaultBase() {
-    try {
-        (0, child_process_1.execSync)(`git rev-parse --verify main`, {
-            stdio: ['ignore', 'ignore', 'ignore'],
-            windowsHide: false,
-        });
-        return 'main';
-    }
-    catch {
-        try {
-            (0, child_process_1.execSync)(`git rev-parse --verify dev`, {
-                stdio: ['ignore', 'ignore', 'ignore'],
-                windowsHide: false,
-            });
-            return 'dev';
+function createNxJsonFromTurboJson(turboJson) {
+    const nxJson = {
+        $schema: './node_modules/nx/schemas/nx-schema.json',
+    };
+    // Handle global dependencies
+    if (turboJson.globalDependencies?.length > 0) {
+        nxJson.namedInputs = {
+            sharedGlobals: turboJson.globalDependencies.map((dep) => `{workspaceRoot}/${dep}`),
+            default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        };
+    }
+    // Handle global env vars
+    if (turboJson.globalEnv?.length > 0) {
+        nxJson.namedInputs = nxJson.namedInputs || {};
+        nxJson.namedInputs.sharedGlobals = nxJson.namedInputs.sharedGlobals || [];
+        nxJson.namedInputs.sharedGlobals.push(...turboJson.globalEnv.map((env) => ({ env })));
+        nxJson.namedInputs.default = nxJson.namedInputs.default || [];
+        if (!nxJson.namedInputs.default.includes('{projectRoot}/**/*')) {
+            nxJson.namedInputs.default.push('{projectRoot}/**/*');
         }
-        catch {
-            try {
-                (0, child_process_1.execSync)(`git rev-parse --verify develop`, {
-                    stdio: ['ignore', 'ignore', 'ignore'],
-                    windowsHide: false,
-                });
-                return 'develop';
+        if (!nxJson.namedInputs.default.includes('sharedGlobals')) {
+            nxJson.namedInputs.default.push('sharedGlobals');
+        }
+    }
+    // Handle task configurations
+    if (turboJson.tasks) {
+        nxJson.targetDefaults = {};
+        for (const [taskName, taskConfig] of Object.entries(turboJson.tasks)) {
+            // Skip project-specific tasks (containing #)
+            if (taskName.includes('#'))
+                continue;
+            const config = taskConfig;
+            nxJson.targetDefaults[taskName] = {};
+            // Handle dependsOn
+            if (config.dependsOn?.length > 0) {
+                nxJson.targetDefaults[taskName].dependsOn = config.dependsOn;
             }
-            catch {
-                try {
-                    (0, child_process_1.execSync)(`git rev-parse --verify next`, {
-                        stdio: ['ignore', 'ignore', 'ignore'],
-                        windowsHide: false,
-                    });
-                    return 'next';
-                }
-                catch {
-                    try {
-                        (0, child_process_1.execSync)(`git rev-parse --verify master`, {
-                            stdio: ['ignore', 'ignore', 'ignore'],
-                            windowsHide: false,
-                        });
-                        return 'master';
+            // Handle inputs
+            if (config.inputs?.length > 0) {
+                nxJson.targetDefaults[taskName].inputs = config.inputs
+                    .map((input) => {
+                    if (input === '$TURBO_DEFAULT$') {
+                        return '{projectRoot}/**/*';
                     }
-                    catch {
-                        return (0, default_base_1.deduceDefaultBase)();
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                })
+                    .map((input) => {
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                });
+            }
+            // Handle outputs
+            if (config.outputs?.length > 0) {
+                nxJson.targetDefaults[taskName].outputs = config.outputs.map((output) => {
+                    // Don't add projectRoot if it's already there
+                    if (output.startsWith('{projectRoot}/'))
+                        return output;
+                    // Handle negated patterns by adding projectRoot after the !
+                    if (output.startsWith('!')) {
+                        return `!{projectRoot}/${output.slice(1)}`;
                     }
-                }
+                    return `{projectRoot}/${output}`;
+                });
             }
+            // Handle cache setting - true by default in Turbo
+            nxJson.targetDefaults[taskName].cache = config.cache !== false;
         }
     }
+    /**
+     * The fact that cacheDir was in use suggests the user had a reason for deviating from the default.
+     * We can't know what that reason was, nor if it would still be applicable in Nx, but we can at least
+     * improve discoverability of the relevant Nx option by explicitly including it with its default value.
+     */
+    if (turboJson.cacheDir) {
+        nxJson.cacheDirectory = '.nx/cache';
+    }
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
+    return nxJson;
 }
 function addDepsToPackageJson(repoRoot, additionalPackages) {
     const path = (0, path_2.joinPathFragments)(repoRoot, `package.json`);

package/src/command-line/init/init-v2.js

@@ -3,23 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initHandler = initHandler;
 exports.detectPlugins = detectPlugins;
 const fs_1 = require("fs");
+const enquirer_1 = require("enquirer");
 const semver_1 = require("semver");
-const output_1 = require("../../utils/output");
-const package_manager_1 = require("../../utils/package-manager");
-const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const nx_json_1 = require("../../config/nx-json");
 const child_process_1 = require("../../utils/child-process");
 const fileutils_1 = require("../../utils/fileutils");
+const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
 const versions_1 = require("../../utils/versions");
-const utils_1 = require("./implementation/utils");
-const enquirer_1 = require("enquirer");
-const angular_1 = require("./implementation/angular");
 const workspace_context_1 = require("../../utils/workspace-context");
 const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
-const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
-const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
-const nx_json_1 = require("../../config/nx-json");
-const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
 const configure_plugins_1 = require("./configure-plugins");
+const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
+const add_nx_to_turborepo_1 = require("./implementation/add-nx-to-turborepo");
+const angular_1 = require("./implementation/angular");
+const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const utils_1 = require("./implementation/utils");
 async function initHandler(options) {
     process.env.NX_RUNNING_NX_INIT = 'true';
     const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
@@ -57,7 +58,29 @@ async function initHandler(options) {
         return;
     }
     const packageJson = (0, fileutils_1.readJsonFile)('package.json');
-    if ((0, utils_1.isMonorepo)(packageJson)) {
+    const _isTurborepo = (0, fs_1.existsSync)('turbo.json');
+    const _isMonorepo = (0, utils_1.isMonorepo)(packageJson);
+    const learnMoreLink = _isTurborepo
+        ? 'https://nx.dev/recipes/adopting-nx/from-turborepo'
+        : _isMonorepo
+            ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
+            : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
+    /**
+     * Turborepo users must have set up individual scripts already, and we keep the transition as minimal as possible.
+     * We log a message during the conversion process in addNxToTurborepo about how they can learn more about the power
+     * of Nx plugins and how it would allow them to infer all the relevant scripts automatically, including all cache
+     * inputs and outputs.
+     */
+    if (_isTurborepo) {
+        await (0, add_nx_to_turborepo_1.addNxToTurborepo)({
+            interactive: options.interactive,
+        });
+        (0, utils_1.printFinalMessage)({
+            learnMoreLink,
+        });
+        return;
+    }
+    if (_isMonorepo) {
         await (0, add_nx_to_monorepo_1.addNxToMonorepo)({
             interactive: options.interactive,
             nxCloud: false,
@@ -69,9 +92,6 @@ async function initHandler(options) {
             nxCloud: false,
         });
     }
-    const learnMoreLink = (0, utils_1.isMonorepo)(packageJson)
-        ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
-        : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
     const useNxCloud = options.nxCloud ??
         (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
     const repoRoot = process.cwd();

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

@@ -118,10 +118,10 @@ class Migrator {
         const packagesToCheck = await this.populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target);
         for (const packageToCheck of packagesToCheck) {
             const filteredUpdates = {};
-            for (const packageUpdate of packageToCheck.updates) {
+            for (const [packageUpdateKey, packageUpdate] of Object.entries(packageToCheck.updates)) {
                 if (this.areRequirementsMet(packageUpdate.requires) &&
                     (!this.interactive ||
-                        (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate)))) {
+                        (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
                     Object.entries(packageUpdate.packages).forEach(([name, update]) => {
                         filteredUpdates[name] = update;
                         this.packageUpdates[name] = update;
@@ -166,15 +166,15 @@ class Migrator {
             addToPackageJson: target.addToPackageJson || false,
         });
         const { packageJsonUpdates, packageGroupOrder } = this.getPackageJsonUpdatesFromMigrationConfig(targetPackage, targetVersion, migrationConfig);
-        if (!packageJsonUpdates.length) {
+        if (!Object.keys(packageJsonUpdates).length) {
             return [];
         }
-        const shouldCheckUpdates = packageJsonUpdates.some((packageJsonUpdate) => (this.interactive && packageJsonUpdate['x-prompt']) ||
+        const shouldCheckUpdates = Object.values(packageJsonUpdates).some((packageJsonUpdate) => (this.interactive && packageJsonUpdate['x-prompt']) ||
             Object.keys(packageJsonUpdate.requires ?? {}).length);
         if (shouldCheckUpdates) {
             return [{ package: targetPackage, updates: packageJsonUpdates }];
         }
-        const packageUpdatesToApply = packageJsonUpdates.reduce((m, c) => ({ ...m, ...c.packages }), {});
+        const packageUpdatesToApply = Object.values(packageJsonUpdates).reduce((m, c) => ({ ...m, ...c.packages }), {});
         return (await Promise.all(Object.entries(packageUpdatesToApply).map(([packageName, packageUpdate]) => this.populatePackageJsonUpdatesAndGetPackagesToCheck(packageName, packageUpdate))))
             .filter((pkgs) => pkgs.length)
             .flat()
@@ -185,7 +185,7 @@ class Migrator {
         const packageGroupOrder = this.getPackageJsonUpdatesFromPackageGroup(packageName, targetVersion, migrationConfig);
         if (!migrationConfig.packageJsonUpdates ||
             !this.getPkgVersion(packageName)) {
-            return { packageJsonUpdates: [], packageGroupOrder };
+            return { packageJsonUpdates: {}, packageGroupOrder };
         }
         const packageJsonUpdates = this.filterPackageJsonUpdates(migrationConfig.packageJsonUpdates, packageName, targetVersion);
         return { packageJsonUpdates, packageGroupOrder };
@@ -228,8 +228,8 @@ class Migrator {
         return packageGroupOrder;
     }
     filterPackageJsonUpdates(packageJsonUpdates, packageName, targetVersion) {
-        const filteredPackageJsonUpdates = [];
-        for (const packageJsonUpdate of Object.values(packageJsonUpdates)) {
+        const filteredPackageJsonUpdates = {};
+        for (const [packageJsonUpdateKey, packageJsonUpdate] of Object.entries(packageJsonUpdates)) {
             if (!packageJsonUpdate.packages ||
                 this.lt(packageJsonUpdate.version, this.getPkgVersion(packageName)) ||
                 this.gt(packageJsonUpdate.version, targetVersion)) {
@@ -254,7 +254,7 @@ class Migrator {
             }
             if (Object.keys(filtered).length) {
                 packageJsonUpdate.packages = filtered;
-                filteredPackageJsonUpdates.push(packageJsonUpdate);
+                filteredPackageJsonUpdates[packageJsonUpdateKey] = packageJsonUpdate;
             }
         }
         return filteredPackageJsonUpdates;
@@ -313,7 +313,7 @@ class Migrator {
                 includePrerelease: true,
             }));
     }
-    async runPackageJsonUpdatesConfirmationPrompt(packageUpdate) {
+    async runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageName) {
         if (!packageUpdate['x-prompt']) {
             return Promise.resolve(true);
         }
@@ -322,14 +322,17 @@ class Migrator {
             // a same prompt was already answered, skip
             return Promise.resolve(false);
         }
-        return await (0, enquirer_1.prompt)([
-            {
-                name: 'shouldApply',
-                type: 'confirm',
-                message: packageUpdate['x-prompt'],
-                initial: true,
-            },
-        ]).then(({ shouldApply }) => {
+        const promptConfig = {
+            name: 'shouldApply',
+            type: 'confirm',
+            message: packageUpdate['x-prompt'],
+            initial: true,
+        };
+        if (packageName.startsWith('@nx/')) {
+            // @ts-expect-error -- enquirer types aren't correct, footer does exist
+            promptConfig.footer = () => chalk.dim(`  View migration details at https://nx.dev/nx-api/${packageName.replace('@nx/', '')}#${packageUpdateKey.replace(/[-\.]/g, '')}packageupdates`);
+        }
+        return await (0, enquirer_1.prompt)([promptConfig]).then(({ shouldApply }) => {
             this.promptAnswers[promptKey] = shouldApply;
             if (!shouldApply &&
                 (!this.minVersionWithSkippedUpdates ||

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

@@ -1,6 +1,6 @@
 import type { ChangelogRenderOptions } from '../../release/changelog-renderer';
-import { PackageManager } from '../utils/package-manager';
-import { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
+import type { PackageManager } from '../utils/package-manager';
+import type { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
 export type ImplicitDependencyEntry<T = '*' | string[]> = {
     [key: string]: T | ImplicitJsonSubsetDependency<T>;
 };
@@ -321,6 +321,7 @@ export interface NxSyncConfiguration {
  * @note: when adding properties here add them to `allowedWorkspaceExtensions` in adapter/compat.ts
  */
 export interface NxJsonConfiguration<T = '*' | string[]> {
+    $schema?: string;
     /**
      * Optional (additional) Nx.json configuration file which becomes a base for this one
      */