nx 23.0.0-beta.22 → 23.0.0-beta.23

package/dist/plugins/package-json.js

@@ -22,7 +22,7 @@ function writeCache() {
 }
 const plugin = {
     name: 'nx-all-package-jsons-plugin',
-    createNodesV2: [
+    createNodes: [
         '*/**/package.json',
         (configFiles, options, context) => {
             const cache = readPackageJsonConfigurationCache();

package/dist/src/adapter/angular-json.d.ts

@@ -1,7 +1,7 @@
 import { ProjectsConfigurations } from '../config/workspace-json-project-json';
-import { NxPluginV2 } from '../project-graph/plugins';
+import { NxPlugin } from '../project-graph/plugins';
 export declare const NX_ANGULAR_JSON_PLUGIN_NAME = "nx-angular-json-plugin";
-export declare const NxAngularJsonPlugin: NxPluginV2;
+export declare const NxAngularJsonPlugin: NxPlugin;
 export default NxAngularJsonPlugin;
 export declare function shouldMergeAngularProjects(root: string, includeProjectsFromAngularJson: boolean): boolean;
 export declare function isAngularPluginInstalled(): boolean;

package/dist/src/adapter/angular-json.js

@@ -25,7 +25,6 @@ const createNodes = [
 exports.NxAngularJsonPlugin = {
     name: exports.NX_ANGULAR_JSON_PLUGIN_NAME,
     createNodes,
-    createNodesV2: createNodes,
 };
 exports.default = exports.NxAngularJsonPlugin;
 function shouldMergeAngularProjects(root, includeProjectsFromAngularJson) {

package/dist/src/ai/set-up-ai-agents/set-up-ai-agents.js

@@ -12,6 +12,7 @@ const generate_files_1 = require("../../generators/utils/generate-files");
 const json_1 = require("../../generators/utils/json");
 const native_1 = require("../../native");
 const package_json_1 = require("../../utils/package-json");
+const package_manager_1 = require("../../utils/package-manager");
 const ignore_1 = require("../../utils/ignore");
 const provenance_1 = require("../../utils/provenance");
 const workspace_root_1 = require("../../utils/workspace-root");
@@ -48,7 +49,7 @@ async function setupAiAgentsGenerator(tree, options, inner = false) {
     }
     try {
         await (0, provenance_1.ensurePackageHasProvenance)('nx', normalizedOptions.packageVersion);
-        const { tempDir, cleanup } = (0, package_json_1.installPackageToTmp)('nx', normalizedOptions.packageVersion);
+        const { tempDir, cleanup } = (0, package_json_1.installPackageToTmp)('nx', normalizedOptions.packageVersion, (0, package_manager_1.detectPackageManager)(tree.root));
         let modulePath = (0, path_1.join)(tempDir, 'node_modules', 'nx', 'src/ai/set-up-ai-agents/set-up-ai-agents.js');
         const module = await (0, handle_import_1.handleImport)(modulePath);
         const setupAiAgentsGeneratorResult = await module.setupAiAgentsGenerator(tree, normalizedOptions, true);

package/dist/src/command-line/configure-ai-agents/configure-ai-agents.js

@@ -44,7 +44,7 @@ async function configureAiAgentsHandler(args, inner = false) {
     let cleanup;
     try {
         await (0, provenance_1.ensurePackageHasProvenance)('nx', 'latest');
-        const packageInstallResults = (0, devkit_internals_1.installPackageToTmp)('nx', 'latest');
+        const packageInstallResults = (0, devkit_internals_1.installPackageToTmp)('nx', 'latest', (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot));
         cleanup = packageInstallResults.cleanup;
         let modulePath = require.resolve('nx/src/command-line/configure-ai-agents/configure-ai-agents.js', { paths: [packageInstallResults.tempDir] });
         const module = await (0, handle_import_1.handleImport)(modulePath);

package/dist/src/command-line/graph/graph.js

@@ -172,7 +172,7 @@ async function generateGraph(args, affectedProjects) {
                 });
             }
             output_1.output.warn({
-                title: `${errors?.length > 1 ? `${errors.length} errors` : `An error`} occured while processing the project graph. Showing partial graph.`,
+                title: `${errors?.length > 1 ? `${errors.length} errors` : `An error`} occurred while processing the project graph. Showing partial graph.`,
             });
         }
     }

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

@@ -42,7 +42,7 @@ async function initHandler(options, inner = false) {
     let cleanup;
     try {
         await (0, provenance_1.ensurePackageHasProvenance)('nx', 'latest');
-        const packageInstallResults = (0, devkit_internals_1.installPackageToTmp)('nx', 'latest');
+        const packageInstallResults = (0, devkit_internals_1.installPackageToTmp)('nx', 'latest', (0, package_manager_2.detectPackageManager)(process.cwd()));
         cleanup = packageInstallResults.cleanup;
         let modulePath = require.resolve('nx/src/command-line/init/init-v2.js', {
             paths: [packageInstallResults.tempDir],

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

@@ -90,7 +90,7 @@ function withMigrationOptions(yargs) {
         default: false,
     })
         .option('mode', {
-        describe: "Restrict which packages to migrate. Only applies when migrating Nx itself. 'first-party' processes only Nx and its plugins (the target package plus its nx.packageGroup); 'third-party' processes only the third-party dependencies referenced by Nx packageJsonUpdates entries, catching up on any updates that may have been skipped previously; 'all' processes everything. When targeting Nx in an interactive terminal, prompts for the value if not provided; otherwise defaults to 'all'.",
+        describe: "Restrict which packages to migrate. Only applies when migrating Nx itself. 'first-party' processes only Nx and its plugins (the target package plus its nx.packageGroup); 'third-party' processes only the third-party dependencies referenced by Nx packageJsonUpdates entries, catching up on any updates that may have been skipped previously; 'all' processes everything. The 'first-party' and 'third-party' modes are only available on Nx v23+: 'third-party' requires the workspace to already be on v23+, and 'first-party' requires migrating from v22+ into a v23+ target. When targeting Nx in an interactive terminal, prompts for the value if not provided; otherwise defaults to 'all'.",
         type: 'string',
         choices: exports.MIGRATE_MODES,
     })

package/dist/src/command-line/migrate/migrate.d.ts

@@ -119,6 +119,8 @@ export declare function resolveCanonicalNxPackage(targetVersion: string): 'nx' |
 export declare function resolveMode(mode: MigrateMode | undefined, targetPackage: string, targetVersion: string, context?: {
     hasFrom: boolean;
     hasExcludeAppliedMigrations: boolean;
+    installedMajor?: number | null;
+    isV23Plus?: boolean;
 }, configuredMode?: MigrateMode): Promise<MigrateMode>;
 type GenerateMigrations = {
     type: 'generateMigrations';

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

@@ -533,32 +533,75 @@ async function resolveMode(mode, targetPackage, targetVersion, context = {
     hasFrom: false,
     hasExcludeAppliedMigrations: false,
 }, configuredMode) {
+    // The first-party/third-party split relies on migration metadata that only
+    // exists in Nx v23+. `first-party` needs a v22+ install migrating into a v23+
+    // target; `third-party` catches up deps a prior first-party migration
+    // deferred, so it needs the workspace already on v23+.
+    const installedMajor = context.installedMajor ?? null;
+    const firstPartyAvailable = installedMajor !== null &&
+        installedMajor >= 22 &&
+        context.isV23Plus === true;
+    const thirdPartyAvailable = installedMajor !== null && installedMajor >= 23;
     if (mode) {
+        if ((0, version_utils_1.isNxEquivalentTarget)(targetPackage, targetVersion)) {
+            if (mode === 'first-party' && !firstPartyAvailable) {
+                if (context.isV23Plus !== true) {
+                    throw new Error(`Error: '--mode=first-party' requires migrating to Nx v23 or later.`);
+                }
+                throw new Error(`Error: '--mode=first-party' requires the workspace to be on Nx v22 or later. Migrate to the latest Nx v22 first, then to v23 or later.`);
+            }
+            // When the installed version is unknown, defer to the downstream
+            // "requires nx to be installed" check rather than the v23 gate.
+            if (mode === 'third-party' &&
+                installedMajor !== null &&
+                !thirdPartyAvailable) {
+                throw new Error(`Error: '--mode=third-party' requires the workspace to be on Nx v23 or later.`);
+            }
+        }
         return mode;
     }
     if (!(0, version_utils_1.isNxEquivalentTarget)(targetPackage, targetVersion)) {
         return 'all';
     }
-    // nx.json `migrate.mode` pre-selects the value the interactive prompt would
-    // ask for; it applies only to Nx targets (non-Nx returned 'all' above).
+    // nx.json `migrate.mode` pre-selects the prompt answer (Nx targets only; non-Nx
+    // returned 'all' above). Honor it only when the v23+ gate makes that mode
+    // available; otherwise warn and fall back to the always-valid 'all'.
     if (configuredMode) {
-        return configuredMode;
-    }
-    if (!process.stdin.isTTY || (0, is_ci_1.isCI)()) {
+        const configuredAvailable = configuredMode === 'all' ||
+            (configuredMode === 'first-party' && firstPartyAvailable) ||
+            (configuredMode === 'third-party' && thirdPartyAvailable);
+        if (configuredAvailable) {
+            return configuredMode;
+        }
+        output_1.output.warn({
+            title: `The configured nx.json migrate.mode '${configuredMode}' is not available for this migration; falling back to 'all'.`,
+            bodyLines: [
+                `The 'first-party' and 'third-party' modes require Nx v23 or later.`,
+            ],
+        });
         return 'all';
     }
-    const choices = [
-        {
+    const choices = [];
+    if (firstPartyAvailable) {
+        choices.push({
             name: 'first-party',
             message: 'First-party only (Nx and its official packages)',
-        },
-    ];
-    if (!context.hasFrom && !context.hasExcludeAppliedMigrations) {
+        });
+    }
+    if (thirdPartyAvailable &&
+        !context.hasFrom &&
+        !context.hasExcludeAppliedMigrations) {
         choices.push({
             name: 'third-party',
             message: 'Third-party only (deps managed by Nx)',
         });
     }
+    if (!choices.length) {
+        return 'all';
+    }
+    if (!process.stdin.isTTY || (0, is_ci_1.isCI)()) {
+        return 'all';
+    }
     choices.push({
         name: 'all',
         message: 'All (first-party and third-party)',
@@ -701,9 +744,11 @@ function assertThirdPartyModeFlagCompatibility(options) {
         throw new Error(`Error: '--mode=third-party' cannot be combined with '--exclude-applied-migrations'.`);
     }
 }
-// Defaults target package/version mode-aware (third-party → installed
-// canonical, otherwise nx@latest) and enforces the era gate when --mode
-// is explicit.
+// Resolves the target package/version up front (third-party → installed
+// canonical; otherwise resolves dist-tags so the v23 mode gate reads a concrete
+// major), then resolves the mode and enforces the era gate when --mode is
+// explicit. Bare invocations on a pre-v22 install throw rather than defaulting
+// to `latest` across the major gap into the v23 era.
 async function resolveTargetAndMode(args) {
     const { positional, from, options } = args;
     let targetPackage;
@@ -713,14 +758,54 @@ async function resolveTargetAndMode(args) {
         targetPackage = normalizeSlashes(parsed.targetPackage);
         targetVersion = parsed.targetVersion;
     }
-    // Resolve mode before defaulting target so the default can depend on the
-    // resolved mode (third-party defaults to nx@<installed>; otherwise nx@latest).
-    // For bare invocation, `targetPackage='nx'` and `targetVersion='latest'` are
-    // safe sentinels: `isNxEquivalentTarget` treats the literal `'latest'` as
-    // modern era (semver `lt('latest', '14.0.0-beta.0')` is false).
+    const installed = resolveInstalledCanonical();
+    const installedMajor = installed && (0, semver_1.valid)(installed.version) ? (0, semver_1.major)(installed.version) : null;
+    // `--mode=third-party` anchors the target to the installed version below, so
+    // it never needs a target or dist-tag resolved up front.
+    const isExplicitThirdParty = options.mode === 'third-party';
+    // Bare invocation: restore the requirement to specify a target when on a
+    // pre-v23 install. We can't safely default to `latest` across the major gap
+    // into the new era, and the first-party/third-party functionality isn't
+    // available there anyway.
+    if (!positional && !isExplicitThirdParty) {
+        if (installedMajor === null || installedMajor < 22) {
+            throw new Error(`Provide the package and version to migrate to. E.g., \`nx migrate nx@<version>\`.`);
+        }
+        targetPackage = 'nx';
+        targetVersion = 'latest';
+    }
+    // Explicit dist-tags arrive already resolved from
+    // `parseTargetPackageAndVersion`; only bare invocations and bare package
+    // names (`nx migrate nx`) reach here unresolved.
+    let isV23Plus = false;
+    if (!isExplicitThirdParty &&
+        (0, version_utils_1.isNxEquivalentTarget)(targetPackage, targetVersion)) {
+        if (targetVersion && (0, semver_1.valid)(targetVersion)) {
+            isV23Plus = (0, semver_1.major)(targetVersion) >= 23;
+        }
+        else {
+            // Resolving the dist-tag here (rather than only in the multi-major check
+            // as before) just moves the single registry round-trip earlier — the
+            // multi-major check short-circuits on the now-concrete version.
+            const tag = targetVersion;
+            try {
+                targetVersion = await (0, version_utils_1.normalizeVersionWithTagCheck)(targetPackage, tag);
+                isV23Plus = (0, semver_1.valid)(targetVersion) ? (0, semver_1.major)(targetVersion) >= 23 : true;
+            }
+            catch {
+                // Registry unavailable: assume dist-tags resolve to >= v23 (true once
+                // v23 is released) so the gate stays sensible. The retained sentinel
+                // still degrades gracefully downstream (multi-major and the cascade).
+                targetVersion = tag;
+                isV23Plus = true;
+            }
+        }
+    }
     const mode = await resolveMode(options.mode, targetPackage ?? 'nx', targetVersion ?? 'latest', {
         hasFrom: Object.keys(from).length > 0,
         hasExcludeAppliedMigrations: options.excludeAppliedMigrations === true,
+        installedMajor,
+        isV23Plus,
     }, options.modeFromConfig);
     let installedNxVersion;
     // For third-party, anchor `targetPackage`/`targetVersion` to the installed
@@ -730,7 +815,6 @@ async function resolveTargetAndMode(args) {
     // the literal `'latest'` that `parseTargetPackageAndVersion` emits for bare
     // package names.
     if (mode === 'third-party' && (!positional || !(0, semver_1.valid)(targetVersion))) {
-        const installed = resolveInstalledCanonical();
         if (!installed) {
             throw new Error(`Error: '--mode=third-party' requires 'nx' (or '@nrwl/workspace' on Nx <14) to be installed in your workspace. Install dependencies first, then re-run.`);
         }
@@ -738,15 +822,6 @@ async function resolveTargetAndMode(args) {
         targetPackage = installed.canonical;
         targetVersion = installed.version;
     }
-    else if (!positional) {
-        // Bare invocation: default to `nx@latest` as a literal sentinel rather
-        // than resolving via the registry here. Multi-major resolves the dist-tag
-        // when needed (and bails gracefully on registry failure), and the cascade
-        // resolves it for the walk (honouring `NX_MIGRATE_SKIP_REGISTRY_FETCH`).
-        // This matches the resilience of `nx migrate nx`.
-        targetPackage = 'nx';
-        targetVersion = 'latest';
-    }
     if (options.mode && !(0, version_utils_1.isNxEquivalentTarget)(targetPackage, targetVersion)) {
         const isLegacy = (0, version_utils_1.isLegacyEra)(targetVersion);
         const validTargets = isLegacy
@@ -863,14 +938,14 @@ function createInstalledPackageVersionsResolver(root) {
     return getInstalledPackageVersion;
 }
 // testing-fetch-start
-function createFetcher() {
+function createFetcher(pmc) {
     const migrationsCache = {};
     const resolvedVersionCache = {};
     function fetchMigrations(packageName, packageVersion, setCache) {
         if (process.env.NX_MIGRATE_SKIP_REGISTRY_FETCH === 'true') {
             // Skip registry fetch and use installation method directly
             logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
-            return getPackageMigrationsUsingInstall(packageName, packageVersion);
+            return getPackageMigrationsUsingInstall(packageName, packageVersion, pmc);
         }
         const cacheKey = packageName + '-' + packageVersion;
         return Promise.resolve(resolvedVersionCache[cacheKey])
@@ -892,7 +967,7 @@ function createFetcher() {
             .catch((e) => {
             logger_1.logger.verbose(`Failed to get migrations from registry for ${packageName}@${packageVersion}: ${e.message}. Falling back to install.`);
             logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
-            return getPackageMigrationsUsingInstall(packageName, packageVersion);
+            return getPackageMigrationsUsingInstall(packageName, packageVersion, pmc);
         });
     }
     return function nxMigrateFetcher(packageName, packageVersion) {
@@ -1011,18 +1086,17 @@ function createConcurrencyLimiter(concurrency) {
 const installConcurrencyLimit = process.env.NX_MIGRATE_INSTALL_CONCURRENCY
     ? createConcurrencyLimiter(Math.max(1, Math.floor(Number(process.env.NX_MIGRATE_INSTALL_CONCURRENCY)) || 1))
     : null;
-async function getPackageMigrationsUsingInstall(packageName, packageVersion) {
-    const run = () => getPackageMigrationsUsingInstallImpl(packageName, packageVersion);
+async function getPackageMigrationsUsingInstall(packageName, packageVersion, pmc) {
+    const run = () => getPackageMigrationsUsingInstallImpl(packageName, packageVersion, pmc);
     return installConcurrencyLimit ? installConcurrencyLimit(run) : run();
 }
-async function getPackageMigrationsUsingInstallImpl(packageName, packageVersion) {
+async function getPackageMigrationsUsingInstallImpl(packageName, packageVersion, pmc) {
     const { dir, cleanup } = (0, package_manager_1.createTempNpmDirectory)();
     let result;
     if ((0, provenance_1.getNxPackageGroup)().includes(packageName)) {
         await (0, provenance_1.ensurePackageHasProvenance)(packageName, packageVersion);
     }
     try {
-        const pmc = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(dir), dir);
         await execAsync(`${pmc.add} ${packageName}@${packageVersion}`, {
             cwd: dir,
             env: {
@@ -1046,7 +1120,6 @@ async function getPackageMigrationsUsingInstallImpl(packageName, packageVersion)
         };
     }
     catch (e) {
-        const pmc = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(dir), dir);
         throw new Error([
             `Failed to fetch migrations for ${packageName}@${packageVersion}`,
             formatCommandFailure(`${pmc.add} ${packageName}@${packageVersion}`, e),
@@ -1233,7 +1306,7 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts) {
         }
         logger_1.logger.info(`Fetching meta data about packages.`);
         logger_1.logger.info(`It may take a few minutes.`);
-        const fetch = createFetcher();
+        const fetch = createFetcher(pmc);
         let firstPartyPackages;
         if (mode === 'first-party' || mode === 'third-party') {
             // `@nx/workspace` is version-synced with `nx` and declares an

package/dist/src/command-line/migrate/multi-major.js

@@ -149,8 +149,11 @@ async function maybePromptOrWarnMultiMajorMigration(args) {
         resolveLatestStableInMajor(targetPackage, installedMajor + 1),
     ]);
     // Only suggest the current-major latest when there's at least a minor
-    // delta — a same-minor patch bump isn't a meaningful incremental step.
-    const showCurrent = latestInCurrent &&
+    // delta — a same-minor patch bump isn't a meaningful incremental step. Skip
+    // major 22 (last pre-v23) entirely: a 22.x step is the only sub-v23 option
+    // and conflicts with the mode gate already decided against the v23+ target.
+    const showCurrent = installedMajor !== 22 &&
+        latestInCurrent &&
         (0, semver_1.gt)(latestInCurrent, installed) &&
         (0, semver_1.minor)(latestInCurrent) > (0, semver_1.minor)(installed)
         ? latestInCurrent