nx 23.0.1 → 23.0.2

package/dist/bin/init-local.js

@@ -162,7 +162,7 @@ function handleAngularCLIFallbacks(workspace) {
         console.log(`- fix migrations that "almost work"`);
         console.log(`- commit a partially migrated state`);
         console.log(`- change versions of packages to match organizational requirements`);
-        console.log(`And, in general, it is lot more reliable for non-trivial workspaces. Read more at: https://nx.dev/getting-started/nx-and-angular#ng-update-and-nx-migrate`);
+        console.log(`And, in general, it is lot more reliable for non-trivial workspaces. Read more at: https://nx.dev/docs/technologies/angular/guides/nx-and-angular#ng-update-vs-nx-migrate`);
         console.log(`Run "nx migrate latest" to update to the latest version of Nx.`);
         console.log(`Running "ng update" can still be useful in some dev workflows, so we aren't planning to remove it.`);
         console.log(`If you need to use it, run "FORCE_NG_UPDATE=true ng update".`);

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.d.ts

@@ -1,5 +1,6 @@
 import { Tree } from '../../../../generators/tree';
 export declare const nxWrapperPath: (p?: typeof import("path")) => string;
+export declare function getDotNxWrapperVersionCommand(platform?: NodeJS.Platform): string;
 export declare function generateDotNxSetup(version?: string): void;
 export declare function normalizeVersionForNxJson(pkg: string, version: string): string;
 export declare function writeMinimalNxJson(host: Tree, version: string): void;

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxWrapperPath = void 0;
+exports.getDotNxWrapperVersionCommand = getDotNxWrapperVersionCommand;
 exports.generateDotNxSetup = generateDotNxSetup;
 exports.normalizeVersionForNxJson = normalizeVersionForNxJson;
 exports.writeMinimalNxJson = writeMinimalNxJson;
@@ -50,6 +51,10 @@ const SHELL_SCRIPT_CONTENTS = [
     // Executes the nx wrapper script
     `node ${path.posix.join('$path_to_root', (0, exports.nxWrapperPath)(path.posix))} "$@"`,
 ].join('\n');
+// cmd.exe can't run the bash './nx' wrapper; use the generated nx.bat on Windows.
+function getDotNxWrapperVersionCommand(platform = process.platform) {
+    return platform === 'win32' ? '.\\nx.bat --version' : './nx --version';
+}
 function generateDotNxSetup(version) {
     const host = new tree_1.FsTree(process.cwd(), false, '.nx setup');
     writeMinimalNxJson(host, version);
@@ -66,7 +71,7 @@ function generateDotNxSetup(version) {
     // This is needed when using a global nx with dot-nx, otherwise running any nx command using global command will fail due to missing modules.
     // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
     try {
-        (0, child_process_1.execSync)('./nx --version', {
+        (0, child_process_1.execSync)(getDotNxWrapperVersionCommand(), {
             stdio: ['ignore', 'ignore', 'pipe'],
             encoding: 'utf8',
             windowsHide: true,

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

@@ -348,7 +348,7 @@ async function runInit(options, baseMeta) {
     }
     else {
         nxCloudChoice = options.interactive
-            ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+            ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)('init', 'setupNxCloud', false)
             : 'skip';
     }
     if (nxCloudChoice === 'yes') {

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

@@ -85,6 +85,7 @@ export declare class Migrator {
     }>;
     private createMigrateJson;
     private buildPackageJsonUpdates;
+    private resolveVersionForCascade;
     private populatePackageJsonUpdatesAndGetPackagesToCheck;
     private getPackageJsonUpdatesFromMigrationConfig;
     /**
@@ -172,6 +173,7 @@ export declare function createFetcher(pmc: PackageManagerCommands): ((pkg: strin
     stats?: MigrateFetchStats;
 };
 export { filterDowngradedUpdates };
+export declare function generateMigrationsJsonAndUpdatePackageJson(root: string, opts: GenerateMigrations, fetch?: MigratorOptions['fetch']): Promise<void>;
 /**
  * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
  * error code, which npm consistently emits for this class of failure across

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

@@ -6,6 +6,7 @@ exports.resolveCanonicalNxPackage = resolveCanonicalNxPackage;
 exports.resolveInclude = resolveInclude;
 exports.parseMigrationsOptions = parseMigrationsOptions;
 exports.createFetcher = createFetcher;
+exports.generateMigrationsJsonAndUpdatePackageJson = generateMigrationsJsonAndUpdatePackageJson;
 exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.resolveAgenticRunId = resolveAgenticRunId;
 exports.formatSkippedPromptsNextStep = formatSkippedPromptsNextStep;
@@ -191,16 +192,37 @@ class Migrator {
                     !this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith) &&
                     (!this.interactive ||
                         (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
-                    Object.entries(packageUpdate.packages).forEach(([name, update]) => {
+                    const updateEntries = Object.entries(packageUpdate.packages);
+                    // Validate all up front so invalid metadata fails fast, before any
+                    // resolution does I/O.
+                    for (const [name, update] of updateEntries) {
                         this.validatePackageUpdateVersion(packageToCheck.package, name, update);
-                        filteredUpdates[name] = update;
-                        this.packageUpdates[name] = update;
-                    });
+                    }
+                    // Resolve serially: resolution can prompt (pnpm strict cooldown) and
+                    // append to minimumReleaseAgeExclude, so a serial loop avoids
+                    // overlapping prompts and keeps packageUpdates ordering stable.
+                    for (const [name, update] of updateEntries) {
+                        const resolvedUpdate = {
+                            ...update,
+                            version: await this.resolveVersionForCascade(name, update.version),
+                        };
+                        filteredUpdates[name] = resolvedUpdate;
+                        this.packageUpdates[name] = resolvedUpdate;
+                    }
                 }
             }
             await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
         }
     }
+    async resolveVersionForCascade(packageName, version) {
+        // Already a fully-qualified semver (incl. prereleases) - nothing to resolve.
+        if ((0, semver_1.valid)(version)) {
+            return version;
+        }
+        // Otherwise resolve the spec (range/tag) through the min-release-age policy,
+        // which also honors any configured minimumReleaseAgeExclude entries.
+        return (0, resolve_package_version_1.resolvePackageVersionRespectingMinReleaseAge)(packageName, version);
+    }
     async populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target) {
         let targetVersion = target.version;
         if (this.to[targetPackage]) {
@@ -1347,6 +1369,7 @@ function readNxVersion(packageJson, root) {
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nx/workspace', root, packageJson) ??
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nrwl/workspace', root, packageJson));
 }
+// Exported for testing the optional-include orchestration seam (see NXC-4590).
 async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
     let phase = 'fetch_migrations';
@@ -1417,7 +1440,11 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
         const writableUpdates = (0, update_filters_1.filterDowngradedUpdates)(packageUpdates, (0, catalog_1.resolveCatalogSpecifiers)(originalPackageJson), installedPackageVersions);
         const wrotePackageJson = await updatePackageJson(root, writableUpdates);
         const wroteNxJsonInstallation = await updateInstallationDetails(root, writableUpdates);
-        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, packageUpdates[walkedTargetPackage].version);
+        // Under `--include=optional` the target's own entry is filtered out of
+        // `packageUpdates` (it's a required package), so resolve the version
+        // defensively. Also reused by the completion analytics below.
+        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
+        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, resolvedTargetVersion);
         if (migrations.length > 0) {
             await createMigrationsFile(root, [
                 ...addSplitConfigurationMigrationIfAvailable(from, writableUpdates),
@@ -1429,7 +1456,6 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
             : include === 'optional'
                 ? `- Processed optional dependency updates only (skipped required package updates).`
                 : null;
-        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
         // The param expressions below evaluate before the report function is
         // entered; `safeReport` keeps them inside the analytics boundary so a
         // param-building throw can't surface here and convert an already

package/dist/src/command-line/nx-cloud/connect/connect-to-nx-cloud.d.ts

@@ -9,5 +9,5 @@ export declare function connectToNxCloudCommand(options: {
     generateToken?: boolean;
     checkRemote?: boolean;
 }, command?: string): Promise<boolean>;
-export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey): Promise<MessageOptionKey>;
+export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey, recordCompletion?: boolean): Promise<MessageOptionKey>;
 export declare function connectToNxCloudWithPrompt(command: string): Promise<void>;

package/dist/src/command-line/nx-cloud/connect/connect-to-nx-cloud.js

@@ -180,27 +180,34 @@ async function runConnectToNxCloud(options, command) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function connectExistingRepoToNxCloudPrompt(command = 'init', key = 'setupNxCloud') {
-    const res = await nxCloudPrompt(key, utmMediumForCommand(command));
-    await (0, ab_testing_1.recordStat)({
-        command,
-        nxVersion: versions_1.nxVersion,
-        useCloud: res === 'yes',
-        meta: {
-            type: 'complete',
-            setupCloudPrompt: ab_testing_1.messages.codeOfSelectedPromptMessage(key) || '',
-            nxCloudArg: res,
-            nodeVersion: process.versions.node,
-            os: process.platform,
-            packageManager: (0, package_manager_1.detectPackageManager)(),
-            aiAgent: (0, native_1.isAiAgent)(),
-            isCI: (0, is_ci_1.isCI)(),
-        },
-    });
+async function connectExistingRepoToNxCloudPrompt(command = 'init', key = 'setupNxCloud', recordCompletion = true) {
+    const res = await nxCloudPrompt(key, utmContentForCommand(command));
+    // TODO: once legacy init-v1 (the NX_ADD_PLUGINS=false / useInferencePlugins:false path) is
+    // removed, drop this recordStat and the recordCompletion flag entirely - init-v2 records its
+    // own complete, and view-logs should record its own stat, so this shared helper won't record.
+    // init-v2 records its own init "complete" stat, so it opts out here to avoid double-counting.
+    // Other callers (e.g. view-logs, legacy init-v1) rely on this as their only completion event.
+    if (recordCompletion) {
+        await (0, ab_testing_1.recordStat)({
+            command,
+            nxVersion: versions_1.nxVersion,
+            useCloud: res === 'yes',
+            meta: {
+                type: 'complete',
+                setupCloudPrompt: ab_testing_1.messages.codeOfSelectedPromptMessage(key) || '',
+                nxCloudArg: res,
+                nodeVersion: process.versions.node,
+                os: process.platform,
+                packageManager: (0, package_manager_1.detectPackageManager)(),
+                aiAgent: (0, native_1.isAiAgent)(),
+                isCI: (0, is_ci_1.isCI)(),
+            },
+        });
+    }
     return res;
 }
 async function connectToNxCloudWithPrompt(command) {
-    const setNxCloud = await nxCloudPrompt('setupNxCloud', utmMediumForCommand(command));
+    const setNxCloud = await nxCloudPrompt('setupNxCloud', utmContentForCommand(command));
     let useCloud = false;
     if (setNxCloud === 'yes') {
         useCloud = await connectToNxCloudCommand({ generateToken: false }, command);
@@ -229,7 +236,7 @@ async function connectToNxCloudWithPrompt(command) {
         },
     });
 }
-function utmMediumForCommand(command) {
+function utmContentForCommand(command) {
     switch (command) {
         case 'migrate':
             return 'nx-migrate';
@@ -239,7 +246,7 @@ function utmMediumForCommand(command) {
             return 'nx-init';
     }
 }
-async function nxCloudPrompt(key, utmMedium) {
+async function nxCloudPrompt(key, utmContent) {
     const { message, choices, initial, footer, hint } = ab_testing_1.messages.getPrompt(key);
     const promptConfig = {
         name: 'NxCloud',
@@ -249,7 +256,7 @@ async function nxCloudPrompt(key, utmMedium) {
         initial,
     }; // meeroslav: types in enquirer are not up to date
     if (footer) {
-        promptConfig.footer = () => pc.dim(`${footer} ${(0, ab_testing_1.nxCloudHyperlink)(utmMedium)}`);
+        promptConfig.footer = () => pc.dim(`${footer} ${(0, ab_testing_1.nxCloudHyperlink)(utmContent)}`);
     }
     if (hint) {
         promptConfig.hint = () => pc.dim(hint);

package/dist/src/command-line/release/version/resolve-current-version.js

@@ -67,7 +67,10 @@ async function resolveCurrentVersionFromRegistry(tree, projectGraphNode, release
         return cached.currentVersion;
     }
     let registryTxt = '';
-    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`);
+    // Skip non-TTY logging — the resolved version is reported through the
+    // project's batched `ProjectLogger` so the spinner step shouldn't emit an
+    // out-of-band line that would bypass the grouped output.
+    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`, undefined, { skipNonTtyLogging: true });
     try {
         const res = await versionActions.readCurrentVersionFromRegistry(tree, finalConfigForProject.currentVersionResolverMetadata);
         if (!res) {