nx 22.7.0 → 23.0.0-beta.1

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

@@ -64,7 +64,19 @@ function generateDotNxSetup(version) {
     (0, tree_1.flushChanges)(host.root, changes);
     // Ensure that the dot-nx installation is available.
     // 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.
-    (0, child_process_1.execSync)('./nx --version', { stdio: 'ignore', windowsHide: true });
+    // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
+    try {
+        (0, child_process_1.execSync)('./nx --version', {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        if (e?.stderr)
+            process.stderr.write(e.stderr);
+        throw e;
+    }
 }
 function normalizeVersionForNxJson(pkg, version) {
     if (!(0, semver_1.valid)(version)) {

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

@@ -60,7 +60,8 @@ function performInstallation(currentInstallation, nxJson) {
         },
     }));
     try {
-        cp.execSync('npm i', {
+        // --include=dev forces install even if consumer env sets NODE_ENV=production / omit=dev.
+        cp.execSync('npm i --include=dev', {
             cwd: path.dirname(installationPath),
             stdio: 'inherit',
             windowsHide: true,

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

@@ -61,6 +61,11 @@ function withMigrationOptions(yargs) {
         describe: 'Exclude migrations that should have been applied on previous updates. To be used with --from.',
         type: 'boolean',
         default: false,
+    })
+        .option('skipInstall', {
+        describe: 'Skip installing packages before running migrations. Useful when the installation needs to be performed manually (e.g., to resolve peer dependency conflicts).',
+        type: 'boolean',
+        default: false,
     })
         .check(({ createCommits, commitPrefix, from, excludeAppliedMigrations }) => {
         if (!createCommits && commitPrefix !== defaultCommitPrefix) {

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

@@ -104,12 +104,20 @@ type RunMigrations = {
 export declare function parseMigrationsOptions(options: {
     [k: string]: any;
 }): Promise<GenerateMigrations | RunMigrations>;
+/**
+ * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
+ * error code, which npm consistently emits for this class of failure across
+ * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
+ * small set of stable phrases in case the code line is missing from the
+ * captured output.
+ */
+export declare function isNpmPeerDepsError(stderr: string): boolean;
 export declare function executeMigrations(root: string, migrations: {
     package: string;
     name: string;
     description?: string;
     version: string;
-}[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string): Promise<{
+}[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, shouldSkipInstall?: boolean): Promise<{
     migrationsWithNoChanges: {
         package: string;
         name: string;
@@ -123,7 +131,7 @@ export declare function runNxOrAngularMigration(root: string, migration: {
     name: string;
     description?: string;
     version: string;
-}, isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged?: () => void, handleInstallDeps?: boolean): Promise<{
+}, isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged?: () => Promise<void>, handleInstallDeps?: boolean): Promise<{
     changes: FileChange[];
     nextSteps: string[];
 }>;

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

@@ -4,6 +4,7 @@ exports.Migrator = void 0;
 exports.formatCommandFailure = formatCommandFailure;
 exports.normalizeVersion = normalizeVersion;
 exports.parseMigrationsOptions = parseMigrationsOptions;
+exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.executeMigrations = executeMigrations;
 exports.runNxOrAngularMigration = runNxOrAngularMigration;
 exports.migrate = migrate;
@@ -1064,28 +1065,120 @@ function showConnectToCloudMessage() {
         return false;
     }
 }
-function runInstall(nxWorkspaceRoot) {
-    let packageManager;
-    let pmCommands;
-    if (nxWorkspaceRoot) {
-        packageManager = (0, package_manager_1.detectPackageManager)(nxWorkspaceRoot);
-        pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, nxWorkspaceRoot);
-    }
-    else {
-        pmCommands = (0, package_manager_1.getPackageManagerCommand)();
-    }
+function runInstall(nxWorkspaceRoot, phase = 'pre-migration') {
+    const cwd = nxWorkspaceRoot ?? process.cwd();
+    const packageManager = (0, package_manager_1.detectPackageManager)(cwd);
+    const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, cwd);
     const installCommand = `${pmCommands.install} ${pmCommands.ignoreScriptsFlag ?? ''}`;
     output_1.output.log({
         title: `Running '${installCommand}' to make sure necessary packages are installed`,
     });
-    (0, child_process_1.execSync)(installCommand, {
-        stdio: [0, 1, 2],
-        windowsHide: true,
-        cwd: nxWorkspaceRoot ?? process.cwd(),
+    return new Promise((resolve, reject) => {
+        // For npm, pipe stderr so we can detect peer dependency errors while still
+        // mirroring it live to the user's terminal. Other package managers inherit
+        // stderr directly since we don't need to inspect their output.
+        const shouldCaptureStderr = packageManager === 'npm';
+        const child = (0, child_process_1.spawn)(installCommand, {
+            shell: true,
+            stdio: ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
+            windowsHide: true,
+            cwd,
+        });
+        const stderrChunks = [];
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(chunk);
+            stderrChunks.push(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            if (shouldCaptureStderr) {
+                const stderr = Buffer.concat(stderrChunks).toString().trim();
+                if (isNpmPeerDepsError(stderr)) {
+                    // Log the remediation guidance here so every caller of `runInstall`
+                    // (CLI migrate, `nx repair`, single-migration runner, etc.) surfaces
+                    // it consistently. Top-level callers catch `NpmPeerDepsInstallError`
+                    // and return a non-zero exit code without re-logging.
+                    logNpmPeerDepsError(phase);
+                    reject(new NpmPeerDepsInstallError());
+                    return;
+                }
+            }
+            reject(new Error(`Command failed: ${installCommand}`));
+        });
     });
 }
-async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix) {
-    const changedDepInstaller = new ChangedDepInstaller(root);
+class NpmPeerDepsInstallError extends Error {
+    constructor() {
+        super('npm install failed due to peer dependency conflicts.');
+        this.name = 'NpmPeerDepsInstallError';
+    }
+}
+/**
+ * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
+ * error code, which npm consistently emits for this class of failure across
+ * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
+ * small set of stable phrases in case the code line is missing from the
+ * captured output.
+ */
+function isNpmPeerDepsError(stderr) {
+    if (/\bERESOLVE\b/.test(stderr)) {
+        return true;
+    }
+    const lowerStderr = stderr.toLowerCase();
+    return (lowerStderr.includes('unable to resolve dependency tree') ||
+        lowerStderr.includes('could not resolve dependency') ||
+        lowerStderr.includes('conflicting peer dependency'));
+}
+function logNpmPeerDepsError(phase) {
+    const peerDepsResolutionSteps = [
+        'Recommended approaches (in order of preference):',
+        '',
+        '1. Use "overrides" in package.json to force compatible versions across the dependency tree.',
+        '   See https://docs.npmjs.com/cli/configuring-npm/package-json#overrides',
+        '2. Persist legacy peer deps resolution in the project ".npmrc":',
+        '   npm config set legacy-peer-deps=true --location=project',
+        '   (bypasses peer dependency resolution; use with caution)',
+        '3. As a last resort, force the installation by running "npm install --force".',
+        '   (does not persist and may produce broken installs)',
+    ];
+    const manualInstallHint = [
+        'If you installed the dependencies manually, pass "--skip-install" to avoid re-installing them:',
+        '   nx migrate --run-migrations --skip-install',
+    ];
+    if (phase === 'pre-migration') {
+        output_1.output.error({
+            title: 'You need to resolve the peer dependency conflicts before the migration can continue',
+            bodyLines: [
+                ...peerDepsResolutionSteps,
+                '',
+                'Once the conflicts are resolved, re-run the migrations:',
+                '   nx migrate --run-migrations',
+                '',
+                ...manualInstallHint,
+            ],
+        });
+    }
+    else {
+        output_1.output.error({
+            title: 'Some migrations have been applied, but installing the updated dependencies failed',
+            bodyLines: [
+                ...peerDepsResolutionSteps,
+                '',
+                'Once the conflicts are resolved, run "npm install" to install the updated dependencies.',
+                'If the migration was interrupted before completing, re-run the remaining migrations:',
+                '   nx migrate --run-migrations',
+                '',
+                ...manualInstallHint,
+            ],
+        });
+    }
+}
+async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall = false) {
+    const changedDepInstaller = new ChangedDepInstaller(root, shouldSkipInstall);
     const migrationsWithNoChanges = [];
     const sortedMigrations = migrations.sort((a, b) => {
         // special case for the split configuration migration to run first
@@ -1114,30 +1207,53 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
             logger_1.logger.info(`---------------------------------------------------------`);
         }
         catch (e) {
-            output_1.output.error({
-                title: `Failed to run ${m.name} from ${m.package}. This workspace is NOT up to date!`,
-            });
+            if (!(e instanceof NpmPeerDepsInstallError)) {
+                output_1.output.error({
+                    title: `Failed to run ${m.name} from ${m.package}. This workspace is NOT up to date!`,
+                });
+            }
             throw e;
         }
     }
     if (!shouldCreateCommits) {
-        changedDepInstaller.installDepsIfChanged();
+        await changedDepInstaller.installDepsIfChanged();
+    }
+    if (changedDepInstaller.skippedInstall) {
+        logSkippedPostMigrationInstall(root);
     }
     return { migrationsWithNoChanges, nextSteps: allNextSteps };
 }
 class ChangedDepInstaller {
-    constructor(root) {
+    constructor(root, shouldSkipInstall = false) {
         this.root = root;
+        this.shouldSkipInstall = shouldSkipInstall;
+        this._skippedInstall = false;
         this.initialDeps = getStringifiedPackageJsonDeps(root);
     }
-    installDepsIfChanged() {
+    get skippedInstall() {
+        return this._skippedInstall;
+    }
+    async installDepsIfChanged() {
         const currentDeps = getStringifiedPackageJsonDeps(this.root);
         if (this.initialDeps !== currentDeps) {
-            runInstall(this.root);
+            if (this.shouldSkipInstall) {
+                this._skippedInstall = true;
+            }
+            else {
+                await runInstall(this.root, 'post-migration');
+            }
         }
         this.initialDeps = currentDeps;
     }
 }
+function logSkippedPostMigrationInstall(root) {
+    const packageManager = (0, package_manager_1.detectPackageManager)(root);
+    const installCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager, root).install;
+    output_1.output.warn({
+        title: 'Migrations updated your dependencies, but the install was skipped',
+        bodyLines: [`Run "${installCommand}" to install the updated dependencies.`],
+    });
+}
 async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateCommits, commitPrefix, installDepsIfChanged, handleInstallDeps = false) {
     if (!installDepsIfChanged) {
         const changedDepInstaller = new ChangedDepInstaller(root);
@@ -1173,7 +1289,7 @@ async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateC
         logger_1.logger.info('');
     }
     if (shouldCreateCommits) {
-        installDepsIfChanged();
+        await installDepsIfChanged();
         const commitMessage = `${commitPrefix}${migration.name}`;
         try {
             const committedSha = (0, git_utils_1.commitChanges)(commitMessage, root);
@@ -1190,13 +1306,13 @@ async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateC
         // if we are running this function alone, we need to install deps internally
     }
     else if (handleInstallDeps) {
-        installDepsIfChanged();
+        await installDepsIfChanged();
     }
     return { changes, nextSteps };
 }
-async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix) {
-    if (!process.env.NX_MIGRATE_SKIP_INSTALL) {
-        runInstall();
+async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix, shouldSkipInstall = false) {
+    if (!shouldSkipInstall && !process.env.NX_MIGRATE_SKIP_INSTALL) {
+        await runInstall();
     }
     if (!__dirname.startsWith(workspace_root_1.workspaceRoot)) {
         // we are running from a temp installation with nx latest, switch to running
@@ -1229,7 +1345,7 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits =
             (shouldCreateCommits ? ', with each applied in a dedicated commit' : ''),
     });
     const migrations = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, opts.runMigrations)).migrations;
-    const { migrationsWithNoChanges, nextSteps } = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix);
+    const { migrationsWithNoChanges, nextSteps } = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall);
     if (migrationsWithNoChanges.length < migrations.length) {
         output_1.output.success({
             title: `Successfully finished running migrations from '${opts.runMigrations}'. This workspace is up to date!`,
@@ -1283,7 +1399,18 @@ async function migrate(root, args, rawArgs) {
             await generateMigrationsJsonAndUpdatePackageJson(root, opts);
         }
         else {
-            return runMigrations(root, opts, rawArgs, args['verbose'], args['createCommits'], args['commitPrefix']);
+            try {
+                return await runMigrations(root, opts, rawArgs, args['verbose'], args['createCommits'], args['commitPrefix'], args['skipInstall']);
+            }
+            catch (e) {
+                // The remediation guidance is already logged by `runInstall`; swallow
+                // the error here so `handleErrors` doesn't print a noisy stack after
+                // the friendly output.
+                if (e instanceof NpmPeerDepsInstallError) {
+                    return 1;
+                }
+                throw e;
+            }
         }
     });
 }

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

@@ -260,4 +260,14 @@ export interface TargetConfiguration<T = any> {
      * is up to date.
      */
     syncGenerators?: string[];
+    /**
+     * Spread token used when merging target configurations. When set to `true`,
+     * base (inferred) values take priority over this target's values for any
+     * shared keys — effectively "only add new keys without overwriting inferred
+     * values". Keys that do not exist in the base target are still added.
+     *
+     * The position of `'...'` in the object's key order follows standard
+     * last-write-wins semantics with {@link https://nx.dev/reference/project-configuration#spread-token}.
+     */
+    '...'?: true;
 }