nx 21.0.0-beta.1 → 21.0.0-beta.11

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

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordInitialMigrationMetadata = recordInitialMigrationMetadata;
+exports.finishMigrationProcess = finishMigrationProcess;
+exports.runSingleMigration = runSingleMigration;
+exports.getImplementationPath = getImplementationPath;
+exports.modifyMigrationsJsonMetadata = modifyMigrationsJsonMetadata;
+exports.addSuccessfulMigration = addSuccessfulMigration;
+exports.updateRefForSuccessfulMigration = updateRefForSuccessfulMigration;
+exports.addFailedMigration = addFailedMigration;
+exports.addSkippedMigration = addSkippedMigration;
+exports.readMigrationsJsonMetadata = readMigrationsJsonMetadata;
+exports.undoMigration = undoMigration;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const migrate_1 = require("./migrate");
+function recordInitialMigrationMetadata(workspacePath, versionToMigrateTo) {
+    const migrationsJsonPath = (0, path_1.join)(workspacePath, 'migrations.json');
+    const parsedMigrationsJson = JSON.parse((0, fs_1.readFileSync)(migrationsJsonPath, 'utf-8'));
+    const gitRef = (0, child_process_1.execSync)('git rev-parse HEAD', {
+        cwd: workspacePath,
+        encoding: 'utf-8',
+    }).trim();
+    const gitSubject = (0, child_process_1.execSync)('git log -1 --pretty=%s', {
+        cwd: workspacePath,
+        encoding: 'utf-8',
+    }).trim();
+    parsedMigrationsJson['nx-console'] = {
+        initialGitRef: {
+            ref: gitRef,
+            subject: gitSubject,
+        },
+        targetVersion: versionToMigrateTo,
+    };
+    (0, fs_1.writeFileSync)(migrationsJsonPath, JSON.stringify(parsedMigrationsJson, null, 2));
+}
+function finishMigrationProcess(workspacePath, squashCommits, commitMessage) {
+    const migrationsJsonPath = (0, path_1.join)(workspacePath, 'migrations.json');
+    const parsedMigrationsJson = JSON.parse((0, fs_1.readFileSync)(migrationsJsonPath, 'utf-8'));
+    const initialGitRef = parsedMigrationsJson['nx-console'].initialGitRef;
+    if ((0, fs_1.existsSync)(migrationsJsonPath)) {
+        (0, fs_1.rmSync)(migrationsJsonPath);
+    }
+    (0, child_process_1.execSync)('git add .', {
+        cwd: workspacePath,
+        encoding: 'utf-8',
+    });
+    (0, child_process_1.execSync)(`git commit -m "${commitMessage}" --no-verify`, {
+        cwd: workspacePath,
+        encoding: 'utf-8',
+    });
+    if (squashCommits && initialGitRef) {
+        (0, child_process_1.execSync)(`git reset --soft ${initialGitRef.ref}`, {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+        (0, child_process_1.execSync)(`git commit -m "${commitMessage}" --no-verify`, {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+    }
+}
+async function runSingleMigration(workspacePath, migration, configuration) {
+    try {
+        modifyMigrationsJsonMetadata(workspacePath, addRunningMigration(migration.id));
+        const gitRefBefore = (0, child_process_1.execSync)('git rev-parse HEAD', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        }).trim();
+        // For Migrate UI, this current module is loaded either from:
+        // 1. The CLI path to the migrated modules. The version of Nx is of the user's choosing. This may or may not have the new migrate API, so Console will check that `runSingleMigration` exists before using it.
+        // 2. Bundled into Console, so the version is fixed to what we build Console with.
+        const updatedMigrateModule = await Promise.resolve().then(() => require('./migrate.js'));
+        const { changes: fileChanges } = await updatedMigrateModule.runNxOrAngularMigration(workspacePath, migration, false, configuration.createCommits, configuration.commitPrefix || 'chore: [nx migration] ', undefined, true);
+        const gitRefAfter = (0, child_process_1.execSync)('git rev-parse HEAD', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        }).trim();
+        modifyMigrationsJsonMetadata(workspacePath, addSuccessfulMigration(migration.id, fileChanges.map((change) => ({
+            path: change.path,
+            type: change.type,
+        })), gitRefAfter));
+        if (gitRefBefore !== gitRefAfter) {
+            (0, child_process_1.execSync)('git add migrations.json', {
+                cwd: workspacePath,
+                encoding: 'utf-8',
+            });
+            (0, child_process_1.execSync)('git commit --amend --no-verify --no-edit', {
+                cwd: workspacePath,
+                encoding: 'utf-8',
+            });
+            // The revision changes after the amend, so we need to update it
+            const amendedGitRef = (0, child_process_1.execSync)('git rev-parse HEAD', {
+                cwd: workspacePath,
+                encoding: 'utf-8',
+            }).trim();
+            modifyMigrationsJsonMetadata(workspacePath, updateRefForSuccessfulMigration(migration.id, amendedGitRef));
+        }
+    }
+    catch (e) {
+        modifyMigrationsJsonMetadata(workspacePath, addFailedMigration(migration.id, e.message));
+    }
+    finally {
+        modifyMigrationsJsonMetadata(workspacePath, removeRunningMigration(migration.id));
+        (0, child_process_1.execSync)('git add migrations.json', {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+    }
+}
+async function getImplementationPath(workspacePath, migration) {
+    const { collection, collectionPath } = (0, migrate_1.readMigrationCollection)(migration.package, workspacePath);
+    const { path } = (0, migrate_1.getImplementationPath)(collection, collectionPath, migration.name);
+    return path;
+}
+function modifyMigrationsJsonMetadata(workspacePath, modify) {
+    const migrationsJsonPath = (0, path_1.join)(workspacePath, 'migrations.json');
+    const migrationsJson = JSON.parse((0, fs_1.readFileSync)(migrationsJsonPath, 'utf-8'));
+    migrationsJson['nx-console'] = modify(migrationsJson['nx-console']);
+    (0, fs_1.writeFileSync)(migrationsJsonPath, JSON.stringify(migrationsJson, null, 2));
+}
+function addSuccessfulMigration(id, fileChanges, ref) {
+    return (migrationsJsonMetadata) => {
+        const copied = { ...migrationsJsonMetadata };
+        if (!copied.completedMigrations) {
+            copied.completedMigrations = {};
+        }
+        copied.completedMigrations = {
+            ...copied.completedMigrations,
+            [id]: {
+                type: 'successful',
+                name: id,
+                changedFiles: fileChanges,
+                ref,
+            },
+        };
+        return copied;
+    };
+}
+function updateRefForSuccessfulMigration(id, ref) {
+    return (migrationsJsonMetadata) => {
+        const copied = { ...migrationsJsonMetadata };
+        if (!copied.completedMigrations) {
+            copied.completedMigrations = {};
+        }
+        const existing = copied.completedMigrations[id];
+        if (existing && existing.type === 'successful') {
+            existing.ref = ref;
+        }
+        else {
+            throw new Error(`Attempted to update ref for unsuccessful migration`);
+        }
+        return copied;
+    };
+}
+function addFailedMigration(id, error) {
+    return (migrationsJsonMetadata) => {
+        const copied = { ...migrationsJsonMetadata };
+        if (!copied.completedMigrations) {
+            copied.completedMigrations = {};
+        }
+        copied.completedMigrations = {
+            ...copied.completedMigrations,
+            [id]: {
+                type: 'failed',
+                name: id,
+                error,
+            },
+        };
+        return copied;
+    };
+}
+function addSkippedMigration(id) {
+    return (migrationsJsonMetadata) => {
+        const copied = { ...migrationsJsonMetadata };
+        if (!copied.completedMigrations) {
+            copied.completedMigrations = {};
+        }
+        copied.completedMigrations = {
+            ...copied.completedMigrations,
+            [id]: {
+                type: 'skipped',
+            },
+        };
+        return copied;
+    };
+}
+function addRunningMigration(id) {
+    return (migrationsJsonMetadata) => {
+        migrationsJsonMetadata.runningMigrations = [
+            ...(migrationsJsonMetadata.runningMigrations ?? []),
+            id,
+        ];
+        return migrationsJsonMetadata;
+    };
+}
+function removeRunningMigration(id) {
+    return (migrationsJsonMetadata) => {
+        migrationsJsonMetadata.runningMigrations =
+            migrationsJsonMetadata.runningMigrations?.filter((n) => n !== id);
+        if (migrationsJsonMetadata.runningMigrations?.length === 0) {
+            delete migrationsJsonMetadata.runningMigrations;
+        }
+        return migrationsJsonMetadata;
+    };
+}
+function readMigrationsJsonMetadata(workspacePath) {
+    const migrationsJsonPath = (0, path_1.join)(workspacePath, 'migrations.json');
+    const migrationsJson = JSON.parse((0, fs_1.readFileSync)(migrationsJsonPath, 'utf-8'));
+    return migrationsJson['nx-console'];
+}
+function undoMigration(workspacePath, id) {
+    return (migrationsJsonMetadata) => {
+        const existing = migrationsJsonMetadata.completedMigrations[id];
+        if (existing.type !== 'successful')
+            throw new Error(`undoMigration called on unsuccessful migration: ${id}`);
+        (0, child_process_1.execSync)(`git reset --hard ${existing.ref}^`, {
+            cwd: workspacePath,
+            encoding: 'utf-8',
+        });
+        migrationsJsonMetadata.completedMigrations[id] = {
+            type: 'skipped',
+        };
+        return migrationsJsonMetadata;
+    };
+}

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

@@ -1,5 +1,6 @@
 import { MigrationsJson, PackageJsonUpdateForPackage as PackageUpdate } from '../../config/misc-interfaces';
 import { NxJsonConfiguration } from '../../config/nx-json';
+import { FileChange } from '../../generators/tree';
 import { ArrayPackageGroup, PackageJson } from '../../utils/package-json';
 export interface ResolvedMigrationConfiguration extends MigrationsJson {
     packageGroup?: ArrayPackageGroup;
@@ -40,7 +41,6 @@ export declare class Migrator {
             name: string;
             version: string;
             description?: string;
-            cli?: string;
             implementation?: string;
             factory?: string;
             requires?: Record<string, string>;
@@ -100,16 +100,35 @@ export declare function executeMigrations(root: string, migrations: {
     name: string;
     description?: string;
     version: string;
-    cli?: 'nx' | 'angular';
 }[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string): Promise<{
+    migrationsWithNoChanges: {
+        package: string;
+        name: string;
+        description?: string;
+        version: string;
+    }[];
+    nextSteps: string[];
+}>;
+export declare function runNxOrAngularMigration(root: string, migration: {
     package: string;
     name: string;
     description?: string;
     version: string;
-    cli?: "nx" | "angular";
-}[]>;
+}, isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged?: () => void, handleInstallDeps?: boolean): Promise<{
+    changes: FileChange[];
+    nextSteps: string[];
+}>;
 export declare function migrate(root: string, args: {
     [k: string]: any;
 }, rawArgs: string[]): Promise<number>;
 export declare function runMigration(): void;
+export declare function readMigrationCollection(packageName: string, root: string): {
+    collection: MigrationsJson;
+    collectionPath: string;
+};
+export declare function getImplementationPath(collection: MigrationsJson, collectionPath: string, name: string): {
+    path: string;
+    fnSymbol: string;
+};
+export declare function nxCliPath(nxWorkspaceRoot?: string): string;
 export {};

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

@@ -4,8 +4,12 @@ exports.Migrator = void 0;
 exports.normalizeVersion = normalizeVersion;
 exports.parseMigrationsOptions = parseMigrationsOptions;
 exports.executeMigrations = executeMigrations;
+exports.runNxOrAngularMigration = runNxOrAngularMigration;
 exports.migrate = migrate;
 exports.runMigration = runMigration;
+exports.readMigrationCollection = readMigrationCollection;
+exports.getImplementationPath = getImplementationPath;
+exports.nxCliPath = nxCliPath;
 const chalk = require("chalk");
 const child_process_1 = require("child_process");
 const enquirer_1 = require("enquirer");
@@ -643,7 +647,11 @@ async function getPackageMigrationsUsingInstall(packageName, packageVersion) {
         result = { ...migrations, packageGroup, version: packageJson.version };
     }
     catch (e) {
-        logger_1.logger.warn(`Unable to fetch migrations for ${packageName}@${packageVersion}: ${e.message}`);
+        output_1.output.warn({
+            title: `Failed to fetch migrations for ${packageName}@${packageVersion}`,
+            bodyLines: [e.message],
+        });
+        return {};
     }
     finally {
         await cleanup();
@@ -809,9 +817,12 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts) {
             // The above code is to remind folks when updating to a new major and not currently using Nx cloud.
             // If for some reason it fails, it shouldn't affect the overall migration process
         }
-        output_1.output.log({
-            title: 'Next steps:',
-            bodyLines: [
+        const bodyLines = process.env['NX_CONSOLE']
+            ? [
+                '- Inspect the package.json changes in the built-in diff editor [Click to open]',
+                '- Confirm the changes to install the new dependencies and continue the migration',
+            ]
+            : [
                 `- Make sure package.json changes make sense and then run '${pmc.install}',`,
                 ...(migrations.length > 0
                     ? [`- Run '${pmc.exec} nx migrate --run-migrations'`]
@@ -830,7 +841,10 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts) {
                         `- You may run '${pmc.run('nx', 'connect-to-nx-cloud')}' to get faster builds, GitHub integration, and more. Check out https://nx.app`,
                     ]
                     : []),
-            ],
+            ];
+        output_1.output.log({
+            title: 'Next steps:',
+            bodyLines,
         });
     }
     catch (e) {
@@ -860,7 +874,6 @@ function addSplitConfigurationMigrationIfAvailable(from, packageJson) {
             {
                 version: '15.7.0-beta.0',
                 description: 'Split global configuration files into individual project.json files. This migration has been added automatically to the beginning of your migration set to retroactively make them work with the new version of Nx.',
-                cli: 'nx',
                 implementation: './src/migrations/update-15-7-0/split-configuration-into-project-json-files',
                 package: '@nrwl/workspace',
                 name: '15-7-0-split-configuration-into-project-json-files',
@@ -881,26 +894,31 @@ function showConnectToCloudMessage() {
         return false;
     }
 }
-function runInstall() {
-    const pmCommands = (0, package_manager_1.getPackageManagerCommand)();
+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)();
+    }
     // TODO: remove this
-    if ((0, package_manager_1.detectPackageManager)() === 'npm') {
+    if (packageManager ?? (0, package_manager_1.detectPackageManager)() === 'npm') {
         process.env.npm_config_legacy_peer_deps ??= 'true';
     }
     output_1.output.log({
         title: `Running '${pmCommands.install}' to make sure necessary packages are installed`,
     });
-    (0, child_process_1.execSync)(pmCommands.install, { stdio: [0, 1, 2], windowsHide: false });
+    (0, child_process_1.execSync)(pmCommands.install, {
+        stdio: [0, 1, 2],
+        windowsHide: false,
+        cwd: nxWorkspaceRoot ?? process.cwd(),
+    });
 }
 async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix) {
-    let initialDeps = getStringifiedPackageJsonDeps(root);
-    const installDepsIfChanged = () => {
-        const currentDeps = getStringifiedPackageJsonDeps(root);
-        if (initialDeps !== currentDeps) {
-            runInstall();
-        }
-        initialDeps = currentDeps;
-    };
+    const changedDepInstaller = new ChangedDepInstaller(root);
     const migrationsWithNoChanges = [];
     const sortedMigrations = migrations.sort((a, b) => {
         // special case for the split configuration migration to run first
@@ -917,52 +935,14 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
     logger_1.logger.info(`Running the following migrations:`);
     sortedMigrations.forEach((m) => logger_1.logger.info(`- ${m.package}: ${m.name} (${m.description})`));
     logger_1.logger.info(`---------------------------------------------------------\n`);
+    const allNextSteps = [];
     for (const m of sortedMigrations) {
         logger_1.logger.info(`Running migration ${m.package}: ${m.name}`);
         try {
-            const { collection, collectionPath } = readMigrationCollection(m.package, root);
-            if (!isAngularMigration(collection, collectionPath, m.name)) {
-                const changes = await runNxMigration(root, collectionPath, collection, m.name);
-                logger_1.logger.info(`Ran ${m.name} from ${m.package}`);
-                logger_1.logger.info(`  ${m.description}\n`);
-                if (changes.length < 1) {
-                    logger_1.logger.info(`No changes were made\n`);
-                    migrationsWithNoChanges.push(m);
-                    continue;
-                }
-                logger_1.logger.info('Changes:');
-                (0, tree_1.printChanges)(changes, '  ');
-                logger_1.logger.info('');
-            }
-            else {
-                const ngCliAdapter = await getNgCompatLayer();
-                const { madeChanges, loggingQueue } = await ngCliAdapter.runMigration(root, m.package, m.name, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(await (0, project_graph_1.createProjectGraphAsync)()).projects, isVerbose);
-                logger_1.logger.info(`Ran ${m.name} from ${m.package}`);
-                logger_1.logger.info(`  ${m.description}\n`);
-                if (!madeChanges) {
-                    logger_1.logger.info(`No changes were made\n`);
-                    migrationsWithNoChanges.push(m);
-                    continue;
-                }
-                logger_1.logger.info('Changes:');
-                loggingQueue.forEach((log) => logger_1.logger.info('  ' + log));
-                logger_1.logger.info('');
-            }
-            if (shouldCreateCommits) {
-                installDepsIfChanged();
-                const commitMessage = `${commitPrefix}${m.name}`;
-                try {
-                    const committedSha = (0, git_utils_1.commitChanges)(commitMessage);
-                    if (committedSha) {
-                        logger_1.logger.info(chalk.dim(`- Commit created for changes: ${committedSha}`));
-                    }
-                    else {
-                        logger_1.logger.info(chalk.red(`- A commit could not be created/retrieved for an unknown reason`));
-                    }
-                }
-                catch (e) {
-                    logger_1.logger.info(chalk.red(`- ${e.message}`));
-                }
+            const { changes, nextSteps } = await runNxOrAngularMigration(root, m, isVerbose, shouldCreateCommits, commitPrefix, () => changedDepInstaller.installDepsIfChanged());
+            allNextSteps.push(...nextSteps);
+            if (changes.length === 0) {
+                migrationsWithNoChanges.push(m);
             }
             logger_1.logger.info(`---------------------------------------------------------`);
         }
@@ -974,9 +954,78 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
         }
     }
     if (!shouldCreateCommits) {
+        changedDepInstaller.installDepsIfChanged();
+    }
+    return { migrationsWithNoChanges, nextSteps: allNextSteps };
+}
+class ChangedDepInstaller {
+    constructor(root) {
+        this.root = root;
+        this.initialDeps = getStringifiedPackageJsonDeps(root);
+    }
+    installDepsIfChanged() {
+        const currentDeps = getStringifiedPackageJsonDeps(this.root);
+        if (this.initialDeps !== currentDeps) {
+            runInstall(this.root);
+        }
+        this.initialDeps = currentDeps;
+    }
+}
+async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateCommits, commitPrefix, installDepsIfChanged, handleInstallDeps = false) {
+    if (!installDepsIfChanged) {
+        const changedDepInstaller = new ChangedDepInstaller(root);
+        installDepsIfChanged = () => changedDepInstaller.installDepsIfChanged();
+    }
+    const { collection, collectionPath } = readMigrationCollection(migration.package, root);
+    let changes = [];
+    let nextSteps = [];
+    if (!isAngularMigration(collection, migration.name)) {
+        ({ nextSteps, changes } = await runNxMigration(root, collectionPath, collection, migration.name));
+        logger_1.logger.info(`Ran ${migration.name} from ${migration.package}`);
+        logger_1.logger.info(`  ${migration.description}\n`);
+        if (changes.length < 1) {
+            logger_1.logger.info(`No changes were made\n`);
+            return { changes, nextSteps };
+        }
+        logger_1.logger.info('Changes:');
+        (0, tree_1.printChanges)(changes, '  ');
+        logger_1.logger.info('');
+    }
+    else {
+        const ngCliAdapter = await getNgCompatLayer();
+        const { madeChanges, loggingQueue } = await ngCliAdapter.runMigration(root, migration.package, migration.name, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(await (0, project_graph_1.createProjectGraphAsync)())
+            .projects, isVerbose);
+        logger_1.logger.info(`Ran ${migration.name} from ${migration.package}`);
+        logger_1.logger.info(`  ${migration.description}\n`);
+        if (!madeChanges) {
+            logger_1.logger.info(`No changes were made\n`);
+            return { changes, nextSteps };
+        }
+        logger_1.logger.info('Changes:');
+        loggingQueue.forEach((log) => logger_1.logger.info('  ' + log));
+        logger_1.logger.info('');
+    }
+    if (shouldCreateCommits) {
+        installDepsIfChanged();
+        const commitMessage = `${commitPrefix}${migration.name}`;
+        try {
+            const committedSha = (0, git_utils_1.commitChanges)(commitMessage, root);
+            if (committedSha) {
+                logger_1.logger.info(chalk.dim(`- Commit created for changes: ${committedSha}`));
+            }
+            else {
+                logger_1.logger.info(chalk.red(`- A commit could not be created/retrieved for an unknown reason`));
+            }
+        }
+        catch (e) {
+            logger_1.logger.info(chalk.red(`- ${e.message}`));
+        }
+        // if we are running this function alone, we need to install deps internally
+    }
+    else if (handleInstallDeps) {
         installDepsIfChanged();
     }
-    return migrationsWithNoChanges;
+    return { changes, nextSteps };
 }
 async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix) {
     if (!process.env.NX_MIGRATE_SKIP_INSTALL) {
@@ -1010,7 +1059,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 = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix);
+    const { migrationsWithNoChanges, nextSteps } = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix);
     if (migrationsWithNoChanges.length < migrations.length) {
         output_1.output.success({
             title: `Successfully finished running migrations from '${opts.runMigrations}'. This workspace is up to date!`,
@@ -1021,6 +1070,12 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits =
             title: `No changes were made from running '${opts.runMigrations}'. This workspace is up to date!`,
         });
     }
+    if (nextSteps.length > 0) {
+        output_1.output.log({
+            title: `Some migrations have additional information, see below.`,
+            bodyLines: nextSteps.map((line) => `- ${line}`),
+        });
+    }
 }
 function getStringifiedPackageJsonDeps(root) {
     try {
@@ -1037,11 +1092,18 @@ async function runNxMigration(root, collectionPath, collection, name) {
     const { path: implPath, fnSymbol } = getImplementationPath(collection, collectionPath, name);
     const fn = require(implPath)[fnSymbol];
     const host = new tree_1.FsTree(root, process.env.NX_VERBOSE_LOGGING === 'true', `migration ${collection.name}:${name}`);
-    await fn(host, {});
+    let nextSteps = await fn(host, {});
+    // This accounts for migrations that mistakenly return a generator callback
+    // from a migration. We've never executed these, so its not a breaking change that
+    // we don't call them now... but currently shipping a migration with one wouldn't break
+    // the migrate flow, so we are being cautious.
+    if (!isStringArray(nextSteps)) {
+        nextSteps = [];
+    }
     host.lock();
     const changes = host.listChanges();
     (0, tree_1.flushChanges)(root, changes);
-    return changes;
+    return { changes, nextSteps };
 }
 async function migrate(root, args, rawArgs) {
     await client_1.daemonClient.stop();
@@ -1111,7 +1173,7 @@ function getImplementationPath(collection, collectionPath, name) {
     }
     return { path: implPath, fnSymbol };
 }
-function nxCliPath() {
+function nxCliPath(nxWorkspaceRoot) {
     const version = process.env.NX_MIGRATE_CLI_VERSION || 'latest';
     try {
         const packageManager = (0, package_manager_1.detectPackageManager)();
@@ -1124,7 +1186,7 @@ function nxCliPath() {
             },
             license: 'MIT',
         });
-        (0, package_manager_1.copyPackageManagerConfigurationFiles)(workspace_root_1.workspaceRoot, tmpDir);
+        (0, package_manager_1.copyPackageManagerConfigurationFiles)(nxWorkspaceRoot ?? workspace_root_1.workspaceRoot, tmpDir);
         if (pmc.preInstall) {
             // ensure package.json and repo in tmp folder is set to a proper package manager state
             (0, child_process_1.execSync)(pmc.preInstall, {
@@ -1148,7 +1210,7 @@ function nxCliPath() {
         });
         // Set NODE_PATH so that these modules can be used for module resolution
         addToNodePath((0, path_1.join)(tmpDir, 'node_modules'));
-        addToNodePath((0, path_1.join)(workspace_root_1.workspaceRoot, 'node_modules'));
+        addToNodePath((0, path_1.join)(nxWorkspaceRoot ?? workspace_root_1.workspaceRoot, 'node_modules'));
         return (0, path_1.join)(tmpDir, `node_modules`, '.bin', 'nx');
     }
     catch (e) {
@@ -1171,24 +1233,8 @@ function addToNodePath(dir) {
     // Update the env variable.
     process.env.NODE_PATH = paths.join(delimiter);
 }
-// TODO (v21): Remove CLI determination of Angular Migration
-function isAngularMigration(collection, collectionPath, name) {
-    const entry = collection.generators?.[name] || collection.schematics?.[name];
-    const shouldBeNx = !!collection.generators?.[name];
-    const shouldBeNg = !!collection.schematics?.[name];
-    if (entry.cli && entry.cli !== 'nx' && collection.generators?.[name]) {
-        output_1.output.warn({
-            title: `The migration '${collection.name}:${name}' appears to be an Angular CLI migration, but is located in the 'generators' section of migrations.json.`,
-            bodyLines: [
-                'In Nx 21, migrations inside `generators` will be treated as Nx Devkit migrations and therefore may not run correctly if they are using Angular Devkit.',
-                'If the migration should be run with Angular Devkit, please place the migration inside `schematics` instead.',
-                "Please open an issue on the plugin's repository if you believe this is an error.",
-            ],
-        });
-    }
-    // Currently, if the cli property exists we listen to it. If its nx, its not an ng cli migration.
-    // If the property is not set, we will fall back to our intuition.
-    return entry.cli ? entry.cli !== 'nx' : !shouldBeNx && shouldBeNg;
+function isAngularMigration(collection, name) {
+    return !collection.generators?.[name] && collection.schematics?.[name];
 }
 const getNgCompatLayer = (() => {
     let _ngCliAdapter;
@@ -1200,3 +1246,9 @@ const getNgCompatLayer = (() => {
         return _ngCliAdapter;
     };
 })();
+function isStringArray(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every((v) => typeof v === 'string');
+}