nx 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250418-8619c1d

package/src/command-line/init/implementation/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNxJsonFile = createNxJsonFile;
+exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
 exports.addDepsToPackageJson = addDepsToPackageJson;
 exports.updateGitIgnore = updateGitIgnore;
 exports.runInstall = runInstall;
@@ -10,6 +11,7 @@ exports.markRootPackageJsonAsNxProjectLegacy = markRootPackageJsonAsNxProjectLeg
 exports.markPackageJsonAsNxProject = markPackageJsonAsNxProject;
 exports.printFinalMessage = printFinalMessage;
 exports.isMonorepo = isMonorepo;
+exports.isCRA = isCRA;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const fileutils_1 = require("../../../utils/fileutils");
@@ -21,7 +23,8 @@ const fs_1 = require("fs");
 const connect_to_nx_cloud_1 = require("../../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud");
 const url_shorten_1 = require("../../../nx-cloud/utilities/url-shorten");
 const connect_to_nx_cloud_2 = require("../../connect/connect-to-nx-cloud");
-const default_base_1 = require("../../../utils/default-base");
+const deduce_default_base_1 = require("./deduce-default-base");
+const child_process_2 = require("../../../utils/child-process");
 function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scriptOutputs) {
     const nxJsonPath = (0, path_2.joinPathFragments)(repoRoot, 'nx.json');
     let nxJson = {};
@@ -53,56 +56,104 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     if (Object.keys(nxJson.targetDefaults).length === 0) {
         delete nxJson.targetDefaults;
     }
-    nxJson.defaultBase ??= deduceDefaultBase();
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
     (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
 }
-function deduceDefaultBase() {
-    try {
-        (0, child_process_1.execSync)(`git rev-parse --verify main`, {
-            stdio: ['ignore', 'ignore', 'ignore'],
-            windowsHide: false,
-        });
-        return 'main';
-    }
-    catch {
-        try {
-            (0, child_process_1.execSync)(`git rev-parse --verify dev`, {
-                stdio: ['ignore', 'ignore', 'ignore'],
-                windowsHide: false,
-            });
-            return 'dev';
+function createNxJsonFromTurboJson(turboJson) {
+    const nxJson = {
+        $schema: './node_modules/nx/schemas/nx-schema.json',
+    };
+    // Handle global dependencies
+    if (turboJson.globalDependencies?.length > 0) {
+        nxJson.namedInputs = {
+            sharedGlobals: turboJson.globalDependencies.map((dep) => `{workspaceRoot}/${dep}`),
+            default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        };
+    }
+    // Handle global env vars
+    if (turboJson.globalEnv?.length > 0) {
+        nxJson.namedInputs = nxJson.namedInputs || {};
+        nxJson.namedInputs.sharedGlobals = nxJson.namedInputs.sharedGlobals || [];
+        nxJson.namedInputs.sharedGlobals.push(...turboJson.globalEnv.map((env) => ({ env })));
+        nxJson.namedInputs.default = nxJson.namedInputs.default || [];
+        if (!nxJson.namedInputs.default.includes('{projectRoot}/**/*')) {
+            nxJson.namedInputs.default.push('{projectRoot}/**/*');
         }
-        catch {
-            try {
-                (0, child_process_1.execSync)(`git rev-parse --verify develop`, {
-                    stdio: ['ignore', 'ignore', 'ignore'],
-                    windowsHide: false,
-                });
-                return 'develop';
+        if (!nxJson.namedInputs.default.includes('sharedGlobals')) {
+            nxJson.namedInputs.default.push('sharedGlobals');
+        }
+    }
+    // Handle task configurations
+    if (turboJson.tasks) {
+        nxJson.targetDefaults = {};
+        for (const [taskName, taskConfig] of Object.entries(turboJson.tasks)) {
+            // Skip project-specific tasks (containing #)
+            if (taskName.includes('#'))
+                continue;
+            const config = taskConfig;
+            nxJson.targetDefaults[taskName] = {};
+            // Handle dependsOn
+            if (config.dependsOn?.length > 0) {
+                nxJson.targetDefaults[taskName].dependsOn = config.dependsOn;
             }
-            catch {
-                try {
-                    (0, child_process_1.execSync)(`git rev-parse --verify next`, {
-                        stdio: ['ignore', 'ignore', 'ignore'],
-                        windowsHide: false,
-                    });
-                    return 'next';
-                }
-                catch {
-                    try {
-                        (0, child_process_1.execSync)(`git rev-parse --verify master`, {
-                            stdio: ['ignore', 'ignore', 'ignore'],
-                            windowsHide: false,
-                        });
-                        return 'master';
+            // Handle inputs
+            if (config.inputs?.length > 0) {
+                nxJson.targetDefaults[taskName].inputs = config.inputs
+                    .map((input) => {
+                    if (input === '$TURBO_DEFAULT$') {
+                        return '{projectRoot}/**/*';
                     }
-                    catch {
-                        return (0, default_base_1.deduceDefaultBase)();
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                })
+                    .map((input) => {
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                });
+            }
+            // Handle outputs
+            if (config.outputs?.length > 0) {
+                nxJson.targetDefaults[taskName].outputs = config.outputs.map((output) => {
+                    // Don't add projectRoot if it's already there
+                    if (output.startsWith('{projectRoot}/'))
+                        return output;
+                    // Handle negated patterns by adding projectRoot after the !
+                    if (output.startsWith('!')) {
+                        return `!{projectRoot}/${output.slice(1)}`;
                     }
-                }
+                    return `{projectRoot}/${output}`;
+                });
             }
+            // Handle cache setting - true by default in Turbo
+            nxJson.targetDefaults[taskName].cache = config.cache !== false;
         }
     }
+    /**
+     * The fact that cacheDir was in use suggests the user had a reason for deviating from the default.
+     * We can't know what that reason was, nor if it would still be applicable in Nx, but we can at least
+     * improve discoverability of the relevant Nx option by explicitly including it with its default value.
+     */
+    if (turboJson.cacheDir) {
+        nxJson.cacheDirectory = '.nx/cache';
+    }
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
+    return nxJson;
 }
 function addDepsToPackageJson(repoRoot, additionalPackages) {
     const path = (0, path_2.joinPathFragments)(repoRoot, `package.json`);
@@ -202,8 +253,8 @@ function printFinalMessage({ learnMoreLink, }) {
     output_1.output.success({
         title: '🎉 Done!',
         bodyLines: [
-            `- Run "${pmc.exec} nx run-many -t build" to run the build target for every project in the workspace. Run it again to replay the cached computation. https://nx.dev/features/cache-task-results`,
-            `- Run "${pmc.exec} nx graph" to see the graph of projects and tasks in your workspace. https://nx.dev/core-features/explore-graph`,
+            `- Run "${(0, child_process_2.getRunNxBaseCommand)(pmc)} run-many -t build" to run the build target for every project in the workspace. Run it again to replay the cached computation. https://nx.dev/features/cache-task-results`,
+            `- Run "${(0, child_process_2.getRunNxBaseCommand)(pmc)} graph" to see the graph of projects and tasks in your workspace. https://nx.dev/core-features/explore-graph`,
             learnMoreLink ? `- Learn more at ${learnMoreLink}.` : undefined,
         ].filter(Boolean),
     });
@@ -217,3 +268,16 @@ function isMonorepo(packageJson) {
         return true;
     return false;
 }
+function isCRA(packageJson) {
+    const combinedDependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    return (
+    // Required dependencies for CRA projects
+    combinedDependencies['react'] &&
+        combinedDependencies['react-dom'] &&
+        combinedDependencies['react-scripts'] &&
+        (0, fileutils_1.directoryExists)('src') &&
+        (0, fileutils_1.directoryExists)('public'));
+}

package/src/command-line/init/init-v1.js

@@ -18,7 +18,7 @@ const utils_1 = require("./implementation/utils");
 async function initHandler(options) {
     // strip the 'init' command itself so we don't forward it
     const args = process.argv.slice(3).join(' ');
-    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
+    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? versions_1.nxVersion : 'latest');
     if (process.env.NX_VERSION) {
         console.log(`Using version ${process.env.NX_VERSION}`);
     }

package/src/command-line/init/init-v2.d.ts

@@ -5,6 +5,7 @@ export interface InitArgs {
     useDotNxInstallation?: boolean;
     integrated?: boolean;
     verbose?: boolean;
+    force?: boolean;
 }
 export declare function initHandler(options: InitArgs): Promise<void>;
 export declare function detectPlugins(nxJson: NxJsonConfiguration, interactive: boolean, includeAngularCli?: boolean): Promise<{

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

@@ -3,48 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initHandler = initHandler;
 exports.detectPlugins = detectPlugins;
 const fs_1 = require("fs");
+const enquirer_1 = require("enquirer");
 const semver_1 = require("semver");
+const nx_json_1 = require("../../config/nx-json");
+const fileutils_1 = require("../../utils/fileutils");
+const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
 const output_1 = require("../../utils/output");
 const package_manager_1 = require("../../utils/package-manager");
-const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
-const child_process_1 = require("../../utils/child-process");
-const fileutils_1 = require("../../utils/fileutils");
 const versions_1 = require("../../utils/versions");
-const utils_1 = require("./implementation/utils");
-const enquirer_1 = require("enquirer");
-const angular_1 = require("./implementation/angular");
 const workspace_context_1 = require("../../utils/workspace-context");
 const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
-const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
-const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
-const nx_json_1 = require("../../config/nx-json");
-const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
 const configure_plugins_1 = require("./configure-plugins");
+const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
+const add_nx_to_turborepo_1 = require("./implementation/add-nx-to-turborepo");
+const angular_1 = require("./implementation/angular");
+const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const utils_1 = require("./implementation/utils");
+const react_1 = require("./implementation/react");
 async function initHandler(options) {
     process.env.NX_RUNNING_NX_INIT = 'true';
-    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
+    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? versions_1.nxVersion : 'latest');
     if (process.env.NX_VERSION) {
         output_1.output.log({ title: `Using version ${process.env.NX_VERSION}` });
     }
-    if (!(0, fs_1.existsSync)('package.json') || options.useDotNxInstallation) {
-        if (process.platform !== 'win32') {
-            console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx --help`');
-        }
-        else {
-            console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx.bat --help`');
-        }
-        (0, add_nx_scripts_1.generateDotNxSetup)(version);
-        const nxJson = (0, nx_json_1.readNxJson)(process.cwd());
-        const { plugins } = await detectPlugins(nxJson, options.interactive);
-        plugins.forEach((plugin) => {
-            (0, child_process_1.runNxSync)(`add ${plugin}`, {
-                stdio: 'inherit',
-            });
-        });
-        // invokes the wrapper, thus invoking the initial installation process
-        (0, child_process_1.runNxSync)('--version', { stdio: 'ignore' });
-        return;
-    }
     // TODO(jack): Remove this Angular logic once `@nx/angular` is compatible with inferred targets.
     if ((0, fs_1.existsSync)('angular.json')) {
         await (0, angular_1.addNxToAngularCliRepo)({
@@ -56,33 +38,80 @@ async function initHandler(options) {
         });
         return;
     }
-    const packageJson = (0, fileutils_1.readJsonFile)('package.json');
-    if ((0, utils_1.isMonorepo)(packageJson)) {
+    const _isNonJs = !(0, fs_1.existsSync)('package.json') || options.useDotNxInstallation;
+    const packageJson = _isNonJs
+        ? null
+        : (0, fileutils_1.readJsonFile)('package.json');
+    const _isTurborepo = (0, fs_1.existsSync)('turbo.json');
+    const _isMonorepo = _isNonJs ? false : (0, utils_1.isMonorepo)(packageJson);
+    const _isCRA = _isNonJs ? false : (0, utils_1.isCRA)(packageJson);
+    const learnMoreLink = _isTurborepo
+        ? 'https://nx.dev/recipes/adopting-nx/from-turborepo'
+        : _isMonorepo
+            ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
+            : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
+    /**
+     * Turborepo users must have set up individual scripts already, and we keep the transition as minimal as possible.
+     * We log a message during the conversion process in addNxToTurborepo about how they can learn more about the power
+     * of Nx plugins and how it would allow them to infer all the relevant scripts automatically, including all cache
+     * inputs and outputs.
+     */
+    if (_isTurborepo) {
+        await (0, add_nx_to_turborepo_1.addNxToTurborepo)({
+            interactive: options.interactive,
+        });
+        (0, utils_1.printFinalMessage)({
+            learnMoreLink,
+        });
+        return;
+    }
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    if (_isCRA) {
+        await (0, react_1.addNxToCraRepo)({
+            addE2e: false,
+            force: options.force,
+            vite: true,
+            integrated: false,
+            interactive: options.interactive,
+            nxCloud: false,
+        });
+    }
+    else if (_isMonorepo) {
         await (0, add_nx_to_monorepo_1.addNxToMonorepo)({
             interactive: options.interactive,
             nxCloud: false,
         });
     }
+    else if (_isNonJs) {
+        (0, add_nx_scripts_1.generateDotNxSetup)(version);
+        console.log('');
+    }
     else {
         await (0, add_nx_to_npm_repo_1.addNxToNpmRepo)({
             interactive: options.interactive,
             nxCloud: false,
         });
     }
-    const learnMoreLink = (0, utils_1.isMonorepo)(packageJson)
-        ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
-        : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
     const useNxCloud = options.nxCloud ??
         (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
     const repoRoot = process.cwd();
-    const pmc = (0, package_manager_1.getPackageManagerCommand)();
     (0, utils_1.createNxJsonFile)(repoRoot, [], [], {});
     (0, utils_1.updateGitIgnore)(repoRoot);
     const nxJson = (0, nx_json_1.readNxJson)(repoRoot);
     output_1.output.log({ title: '🧐 Checking dependencies' });
-    const { plugins, updatePackageScripts } = await detectPlugins(nxJson, options.interactive);
+    let plugins;
+    let updatePackageScripts;
+    if (_isCRA) {
+        plugins = ['@nx/vite'];
+        updatePackageScripts = true;
+    }
+    else {
+        const { plugins: _plugins, updatePackageScripts: _updatePackageScripts } = await detectPlugins(nxJson, options.interactive);
+        plugins = _plugins;
+        updatePackageScripts = _updatePackageScripts;
+    }
     output_1.output.log({ title: '📦 Installing Nx' });
-    (0, configure_plugins_1.runPackageManagerInstallPlugins)(repoRoot, pmc, plugins);
+    (0, configure_plugins_1.installPluginPackages)(repoRoot, pmc, plugins);
     await (0, configure_plugins_1.configurePlugins)(plugins, updatePackageScripts, pmc, repoRoot, options.verbose);
     if (useNxCloud) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
@@ -114,6 +143,7 @@ const npmPackageToPluginMap = {
     'react-native': '@nx/react-native',
     '@remix-run/dev': '@nx/remix',
     '@rsbuild/core': '@nx/rsbuild',
+    '@react-router/dev': '@nx/react',
 };
 async function detectPlugins(nxJson, interactive, includeAngularCli) {
     let files = ['package.json'].concat((0, workspace_context_1.globWithWorkspaceContextSync)(process.cwd(), ['**/*/package.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 {};