nx 21.0.0-beta.4 → 21.0.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.0.0-beta.4",
+  "version": "21.0.0-beta.5",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.0.0-beta.4",
-    "@nx/nx-darwin-x64": "21.0.0-beta.4",
-    "@nx/nx-freebsd-x64": "21.0.0-beta.4",
-    "@nx/nx-linux-arm-gnueabihf": "21.0.0-beta.4",
-    "@nx/nx-linux-arm64-gnu": "21.0.0-beta.4",
-    "@nx/nx-linux-arm64-musl": "21.0.0-beta.4",
-    "@nx/nx-linux-x64-gnu": "21.0.0-beta.4",
-    "@nx/nx-linux-x64-musl": "21.0.0-beta.4",
-    "@nx/nx-win32-arm64-msvc": "21.0.0-beta.4",
-    "@nx/nx-win32-x64-msvc": "21.0.0-beta.4"
+    "@nx/nx-darwin-arm64": "21.0.0-beta.5",
+    "@nx/nx-darwin-x64": "21.0.0-beta.5",
+    "@nx/nx-freebsd-x64": "21.0.0-beta.5",
+    "@nx/nx-linux-arm-gnueabihf": "21.0.0-beta.5",
+    "@nx/nx-linux-arm64-gnu": "21.0.0-beta.5",
+    "@nx/nx-linux-arm64-musl": "21.0.0-beta.5",
+    "@nx/nx-linux-x64-gnu": "21.0.0-beta.5",
+    "@nx/nx-linux-x64-musl": "21.0.0-beta.5",
+    "@nx/nx-win32-arm64-msvc": "21.0.0-beta.5",
+    "@nx/nx-win32-x64-msvc": "21.0.0-beta.5"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -0,0 +1,56 @@
+import type { MigrationDetailsWithId } from '../../config/misc-interfaces';
+import type { FileChange } from '../../generators/tree';
+export type MigrationsJsonMetadata = {
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration>;
+    runningMigrations?: string[];
+    initialGitRef?: {
+        ref: string;
+        subject: string;
+    };
+    confirmedPackageUpdates?: boolean;
+    targetVersion?: string;
+};
+export type SuccessfulMigration = {
+    type: 'successful';
+    name: string;
+    changedFiles: Omit<FileChange, 'content'>[];
+    ref: string;
+};
+export type FailedMigration = {
+    type: 'failed';
+    name: string;
+    error: string;
+};
+export type SkippedMigration = {
+    type: 'skipped';
+};
+export declare function recordInitialMigrationMetadata(workspacePath: string, versionToMigrateTo: string): void;
+export declare function finishMigrationProcess(workspacePath: string, squashCommits: boolean, commitMessage: string): void;
+export declare function runSingleMigration(workspacePath: string, migration: MigrationDetailsWithId, configuration: {
+    createCommits: boolean;
+    commitPrefix?: string;
+}): Promise<void>;
+export declare function getImplementationPath(workspacePath: string, migration: MigrationDetailsWithId): Promise<string>;
+export declare function modifyMigrationsJsonMetadata(workspacePath: string, modify: (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata): void;
+export declare function addSuccessfulMigration(id: string, fileChanges: Omit<FileChange, 'content'>[], ref: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
+export declare function addFailedMigration(id: string, error: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => {
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration>;
+    runningMigrations?: string[];
+    initialGitRef?: {
+        ref: string;
+        subject: string;
+    };
+    confirmedPackageUpdates?: boolean;
+    targetVersion?: string;
+};
+export declare function addSkippedMigration(id: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => {
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration>;
+    runningMigrations?: string[];
+    initialGitRef?: {
+        ref: string;
+        subject: string;
+    };
+    confirmedPackageUpdates?: boolean;
+    targetVersion?: string;
+};
+export declare function readMigrationsJsonMetadata(workspacePath: string): MigrationsJsonMetadata;

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

@@ -0,0 +1,188 @@
+"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.addFailedMigration = addFailedMigration;
+exports.addSkippedMigration = addSkippedMigration;
+exports.readMigrationsJsonMetadata = readMigrationsJsonMetadata;
+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',
+            });
+        }
+    }
+    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 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'];
+}

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;
@@ -108,8 +109,24 @@ export declare function executeMigrations(root: string, migrations: {
     version: string;
     cli?: "nx" | "angular";
 }[]>;
+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<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");
@@ -809,9 +813,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 +837,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) {
@@ -881,26 +891,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 +935,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 +949,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, collectionPath, 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 +1154,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 +1167,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 +1191,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) {

package/src/config/misc-interfaces.d.ts

@@ -58,6 +58,16 @@ export interface MigrationsJsonEntry {
     factory?: string;
     requires?: Record<string, string>;
 }
+export type MigrationDetailsWithId = GeneratedMigrationDetails & {
+    id: string;
+};
+export interface GeneratedMigrationDetails {
+    name: string;
+    version: string;
+    package: string;
+    description: string;
+    implementation: string;
+}
 export interface MigrationsJson {
     name?: string;
     version?: string;