nx 21.0.0-beta.1 → 21.0.0-beta.10

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 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,29 @@ export declare function executeMigrations(root: string, migrations: {
     name: string;
     description?: string;
     version: string;
-    cli?: 'nx' | 'angular';
 }[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string): Promise<{
     package: string;
     name: string;
     description?: string;
     version: string;
-    cli?: "nx" | "angular";
 }[]>;
+export declare function runNxOrAngularMigration(root: string, migration: {
+    package: string;
+    name: string;
+    description?: string;
+    version: string;
+}, isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged?: () => void, handleInstallDeps?: boolean): Promise<FileChange[]>;
 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
@@ -920,49 +938,9 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
     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 = await runNxOrAngularMigration(root, m, isVerbose, shouldCreateCommits, commitPrefix, () => changedDepInstaller.installDepsIfChanged());
+            if (changes.length === 0) {
+                migrationsWithNoChanges.push(m);
             }
             logger_1.logger.info(`---------------------------------------------------------`);
         }
@@ -974,10 +952,78 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
         }
     }
     if (!shouldCreateCommits) {
-        installDepsIfChanged();
+        changedDepInstaller.installDepsIfChanged();
     }
     return migrationsWithNoChanges;
 }
+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 = [];
+    if (!isAngularMigration(collection, migration.name)) {
+        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 [];
+        }
+        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 [];
+        }
+        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 changes;
+}
 async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix) {
     if (!process.env.NX_MIGRATE_SKIP_INSTALL) {
         runInstall();
@@ -1111,7 +1157,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 +1170,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 +1194,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 +1217,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;

package/src/command-line/nx-commands.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandsObject = exports.parserConfiguration = void 0;
 const chalk = require("chalk");
 const yargs = require("yargs");
-const command_object_1 = require("./activate-powerpack/command-object");
+const command_object_1 = require("./register/command-object");
 const command_object_2 = require("./affected/command-object");
 const command_object_3 = require("./connect/command-object");
 const command_object_4 = require("./daemon/command-object");
@@ -46,7 +46,7 @@ exports.commandsObject = yargs
     .parserConfiguration(exports.parserConfiguration)
     .usage(chalk.bold('Smart Monorepos · Fast CI'))
     .demandCommand(1, '')
-    .command(command_object_1.yargsActivatePowerpackCommand)
+    .command(command_object_1.yargsRegisterCommand)
     .command(command_object_22.yargsAddCommand)
     .command(command_object_2.yargsAffectedBuildCommand)
     .command(command_object_2.yargsAffectedCommand)
@@ -99,7 +99,7 @@ function createMissingConformanceCommand(command) {
             output_1.output.error({
                 title: `${command} is not available`,
                 bodyLines: [
-                    `In order to use the \`nx ${command}\` command you must have an active Powerpack license and the \`@nx/powerpack-conformance\` plugin installed.`,
+                    `In order to use the \`nx ${command}\` command you must have an active Nx key and the \`@nx/conformance\` plugin installed.`,
                     '',
                     'To learn more, visit https://nx.dev/nx-enterprise/powerpack/conformance',
                 ],
@@ -110,7 +110,14 @@ function createMissingConformanceCommand(command) {
 }
 function resolveConformanceCommandObject() {
     try {
-        const { yargsConformanceCommand } = require('@nx/powerpack-conformance');
+        const { yargsConformanceCommand } = (() => {
+            try {
+                return require('@nx/powerpack-conformance');
+            }
+            catch {
+                return require('@nx/conformance');
+            }
+        })();
         return yargsConformanceCommand;
     }
     catch {
@@ -119,7 +126,14 @@ function resolveConformanceCommandObject() {
 }
 function resolveConformanceCheckCommandObject() {
     try {
-        const { yargsConformanceCheckCommand, } = require('@nx/powerpack-conformance');
+        const { yargsConformanceCheckCommand } = (() => {
+            try {
+                return require('@nx/powerpack-conformance');
+            }
+            catch {
+                return require('@nx/conformance');
+            }
+        })();
         return yargsConformanceCheckCommand;
     }
     catch {

package/src/command-line/register/command-object.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from 'yargs';
+export interface RegisterOptions {
+    key?: string;
+    verbose?: boolean;
+}
+export declare const yargsRegisterCommand: CommandModule<{}, RegisterOptions>;

package/src/command-line/{activate-powerpack → register}/command-object.js

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.yargsActivatePowerpackCommand = void 0;
+exports.yargsRegisterCommand = void 0;
 const shared_options_1 = require("../yargs-utils/shared-options");
 const handle_errors_1 = require("../../utils/handle-errors");
-exports.yargsActivatePowerpackCommand = {
-    command: 'activate-powerpack <license>',
+exports.yargsRegisterCommand = {
+    command: 'register [key]',
+    aliases: ['activate-powerpack'],
     describe: false,
-    // describe: 'Activate a Nx Powerpack license.',
     builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
         .parserConfiguration({
         'strip-dashed': true,
         'unknown-options-as-args': true,
     })
-        .positional('license', {
+        .positional('key', {
         type: 'string',
-        description: 'This is a License Key for Nx Powerpack.',
+        description: 'This is a key for Nx.',
     })
-        .example('$0 activate-powerpack <license key>', 'Activate a Nx Powerpack license'),
+        .example('$0 register <key>', 'Register a Nx key'),
     handler: async (args) => {
-        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose, async () => {
-            return (await Promise.resolve().then(() => require('./activate-powerpack'))).handleActivatePowerpack(args);
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? false, async () => {
+            return (await Promise.resolve().then(() => require('./register'))).handleRegister(args);
         });
         process.exit(exitCode);
     },

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

@@ -0,0 +1,2 @@
+import { RegisterOptions } from './command-object';
+export declare function handleRegister(options: RegisterOptions): Promise<import("@nx/key").NxKey>;