nx 20.8.4 → 22.7.7

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

@@ -0,0 +1,1608 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migrator = void 0;
+exports.formatCommandFailure = formatCommandFailure;
+exports.normalizeVersion = normalizeVersion;
+exports.parseMigrationsOptions = parseMigrationsOptions;
+exports.isNpmPeerDepsError = isNpmPeerDepsError;
+exports.executeMigrations = executeMigrations;
+exports.runNxOrAngularMigration = runNxOrAngularMigration;
+exports.migrate = migrate;
+exports.runMigration = runMigration;
+exports.readMigrationCollection = readMigrationCollection;
+exports.getImplementationPath = getImplementationPath;
+exports.nxCliPath = nxCliPath;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const child_process_1 = require("child_process");
+const enquirer_1 = require("enquirer");
+const handle_import_1 = require("../../utils/handle-import");
+const path_1 = require("path");
+const module_1 = require("module");
+const path_2 = require("../../utils/path");
+const semver_1 = require("semver");
+const node_url_1 = require("node:url");
+const util_1 = require("util");
+const tree_1 = require("../../generators/tree");
+const fileutils_1 = require("../../utils/fileutils");
+const write_formatted_json_file_1 = require("../../utils/write-formatted-json-file");
+const logger_1 = require("../../utils/logger");
+const git_utils_1 = require("../../utils/git-utils");
+const package_json_1 = require("../../utils/package-json");
+const package_manager_1 = require("../../utils/package-manager");
+const handle_errors_1 = require("../../utils/handle-errors");
+const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
+const output_1 = require("../../utils/output");
+const fs_1 = require("fs");
+const workspace_root_1 = require("../../utils/workspace-root");
+const is_ci_1 = require("../../utils/is-ci");
+const installation_directory_1 = require("../../utils/installation-directory");
+const configuration_1 = require("../../config/configuration");
+const child_process_2 = require("../../utils/child-process");
+const client_1 = require("../../daemon/client/client");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const provenance_1 = require("../../utils/provenance");
+const catalog_1 = require("../../utils/catalog");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function formatCommandFailure(command, error) {
+    const normalizeCommandOutput = (output) => {
+        if (!output) {
+            return undefined;
+        }
+        const normalized = typeof output === 'string' ? output.trim() : output.toString().trim();
+        return normalized || undefined;
+    };
+    const details = normalizeCommandOutput(error.stderr) ||
+        normalizeCommandOutput(error.stdout) ||
+        normalizeCommandOutput(error.message)
+            ?.replace(`Command failed: ${command}`, '')
+            .trim();
+    return [`Command failed: ${command}`, ...(details ? [details] : [])].join('\n');
+}
+function runOrReturnExitCode(run) {
+    try {
+        run();
+        return 0;
+    }
+    catch (e) {
+        if (typeof e === 'object' &&
+            e !== null &&
+            'status' in e &&
+            typeof e.status === 'number') {
+            return e.status;
+        }
+        throw e;
+    }
+}
+function normalizeVersion(version) {
+    const [semver, ...prereleaseTagParts] = version.split('-');
+    // Handle versions like 1.0.0-beta-next.2
+    const prereleaseTag = prereleaseTagParts.join('-');
+    const [major, minor, patch] = semver.split('.');
+    const newSemver = `${major || 0}.${minor || 0}.${patch || 0}`;
+    const newVersion = prereleaseTag
+        ? `${newSemver}-${prereleaseTag}`
+        : newSemver;
+    const withoutPatch = `${major || 0}.${minor || 0}.0`;
+    const withoutPatchAndMinor = `${major || 0}.0.0`;
+    const variationsToCheck = [
+        newVersion,
+        newSemver,
+        withoutPatch,
+        withoutPatchAndMinor,
+    ];
+    for (const variation of variationsToCheck) {
+        try {
+            if ((0, semver_1.gt)(variation, '0.0.0')) {
+                return variation;
+            }
+        }
+        catch { }
+    }
+    return '0.0.0';
+}
+function cleanSemver(version) {
+    return (0, semver_1.clean)(version) ?? (0, semver_1.coerce)(version);
+}
+function normalizeSlashes(packageName) {
+    return packageName.replace(/\\/g, '/');
+}
+class Migrator {
+    constructor(opts) {
+        this.packageUpdates = {};
+        this.collectedVersions = {};
+        this.promptAnswers = {};
+        this.packageJson = opts.packageJson;
+        this.nxInstallation = opts.nxInstallation;
+        this.getInstalledPackageVersion = opts.getInstalledPackageVersion;
+        this.fetch = opts.fetch;
+        this.installedPkgVersionOverrides = opts.from;
+        this.to = opts.to;
+        this.interactive = opts.interactive;
+        this.excludeAppliedMigrations = opts.excludeAppliedMigrations;
+    }
+    async fetchMigrationConfig(packageName, packageVersion) {
+        const migrationConfig = await this.fetch(packageName, packageVersion);
+        if (!migrationConfig.version) {
+            throw new Error(`Fetched migration metadata for ${packageName} is invalid: the target version is missing.`);
+        }
+        return migrationConfig;
+    }
+    async migrate(targetPackage, targetVersion) {
+        await this.buildPackageJsonUpdates(targetPackage, {
+            version: targetVersion,
+            addToPackageJson: false,
+        });
+        const migrations = await this.createMigrateJson();
+        return {
+            packageUpdates: this.packageUpdates,
+            migrations,
+            minVersionWithSkippedUpdates: this.minVersionWithSkippedUpdates,
+        };
+    }
+    async createMigrateJson() {
+        const migrations = await Promise.all(Object.keys(this.packageUpdates).map(async (packageName) => {
+            if (this.packageUpdates[packageName].ignoreMigrations) {
+                return [];
+            }
+            const currentVersion = this.getPkgVersion(packageName);
+            if (currentVersion === null)
+                return [];
+            const { version } = this.packageUpdates[packageName];
+            const { generators } = await this.fetchMigrationConfig(packageName, version);
+            if (!generators)
+                return [];
+            return Object.entries(generators)
+                .filter(([, migration]) => migration.version &&
+                this.gt(migration.version, currentVersion) &&
+                this.lte(migration.version, version) &&
+                this.areMigrationRequirementsMet(packageName, migration))
+                .map(([migrationName, migration]) => ({
+                ...migration,
+                package: packageName,
+                name: migrationName,
+            }));
+        }));
+        return migrations.flat();
+    }
+    async buildPackageJsonUpdates(targetPackage, target) {
+        const packagesToCheck = await this.populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target);
+        for (const packageToCheck of packagesToCheck) {
+            const filteredUpdates = {};
+            for (const [packageUpdateKey, packageUpdate] of Object.entries(packageToCheck.updates)) {
+                if (this.areRequirementsMet(packageUpdate.requires) &&
+                    !this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith) &&
+                    (!this.interactive ||
+                        (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
+                    Object.entries(packageUpdate.packages).forEach(([name, update]) => {
+                        this.validatePackageUpdateVersion(packageToCheck.package, name, update);
+                        filteredUpdates[name] = update;
+                        this.packageUpdates[name] = update;
+                    });
+                }
+            }
+            await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
+        }
+    }
+    async populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target) {
+        let targetVersion = target.version;
+        if (this.to[targetPackage]) {
+            targetVersion = this.to[targetPackage];
+        }
+        if (!this.getPkgVersion(targetPackage)) {
+            this.addPackageUpdate(targetPackage, {
+                version: target.version,
+                addToPackageJson: target.addToPackageJson || false,
+                ...(target.ignoreMigrations && { ignoreMigrations: true }),
+            });
+            return [];
+        }
+        let migrationConfig;
+        try {
+            migrationConfig = await this.fetchMigrationConfig(targetPackage, targetVersion);
+        }
+        catch (e) {
+            if (e?.message?.includes('No matching version')) {
+                throw new Error(`${e.message}\nRun migrate with --to="package1@version1,package2@version2"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        targetVersion = migrationConfig.version;
+        if (this.collectedVersions[targetPackage] &&
+            (0, semver_1.gte)(this.collectedVersions[targetPackage], targetVersion)) {
+            return [];
+        }
+        this.collectedVersions[targetPackage] = targetVersion;
+        this.addPackageUpdate(targetPackage, {
+            version: migrationConfig.version,
+            addToPackageJson: target.addToPackageJson || false,
+            ...(target.ignoreMigrations && { ignoreMigrations: true }),
+        });
+        const { packageJsonUpdates, packageGroupOrder } = this.getPackageJsonUpdatesFromMigrationConfig(targetPackage, targetVersion, migrationConfig, target.ignorePackageGroup);
+        if (!Object.keys(packageJsonUpdates).length) {
+            return [];
+        }
+        const shouldCheckUpdates = Object.values(packageJsonUpdates).some((packageJsonUpdate) => (this.interactive && packageJsonUpdate['x-prompt']) ||
+            Object.keys(packageJsonUpdate.requires ?? {}).length ||
+            Object.keys(packageJsonUpdate.incompatibleWith ?? {}).length);
+        if (shouldCheckUpdates) {
+            return [{ package: targetPackage, updates: packageJsonUpdates }];
+        }
+        const packageUpdatesToApply = Object.values(packageJsonUpdates).reduce((m, c) => ({ ...m, ...c.packages }), {});
+        return (await Promise.all(Object.entries(packageUpdatesToApply).map(([packageName, packageUpdate]) => {
+            this.validatePackageUpdateVersion(targetPackage, packageName, packageUpdate);
+            return this.populatePackageJsonUpdatesAndGetPackagesToCheck(packageName, packageUpdate);
+        })))
+            .filter((pkgs) => pkgs.length)
+            .flat()
+            .sort((pkgUpdate1, pkgUpdate2) => packageGroupOrder.indexOf(pkgUpdate1.package) -
+            packageGroupOrder.indexOf(pkgUpdate2.package));
+    }
+    getPackageJsonUpdatesFromMigrationConfig(packageName, targetVersion, migrationConfig, ignorePackageGroup) {
+        const packageGroupOrder = this.getPackageJsonUpdatesFromPackageGroup(packageName, targetVersion, migrationConfig, ignorePackageGroup);
+        if (!migrationConfig.packageJsonUpdates ||
+            !this.getPkgVersion(packageName)) {
+            return { packageJsonUpdates: {}, packageGroupOrder };
+        }
+        const packageJsonUpdates = this.filterPackageJsonUpdates(migrationConfig.packageJsonUpdates, packageName, targetVersion);
+        return { packageJsonUpdates, packageGroupOrder };
+    }
+    /**
+     * Mutates migrationConfig, adding package group updates into packageJsonUpdates section
+     *
+     * @param packageName Package which is being migrated
+     * @param targetVersion Version which is being migrated to
+     * @param migrationConfig Configuration which is mutated to contain package json updates
+     * @returns Order of package groups
+     */
+    getPackageJsonUpdatesFromPackageGroup(packageName, targetVersion, migrationConfig, ignorePackageGroup) {
+        if (ignorePackageGroup) {
+            return [];
+        }
+        const packageGroup = packageName === '@nrwl/workspace' && (0, semver_1.lt)(targetVersion, '14.0.0-beta.0')
+            ? LEGACY_NRWL_PACKAGE_GROUP
+            : (migrationConfig.packageGroup ?? []);
+        let packageGroupOrder = [];
+        if (packageGroup.length) {
+            packageGroupOrder = packageGroup.map((packageConfig) => packageConfig.package);
+            migrationConfig.packageJsonUpdates ??= {};
+            const packages = {};
+            migrationConfig.packageJsonUpdates[targetVersion + '--PackageGroup'] = {
+                version: targetVersion,
+                packages,
+            };
+            for (const packageConfig of packageGroup) {
+                packages[packageConfig.package] = {
+                    version: packageConfig.version === '*'
+                        ? targetVersion
+                        : packageConfig.version,
+                    alwaysAddToPackageJson: false,
+                };
+                if (packageConfig.version === '*' &&
+                    this.installedPkgVersionOverrides[packageName]) {
+                    this.installedPkgVersionOverrides[packageConfig.package] ??=
+                        this.installedPkgVersionOverrides[packageName];
+                }
+            }
+        }
+        return packageGroupOrder;
+    }
+    filterPackageJsonUpdates(packageJsonUpdates, packageName, targetVersion) {
+        const filteredPackageJsonUpdates = {};
+        for (const [packageJsonUpdateKey, packageJsonUpdate] of Object.entries(packageJsonUpdates)) {
+            if (!packageJsonUpdate.packages ||
+                this.lt(packageJsonUpdate.version, this.getPkgVersion(packageName)) ||
+                this.gt(packageJsonUpdate.version, targetVersion)) {
+                continue;
+            }
+            const dependencies = {
+                ...this.packageJson?.dependencies,
+                ...this.packageJson?.devDependencies,
+                ...this.nxInstallation?.plugins,
+                ...(this.nxInstallation && { nx: this.nxInstallation.version }),
+            };
+            const filtered = {};
+            for (const [packageName, packageUpdate] of Object.entries(packageJsonUpdate.packages)) {
+                if (this.shouldApplyPackageUpdate(packageUpdate, packageName, dependencies)) {
+                    filtered[packageName] = {
+                        version: packageUpdate.version,
+                        addToPackageJson: packageUpdate.alwaysAddToPackageJson
+                            ? typeof packageUpdate.alwaysAddToPackageJson === 'string'
+                                ? packageUpdate.alwaysAddToPackageJson
+                                : 'dependencies'
+                            : packageUpdate.addToPackageJson || false,
+                        ...(packageUpdate.ignorePackageGroup && {
+                            ignorePackageGroup: true,
+                        }),
+                        ...(packageUpdate.ignoreMigrations && {
+                            ignoreMigrations: true,
+                        }),
+                    };
+                }
+            }
+            if (Object.keys(filtered).length) {
+                packageJsonUpdate.packages = filtered;
+                filteredPackageJsonUpdates[packageJsonUpdateKey] = packageJsonUpdate;
+            }
+        }
+        return filteredPackageJsonUpdates;
+    }
+    shouldApplyPackageUpdate(packageUpdate, packageName, dependencies) {
+        return ((!packageUpdate.ifPackageInstalled ||
+            this.getPkgVersion(packageUpdate.ifPackageInstalled)) &&
+            (packageUpdate.alwaysAddToPackageJson ||
+                packageUpdate.addToPackageJson ||
+                !!dependencies?.[packageName]) &&
+            (!this.collectedVersions[packageName] ||
+                this.gt(packageUpdate.version, this.collectedVersions[packageName])));
+    }
+    validatePackageUpdateVersion(sourcePackageName, packageName, packageUpdate) {
+        if (!packageUpdate.version) {
+            throw new Error(`Fetched migration metadata for ${sourcePackageName} is invalid: the target version for ${packageName} is missing.`);
+        }
+    }
+    addPackageUpdate(name, packageUpdate) {
+        if (!this.packageUpdates[name] ||
+            this.gt(packageUpdate.version, this.packageUpdates[name].version)) {
+            this.packageUpdates[name] = packageUpdate;
+        }
+    }
+    areRequirementsMet(requirements) {
+        if (!requirements || !Object.keys(requirements).length) {
+            return true;
+        }
+        return Object.entries(requirements).every(([pkgName, versionRange]) => {
+            if (this.packageUpdates[pkgName]) {
+                return (0, semver_1.satisfies)(cleanSemver(this.packageUpdates[pkgName].version), versionRange, { includePrerelease: true });
+            }
+            return (this.getPkgVersion(pkgName) &&
+                (0, semver_1.satisfies)(this.getPkgVersion(pkgName), versionRange, {
+                    includePrerelease: true,
+                }));
+        });
+    }
+    areIncompatiblePackagesPresent(incompatibleWith) {
+        if (!incompatibleWith || !Object.keys(incompatibleWith).length) {
+            return false;
+        }
+        return Object.entries(incompatibleWith).some(([pkgName, versionRange]) => {
+            if (this.packageUpdates[pkgName]) {
+                return (0, semver_1.satisfies)(cleanSemver(this.packageUpdates[pkgName].version), versionRange, { includePrerelease: true });
+            }
+            return (this.getPkgVersion(pkgName) &&
+                (0, semver_1.satisfies)(this.getPkgVersion(pkgName), versionRange, {
+                    includePrerelease: true,
+                }));
+        });
+    }
+    areMigrationRequirementsMet(packageName, migration) {
+        if (!this.excludeAppliedMigrations) {
+            return this.areRequirementsMet(migration.requires);
+        }
+        return ((this.wasMigrationSkipped(migration.requires) ||
+            this.isMigrationForHigherVersionThanWhatIsInstalled(packageName, migration)) &&
+            this.areRequirementsMet(migration.requires));
+    }
+    isMigrationForHigherVersionThanWhatIsInstalled(packageName, migration) {
+        const installedVersion = this.getInstalledPackageVersion(packageName);
+        return (migration.version &&
+            (!installedVersion || this.gt(migration.version, installedVersion)) &&
+            this.lte(migration.version, this.packageUpdates[packageName].version));
+    }
+    wasMigrationSkipped(requirements) {
+        // no requiremets, so it ran before
+        if (!requirements || !Object.keys(requirements).length) {
+            return false;
+        }
+        // at least a requirement was not met, it was skipped
+        return Object.entries(requirements).some(([pkgName, versionRange]) => !this.getInstalledPackageVersion(pkgName) ||
+            !(0, semver_1.satisfies)(this.getInstalledPackageVersion(pkgName), versionRange, {
+                includePrerelease: true,
+            }));
+    }
+    async runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageName) {
+        if (!packageUpdate['x-prompt']) {
+            return Promise.resolve(true);
+        }
+        const promptKey = this.getPackageUpdatePromptKey(packageUpdate);
+        if (this.promptAnswers[promptKey] !== undefined) {
+            // a same prompt was already answered, skip
+            return Promise.resolve(false);
+        }
+        const promptConfig = {
+            name: 'shouldApply',
+            type: 'confirm',
+            message: packageUpdate['x-prompt'],
+            initial: true,
+        };
+        if (packageName.startsWith('@nx/')) {
+            // @ts-expect-error -- enquirer types aren't correct, footer does exist
+            promptConfig.footer = () => pc.dim(`  View migration details at https://nx.dev/nx-api/${packageName.replace('@nx/', '')}#${packageUpdateKey.replace(/[-\.]/g, '')}packageupdates`);
+        }
+        return await (0, enquirer_1.prompt)([promptConfig]).then(({ shouldApply }) => {
+            this.promptAnswers[promptKey] = shouldApply;
+            if (!shouldApply &&
+                (!this.minVersionWithSkippedUpdates ||
+                    (0, semver_1.lt)(packageUpdate.version, this.minVersionWithSkippedUpdates))) {
+                this.minVersionWithSkippedUpdates = packageUpdate.version;
+            }
+            return shouldApply;
+        });
+    }
+    getPackageUpdatePromptKey(packageUpdate) {
+        return Object.entries(packageUpdate.packages)
+            .map(([name, update]) => `${name}:${JSON.stringify(update)}`)
+            .join('|');
+    }
+    getPkgVersion(pkg) {
+        return this.getInstalledPackageVersion(pkg, this.installedPkgVersionOverrides);
+    }
+    gt(v1, v2) {
+        return (0, semver_1.gt)(normalizeVersion(v1), normalizeVersion(v2));
+    }
+    lt(v1, v2) {
+        return (0, semver_1.lt)(normalizeVersion(v1), normalizeVersion(v2));
+    }
+    lte(v1, v2) {
+        return (0, semver_1.lte)(normalizeVersion(v1), normalizeVersion(v2));
+    }
+}
+exports.Migrator = Migrator;
+const LEGACY_NRWL_PACKAGE_GROUP = [
+    { package: '@nrwl/workspace', version: '*' },
+    { package: '@nrwl/angular', version: '*' },
+    { package: '@nrwl/cypress', version: '*' },
+    { package: '@nrwl/devkit', version: '*' },
+    { package: '@nrwl/eslint-plugin-nx', version: '*' },
+    { package: '@nrwl/express', version: '*' },
+    { package: '@nrwl/jest', version: '*' },
+    { package: '@nrwl/linter', version: '*' },
+    { package: '@nrwl/nest', version: '*' },
+    { package: '@nrwl/next', version: '*' },
+    { package: '@nrwl/node', version: '*' },
+    { package: '@nrwl/nx-plugin', version: '*' },
+    { package: '@nrwl/react', version: '*' },
+    { package: '@nrwl/storybook', version: '*' },
+    { package: '@nrwl/web', version: '*' },
+    { package: '@nrwl/js', version: '*' },
+    { package: 'nx-cloud', version: 'latest' },
+    { package: '@nrwl/react-native', version: '*' },
+    { package: '@nrwl/detox', version: '*' },
+    { package: '@nrwl/expo', version: '*' },
+    { package: '@nrwl/tao', version: '*' },
+];
+async function normalizeVersionWithTagCheck(pkg, version) {
+    // This doesn't seem like a valid version, lets check if its a tag on the registry.
+    if (version && !(0, semver_1.parse)(version)) {
+        try {
+            return (0, package_manager_1.resolvePackageVersionUsingRegistry)(pkg, version);
+        }
+        catch {
+            // fall through to old logic
+        }
+    }
+    return normalizeVersion(version);
+}
+async function versionOverrides(overrides, param) {
+    const res = {};
+    const promises = overrides.split(',').map((p) => {
+        const split = p.lastIndexOf('@');
+        if (split === -1 || split === 0) {
+            throw new Error(`Incorrect '${param}' section. Use --${param}="package@version"`);
+        }
+        const selectedPackage = p.substring(0, split).trim();
+        const selectedVersion = p.substring(split + 1).trim();
+        if (!selectedPackage || !selectedVersion) {
+            throw new Error(`Incorrect '${param}' section. Use --${param}="package@version"`);
+        }
+        return normalizeVersionWithTagCheck(selectedPackage, selectedVersion).then((version) => {
+            res[normalizeSlashes(selectedPackage)] = version;
+        });
+    });
+    await Promise.all(promises);
+    return res;
+}
+async function parseTargetPackageAndVersion(args) {
+    if (!args) {
+        throw new Error(`Provide the correct package name and version. E.g., my-package@9.0.0.`);
+    }
+    if (args.indexOf('@') > -1) {
+        const i = args.lastIndexOf('@');
+        if (i === 0) {
+            const targetPackage = args.trim();
+            const targetVersion = 'latest';
+            return { targetPackage, targetVersion };
+        }
+        else {
+            const targetPackage = args.substring(0, i);
+            const maybeVersion = args.substring(i + 1);
+            if (!targetPackage || !maybeVersion) {
+                throw new Error(`Provide the correct package name and version. E.g., my-package@9.0.0.`);
+            }
+            const targetVersion = await normalizeVersionWithTagCheck(targetPackage, maybeVersion);
+            return { targetPackage, targetVersion };
+        }
+    }
+    else {
+        if (args === 'latest' ||
+            args === 'next' ||
+            args === 'canary' ||
+            (0, semver_1.valid)(args) ||
+            args.match(/^\d+(?:\.\d+)?(?:\.\d+)?$/)) {
+            // Passing `nx` here may seem wrong, but nx and @nrwl/workspace are synced in version.
+            // We could duplicate the ternary below, but its not necessary since they are equivalent
+            // on the registry
+            const targetVersion = await normalizeVersionWithTagCheck('nx', args);
+            const targetPackage = !['latest', 'next', 'canary'].includes(args) &&
+                (0, semver_1.lt)(targetVersion, '14.0.0-beta.0')
+                ? '@nrwl/workspace'
+                : 'nx';
+            return {
+                targetPackage,
+                targetVersion,
+            };
+        }
+        else {
+            return {
+                targetPackage: args,
+                targetVersion: 'latest',
+            };
+        }
+    }
+}
+async function parseMigrationsOptions(options) {
+    if (options.runMigrations === '') {
+        options.runMigrations = 'migrations.json';
+    }
+    if (!options.runMigrations) {
+        const [from, to] = await Promise.all([
+            options.from
+                ? versionOverrides(options.from, 'from')
+                : Promise.resolve({}),
+            options.to
+                ? await versionOverrides(options.to, 'to')
+                : Promise.resolve({}),
+        ]);
+        const { targetPackage, targetVersion } = await parseTargetPackageAndVersion(options['packageAndVersion']);
+        return {
+            type: 'generateMigrations',
+            targetPackage: normalizeSlashes(targetPackage),
+            targetVersion,
+            from,
+            to,
+            interactive: options.interactive,
+            excludeAppliedMigrations: options.excludeAppliedMigrations,
+        };
+    }
+    else {
+        return {
+            type: 'runMigrations',
+            runMigrations: options.runMigrations,
+            ifExists: options.ifExists,
+        };
+    }
+}
+function createInstalledPackageVersionsResolver(root) {
+    const cache = {};
+    const nxRequires = (0, installation_directory_1.getNxRequirePaths)(root).map((path) => (0, module_1.createRequire)((0, path_1.join)(path, 'package.json')));
+    function getInstalledPackageVersion(packageName, overrides) {
+        if (overrides?.[packageName]) {
+            return overrides[packageName];
+        }
+        if (packageName === 'nx') {
+            const nxVersion = cache[packageName] ??
+                (() => {
+                    for (const req of nxRequires) {
+                        try {
+                            const packageJsonPath = req.resolve('nx/package.json');
+                            if (packageJsonPath.startsWith(workspace_root_1.workspaceRoot)) {
+                                return (0, fileutils_1.readJsonFile)(packageJsonPath).version;
+                            }
+                        }
+                        catch { }
+                    }
+                    return getInstalledPackageVersion('@nrwl/workspace', overrides);
+                })();
+            if (nxVersion) {
+                cache[packageName] = nxVersion;
+            }
+            return nxVersion;
+        }
+        try {
+            if (!cache[packageName]) {
+                const { packageJson, path } = (0, package_json_1.readModulePackageJson)(packageName, (0, installation_directory_1.getNxRequirePaths)(root));
+                // old workspaces would have the temp installation of nx in the cache,
+                // so the resolved package is not the one we need
+                if (!path.startsWith(workspace_root_1.workspaceRoot)) {
+                    throw new Error('Resolved a package outside the workspace root.');
+                }
+                cache[packageName] = packageJson.version;
+            }
+            return cache[packageName];
+        }
+        catch {
+            return null;
+        }
+    }
+    return getInstalledPackageVersion;
+}
+// testing-fetch-start
+function createFetcher() {
+    const migrationsCache = {};
+    const resolvedVersionCache = {};
+    function fetchMigrations(packageName, packageVersion, setCache) {
+        if (process.env.NX_MIGRATE_SKIP_REGISTRY_FETCH === 'true') {
+            // Skip registry fetch and use installation method directly
+            logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
+            return getPackageMigrationsUsingInstall(packageName, packageVersion);
+        }
+        const cacheKey = packageName + '-' + packageVersion;
+        return Promise.resolve(resolvedVersionCache[cacheKey])
+            .then((cachedResolvedVersion) => {
+            if (cachedResolvedVersion) {
+                return cachedResolvedVersion;
+            }
+            resolvedVersionCache[cacheKey] = (0, package_manager_1.resolvePackageVersionUsingRegistry)(packageName, packageVersion);
+            return resolvedVersionCache[cacheKey];
+        })
+            .then((resolvedVersion) => {
+            if (resolvedVersion !== packageVersion &&
+                migrationsCache[`${packageName}-${resolvedVersion}`]) {
+                return migrationsCache[`${packageName}-${resolvedVersion}`];
+            }
+            setCache(packageName, resolvedVersion);
+            return getPackageMigrationsUsingRegistry(packageName, resolvedVersion);
+        })
+            .catch((e) => {
+            logger_1.logger.verbose(`Failed to get migrations from registry for ${packageName}@${packageVersion}: ${e.message}. Falling back to install.`);
+            logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
+            return getPackageMigrationsUsingInstall(packageName, packageVersion);
+        });
+    }
+    return function nxMigrateFetcher(packageName, packageVersion) {
+        if (migrationsCache[`${packageName}-${packageVersion}`]) {
+            return migrationsCache[`${packageName}-${packageVersion}`];
+        }
+        let resolvedVersion = packageVersion;
+        let migrations;
+        function setCache(packageName, packageVersion) {
+            migrationsCache[packageName + '-' + packageVersion] = migrations;
+        }
+        migrations = fetchMigrations(packageName, packageVersion, setCache).then((result) => {
+            if (result.schematics) {
+                result.generators = { ...result.schematics, ...result.generators };
+                delete result.schematics;
+            }
+            resolvedVersion = result.version;
+            return result;
+        });
+        setCache(packageName, packageVersion);
+        return migrations;
+    };
+}
+// testing-fetch-end
+async function getPackageMigrationsUsingRegistry(packageName, packageVersion) {
+    if ((0, provenance_1.getNxPackageGroup)().includes(packageName)) {
+        await (0, provenance_1.ensurePackageHasProvenance)(packageName, packageVersion);
+    }
+    // check if there are migrations in the packages by looking at the
+    // registry directly
+    const migrationsConfig = await getPackageMigrationsConfigFromRegistry(packageName, packageVersion);
+    if (!migrationsConfig) {
+        return {
+            name: packageName,
+            version: packageVersion,
+        };
+    }
+    if (!migrationsConfig.migrations) {
+        return {
+            name: packageName,
+            version: packageVersion,
+            packageGroup: migrationsConfig.packageGroup,
+        };
+    }
+    logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
+    // try to obtain the migrations from the registry directly
+    return await downloadPackageMigrationsFromRegistry(packageName, packageVersion, migrationsConfig);
+}
+async function getPackageMigrationsConfigFromRegistry(packageName, packageVersion) {
+    const result = await (0, package_manager_1.packageRegistryView)(packageName, packageVersion, 'nx-migrations ng-update dist --json');
+    if (!result) {
+        return null;
+    }
+    const json = JSON.parse(result);
+    if (!json['nx-migrations'] && !json['ng-update']) {
+        const registry = new node_url_1.URL('dist' in json ? json.dist.tarball : json.tarball)
+            .hostname;
+        // Registries other than npmjs and the local registry may not support full metadata via npm view
+        // so throw error so that fetcher falls back to getting config via install
+        if (!['registry.npmjs.org', 'localhost', 'artifactory'].some((v) => registry.includes(v))) {
+            throw new Error(`Getting migration config from registry is not supported from ${registry}`);
+        }
+    }
+    return (0, package_json_1.readNxMigrateConfig)(json);
+}
+async function downloadPackageMigrationsFromRegistry(packageName, packageVersion, { migrations: migrationsFilePath, packageGroup, }) {
+    const { dir, cleanup } = (0, package_manager_1.createTempNpmDirectory)();
+    let result;
+    try {
+        const { tarballPath } = await (0, package_manager_1.packageRegistryPack)(dir, packageName, packageVersion);
+        const migrations = await (0, fileutils_1.extractFileFromTarball)((0, path_1.join)(dir, tarballPath), (0, path_2.joinPathFragments)('package', migrationsFilePath), (0, path_1.join)(dir, migrationsFilePath)).then((path) => (0, fileutils_1.readJsonFile)(path));
+        result = { ...migrations, packageGroup, version: packageVersion };
+    }
+    catch {
+        throw new Error(`Failed to find migrations file "${migrationsFilePath}" in package "${packageName}@${packageVersion}".`);
+    }
+    finally {
+        await cleanup();
+    }
+    return result;
+}
+function createConcurrencyLimiter(concurrency) {
+    const queue = [];
+    let active = 0;
+    function next() {
+        while (queue.length > 0 && active < concurrency) {
+            active++;
+            queue.shift()();
+        }
+    }
+    return function limit(fn) {
+        return new Promise((resolve, reject) => {
+            queue.push(() => {
+                fn()
+                    .then(resolve, reject)
+                    .finally(() => {
+                    active--;
+                    next();
+                });
+            });
+            next();
+        });
+    };
+}
+const installConcurrencyLimit = process.env.NX_MIGRATE_INSTALL_CONCURRENCY
+    ? createConcurrencyLimiter(Math.max(1, Math.floor(Number(process.env.NX_MIGRATE_INSTALL_CONCURRENCY)) || 1))
+    : null;
+async function getPackageMigrationsUsingInstall(packageName, packageVersion) {
+    const run = () => getPackageMigrationsUsingInstallImpl(packageName, packageVersion);
+    return installConcurrencyLimit ? installConcurrencyLimit(run) : run();
+}
+async function getPackageMigrationsUsingInstallImpl(packageName, packageVersion) {
+    const { dir, cleanup } = (0, package_manager_1.createTempNpmDirectory)();
+    let result;
+    if ((0, provenance_1.getNxPackageGroup)().includes(packageName)) {
+        await (0, provenance_1.ensurePackageHasProvenance)(packageName, packageVersion);
+    }
+    try {
+        const pmc = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(dir), dir);
+        await execAsync(`${pmc.add} ${packageName}@${packageVersion}`, {
+            cwd: dir,
+            env: {
+                ...process.env,
+                npm_config_legacy_peer_deps: 'true',
+            },
+        });
+        const { migrations: migrationsFilePath, packageGroup, packageJson, } = readPackageMigrationConfig(packageName, dir);
+        let migrations = undefined;
+        if (migrationsFilePath) {
+            migrations = (0, fileutils_1.readJsonFile)(migrationsFilePath);
+        }
+        result = { ...migrations, packageGroup, version: packageJson.version };
+    }
+    catch (e) {
+        const pmc = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(dir), dir);
+        throw new Error([
+            `Failed to fetch migrations for ${packageName}@${packageVersion}`,
+            formatCommandFailure(`${pmc.add} ${packageName}@${packageVersion}`, e),
+        ].join('\n'));
+    }
+    finally {
+        await cleanup();
+    }
+    return result;
+}
+function readPackageMigrationConfig(packageName, dir) {
+    const { path: packageJsonPath, packageJson: json } = (0, package_json_1.readModulePackageJson)(packageName, (0, installation_directory_1.getNxRequirePaths)(dir));
+    const config = (0, package_json_1.readNxMigrateConfig)(json);
+    if (!config) {
+        return { packageJson: json, migrations: null, packageGroup: [] };
+    }
+    try {
+        const migrationFile = require.resolve(config.migrations, {
+            paths: [(0, path_1.dirname)(packageJsonPath)],
+        });
+        return {
+            packageJson: json,
+            migrations: migrationFile,
+            packageGroup: config.packageGroup,
+        };
+    }
+    catch {
+        return {
+            packageJson: json,
+            migrations: null,
+            packageGroup: config.packageGroup,
+        };
+    }
+}
+async function createMigrationsFile(root, migrations) {
+    await (0, write_formatted_json_file_1.writeFormattedJsonFile)((0, path_1.join)(root, 'migrations.json'), { migrations });
+}
+async function updatePackageJson(root, updatedPackages) {
+    const packageJsonPath = (0, path_1.join)(root, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return;
+    }
+    const parseOptions = {};
+    const json = (0, fileutils_1.readJsonFile)(packageJsonPath, parseOptions);
+    const manager = (0, catalog_1.getCatalogManager)(root);
+    const catalogUpdates = [];
+    Object.keys(updatedPackages).forEach((p) => {
+        const existingVersion = json.dependencies?.[p] ?? json.devDependencies?.[p];
+        if (existingVersion && manager?.isCatalogReference(existingVersion)) {
+            const { catalogName } = manager.parseCatalogReference(existingVersion);
+            catalogUpdates.push({
+                packageName: p,
+                version: updatedPackages[p].version,
+                catalogName,
+            });
+            // don't overwrite the catalog reference with the new version
+            return;
+        }
+        // Update non-catalog packages in package.json
+        if (json.devDependencies?.[p]) {
+            json.devDependencies[p] = updatedPackages[p].version;
+            return;
+        }
+        if (json.dependencies?.[p]) {
+            json.dependencies[p] = updatedPackages[p].version;
+            return;
+        }
+        const dependencyType = updatedPackages[p].addToPackageJson;
+        if (typeof dependencyType === 'string') {
+            json[dependencyType] ??= {};
+            json[dependencyType][p] = updatedPackages[p].version;
+        }
+    });
+    await (0, write_formatted_json_file_1.writeFormattedJsonFile)(packageJsonPath, json, {
+        appendNewLine: parseOptions.endsWithNewline,
+    });
+    // Update catalog definitions
+    if (catalogUpdates.length) {
+        // manager is guaranteed to be defined when there are catalog updates
+        manager.updateCatalogVersions(root, catalogUpdates);
+        await formatCatalogDefinitionFiles(manager, root);
+    }
+}
+async function formatCatalogDefinitionFiles(manager, root) {
+    const catalogDefinitionFilePaths = manager.getCatalogDefinitionFilePaths();
+    const catalogDefinitionFiles = catalogDefinitionFilePaths.map((filePath) => {
+        const absolutePath = (0, path_1.join)(root, filePath);
+        return {
+            path: filePath,
+            absolutePath,
+            content: (0, fs_1.readFileSync)(absolutePath, 'utf-8'),
+        };
+    });
+    const results = await (0, format_changed_files_with_prettier_if_available_1.formatFilesWithPrettierIfAvailable)(catalogDefinitionFiles.map(({ path, content }) => ({ path, content })), root, { silent: true });
+    for (const { path, absolutePath, content } of catalogDefinitionFiles) {
+        (0, fs_1.writeFileSync)(absolutePath, results.has(path) ? results.get(path) : content, { encoding: 'utf-8' });
+    }
+}
+async function updateInstallationDetails(root, updatedPackages) {
+    const nxJsonPath = (0, path_1.join)(root, 'nx.json');
+    const parseOptions = {};
+    const nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath, parseOptions);
+    if (!nxJson.installation) {
+        return;
+    }
+    const nxVersion = updatedPackages.nx?.version;
+    if (nxVersion) {
+        nxJson.installation.version = nxVersion;
+    }
+    if (nxJson.installation.plugins) {
+        for (const dep in nxJson.installation.plugins) {
+            const update = updatedPackages[dep];
+            if (update) {
+                nxJson.installation.plugins[dep] = (0, semver_1.valid)(update.version)
+                    ? update.version
+                    : await (0, package_manager_1.resolvePackageVersionUsingRegistry)(dep, update.version);
+            }
+        }
+    }
+    await (0, write_formatted_json_file_1.writeFormattedJsonFile)(nxJsonPath, nxJson, {
+        appendNewLine: parseOptions.endsWithNewline,
+    });
+}
+async function isMigratingToNewMajor(from, to) {
+    from = normalizeVersion(from);
+    to = ['latest', 'next', 'canary'].includes(to) ? to : normalizeVersion(to);
+    if (!(0, semver_1.valid)(from)) {
+        from = await (0, package_manager_1.resolvePackageVersionUsingRegistry)('nx', from);
+    }
+    if (!(0, semver_1.valid)(to)) {
+        to = await (0, package_manager_1.resolvePackageVersionUsingRegistry)('nx', to);
+    }
+    return (0, semver_1.major)(from) < (0, semver_1.major)(to);
+}
+function readNxVersion(packageJson, root) {
+    return ((0, package_json_1.getDependencyVersionFromPackageJson)('nx', root, packageJson) ??
+        (0, package_json_1.getDependencyVersionFromPackageJson)('@nx/workspace', root, packageJson) ??
+        (0, package_json_1.getDependencyVersionFromPackageJson)('@nrwl/workspace', root, packageJson));
+}
+async function generateMigrationsJsonAndUpdatePackageJson(root, opts) {
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    try {
+        const rootPkgJsonPath = (0, path_1.join)(root, 'package.json');
+        let originalPackageJson = (0, fs_1.existsSync)(rootPkgJsonPath)
+            ? (0, fileutils_1.readJsonFile)(rootPkgJsonPath)
+            : null;
+        const originalNxJson = (0, configuration_1.readNxJson)();
+        const from = originalNxJson.installation?.version ??
+            readNxVersion(originalPackageJson, root);
+        logger_1.logger.info(`Fetching meta data about packages.`);
+        logger_1.logger.info(`It may take a few minutes.`);
+        const migrator = new Migrator({
+            packageJson: originalPackageJson,
+            nxInstallation: originalNxJson.installation,
+            getInstalledPackageVersion: createInstalledPackageVersionsResolver(root),
+            fetch: createFetcher(),
+            from: opts.from,
+            to: opts.to,
+            interactive: opts.interactive && !(0, is_ci_1.isCI)(),
+            excludeAppliedMigrations: opts.excludeAppliedMigrations,
+        });
+        const { migrations, packageUpdates, minVersionWithSkippedUpdates } = await migrator.migrate(opts.targetPackage, opts.targetVersion);
+        await updatePackageJson(root, packageUpdates);
+        await updateInstallationDetails(root, packageUpdates);
+        if (migrations.length > 0) {
+            await createMigrationsFile(root, [
+                ...addSplitConfigurationMigrationIfAvailable(from, packageUpdates),
+                ...migrations,
+            ]);
+        }
+        output_1.output.success({
+            title: `The migrate command has run successfully.`,
+            bodyLines: [
+                `- package.json has been updated.`,
+                migrations.length > 0
+                    ? `- migrations.json has been generated.`
+                    : `- There are no migrations to run, so migrations.json has not been created.`,
+            ],
+        });
+        try {
+            if (opts.interactive !== false &&
+                ['nx', '@nrwl/workspace'].includes(opts.targetPackage) &&
+                (await isMigratingToNewMajor(from, opts.targetVersion)) &&
+                !(0, is_ci_1.isCI)() &&
+                !(0, nx_cloud_utils_1.isNxCloudDisabled)(originalNxJson) &&
+                !(0, nx_cloud_utils_1.isNxCloudUsed)(originalNxJson)) {
+                output_1.output.success({
+                    title: 'Connect to Nx Cloud',
+                    bodyLines: [
+                        'Nx Cloud is a first-party CI companion for Nx projects. It improves critical aspects of CI:',
+                        '- Speed: 30% - 70% faster CI',
+                        '- Cost: 40% - 75% reduction in CI costs',
+                        '- Reliability: by automatically identifying flaky tasks and re-running them',
+                    ],
+                });
+                await (0, connect_to_nx_cloud_1.connectToNxCloudWithPrompt)('migrate');
+                originalPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
+            }
+        }
+        catch {
+            // 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
+        }
+        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'`]
+                    : []),
+                ...(opts.interactive && minVersionWithSkippedUpdates
+                    ? [
+                        `- You opted out of some migrations for now. Write the following command down somewhere to apply these migrations later:`,
+                        `  nx migrate ${opts.targetVersion} --from ${opts.targetPackage}@${minVersionWithSkippedUpdates} --exclude-applied-migrations`,
+                        `- To learn more go to https://nx.dev/recipes/tips-n-tricks/advanced-update`,
+                    ]
+                    : [
+                        `- To learn more go to https://nx.dev/features/automate-updating-dependencies`,
+                    ]),
+                ...(showConnectToCloudMessage()
+                    ? [
+                        `- 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) {
+        output_1.output.error({
+            title: `The migrate command failed.`,
+        });
+        throw e;
+    }
+}
+function addSplitConfigurationMigrationIfAvailable(from, packageJson) {
+    if (!packageJson['@nrwl/workspace'])
+        return [];
+    if ((0, semver_1.gte)(packageJson['@nrwl/workspace'].version, '15.7.0-beta.0') &&
+        (0, semver_1.lt)(normalizeVersion(from), '15.7.0-beta.0')) {
+        return [
+            {
+                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.',
+                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',
+            },
+        ];
+    }
+    else {
+        return [];
+    }
+}
+function showConnectToCloudMessage() {
+    try {
+        const nxJson = (0, configuration_1.readNxJson)();
+        const defaultRunnerIsUsed = (0, connect_to_nx_cloud_1.onlyDefaultRunnerIsUsed)(nxJson);
+        return !!defaultRunnerIsUsed;
+    }
+    catch {
+        return false;
+    }
+}
+function runInstall(nxWorkspaceRoot, phase = 'pre-migration') {
+    const cwd = nxWorkspaceRoot ?? process.cwd();
+    const packageManager = (0, package_manager_1.detectPackageManager)(cwd);
+    const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, cwd);
+    const installCommand = `${pmCommands.install} ${pmCommands.ignoreScriptsFlag ?? ''}`;
+    output_1.output.log({
+        title: `Running '${installCommand}' to make sure necessary packages are installed`,
+    });
+    return new Promise((resolve, reject) => {
+        // For npm, pipe stderr so we can detect peer dependency errors while still
+        // mirroring it live to the user's terminal. Other package managers inherit
+        // stderr directly since we don't need to inspect their output.
+        const shouldCaptureStderr = packageManager === 'npm';
+        const child = (0, child_process_1.spawn)(installCommand, {
+            shell: true,
+            stdio: ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
+            windowsHide: true,
+            cwd,
+        });
+        const stderrChunks = [];
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(chunk);
+            stderrChunks.push(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            if (shouldCaptureStderr) {
+                const stderr = Buffer.concat(stderrChunks).toString().trim();
+                if (isNpmPeerDepsError(stderr)) {
+                    // Log the remediation guidance here so every caller of `runInstall`
+                    // (CLI migrate, `nx repair`, single-migration runner, etc.) surfaces
+                    // it consistently. Top-level callers catch `NpmPeerDepsInstallError`
+                    // and return a non-zero exit code without re-logging.
+                    logNpmPeerDepsError(phase);
+                    reject(new NpmPeerDepsInstallError());
+                    return;
+                }
+            }
+            reject(new Error(`Command failed: ${installCommand}`));
+        });
+    });
+}
+class NpmPeerDepsInstallError extends Error {
+    constructor() {
+        super('npm install failed due to peer dependency conflicts.');
+        this.name = 'NpmPeerDepsInstallError';
+    }
+}
+/**
+ * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
+ * error code, which npm consistently emits for this class of failure across
+ * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
+ * small set of stable phrases in case the code line is missing from the
+ * captured output.
+ */
+function isNpmPeerDepsError(stderr) {
+    if (/\bERESOLVE\b/.test(stderr)) {
+        return true;
+    }
+    const lowerStderr = stderr.toLowerCase();
+    return (lowerStderr.includes('unable to resolve dependency tree') ||
+        lowerStderr.includes('could not resolve dependency') ||
+        lowerStderr.includes('conflicting peer dependency'));
+}
+function logNpmPeerDepsError(phase) {
+    const peerDepsResolutionSteps = [
+        'Recommended approaches (in order of preference):',
+        '',
+        '1. Use "overrides" in package.json to force compatible versions across the dependency tree.',
+        '   See https://docs.npmjs.com/cli/configuring-npm/package-json#overrides',
+        '2. Persist legacy peer deps resolution in the project ".npmrc":',
+        '   npm config set legacy-peer-deps=true --location=project',
+        '   (bypasses peer dependency resolution; use with caution)',
+        '3. As a last resort, force the installation by running "npm install --force".',
+        '   (does not persist and may produce broken installs)',
+    ];
+    const manualInstallHint = [
+        'If you installed the dependencies manually, pass "--skip-install" to avoid re-installing them:',
+        '   nx migrate --run-migrations --skip-install',
+    ];
+    if (phase === 'pre-migration') {
+        output_1.output.error({
+            title: 'You need to resolve the peer dependency conflicts before the migration can continue',
+            bodyLines: [
+                ...peerDepsResolutionSteps,
+                '',
+                'Once the conflicts are resolved, re-run the migrations:',
+                '   nx migrate --run-migrations',
+                '',
+                ...manualInstallHint,
+            ],
+        });
+    }
+    else {
+        output_1.output.error({
+            title: 'Some migrations have been applied, but installing the updated dependencies failed',
+            bodyLines: [
+                ...peerDepsResolutionSteps,
+                '',
+                'Once the conflicts are resolved, run "npm install" to install the updated dependencies.',
+                'If the migration was interrupted before completing, re-run the remaining migrations:',
+                '   nx migrate --run-migrations',
+                '',
+                ...manualInstallHint,
+            ],
+        });
+    }
+}
+async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall = false) {
+    const changedDepInstaller = new ChangedDepInstaller(root, shouldSkipInstall);
+    const migrationsWithNoChanges = [];
+    const sortedMigrations = migrations.sort((a, b) => {
+        // special case for the split configuration migration to run first
+        if (a.name === '15-7-0-split-configuration-into-project-json-files') {
+            return -1;
+        }
+        if (b.name === '15-7-0-split-configuration-into-project-json-files') {
+            return 1;
+        }
+        return (0, semver_1.lt)(normalizeVersion(a.version), normalizeVersion(b.version))
+            ? -1
+            : 1;
+    });
+    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 { 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(`---------------------------------------------------------`);
+        }
+        catch (e) {
+            if (!(e instanceof NpmPeerDepsInstallError)) {
+                output_1.output.error({
+                    title: `Failed to run ${m.name} from ${m.package}. This workspace is NOT up to date!`,
+                });
+            }
+            throw e;
+        }
+    }
+    if (!shouldCreateCommits) {
+        await changedDepInstaller.installDepsIfChanged();
+    }
+    if (changedDepInstaller.skippedInstall) {
+        logSkippedPostMigrationInstall(root);
+    }
+    return { migrationsWithNoChanges, nextSteps: allNextSteps };
+}
+class ChangedDepInstaller {
+    constructor(root, shouldSkipInstall = false) {
+        this.root = root;
+        this.shouldSkipInstall = shouldSkipInstall;
+        this._skippedInstall = false;
+        this.initialDeps = getStringifiedPackageJsonDeps(root);
+    }
+    get skippedInstall() {
+        return this._skippedInstall;
+    }
+    async installDepsIfChanged() {
+        const currentDeps = getStringifiedPackageJsonDeps(this.root);
+        if (this.initialDeps !== currentDeps) {
+            if (this.shouldSkipInstall) {
+                this._skippedInstall = true;
+            }
+            else {
+                await runInstall(this.root, 'post-migration');
+            }
+        }
+        this.initialDeps = currentDeps;
+    }
+}
+function logSkippedPostMigrationInstall(root) {
+    const packageManager = (0, package_manager_1.detectPackageManager)(root);
+    const installCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager, root).install;
+    output_1.output.warn({
+        title: 'Migrations updated your dependencies, but the install was skipped',
+        bodyLines: [`Run "${installCommand}" to install the updated dependencies.`],
+    });
+}
+async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateCommits, commitPrefix, installDepsIfChanged, handleInstallDeps = false) {
+    if (!installDepsIfChanged) {
+        const changedDepInstaller = new ChangedDepInstaller(root);
+        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, migration.version));
+        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 migrationProjectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+        const { madeChanges, loggingQueue } = await ngCliAdapter.runMigration(root, migration.package, migration.name, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(migrationProjectGraph).projects, isVerbose, migrationProjectGraph);
+        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) {
+        await installDepsIfChanged();
+        const commitMessage = `${commitPrefix}${migration.name}`;
+        try {
+            const committedSha = (0, git_utils_1.commitChanges)(commitMessage, root);
+            if (committedSha) {
+                logger_1.logger.info(pc.dim(`- Commit created for changes: ${committedSha}`));
+            }
+            else {
+                logger_1.logger.info(pc.red(`- A commit could not be created/retrieved for an unknown reason`));
+            }
+        }
+        catch (e) {
+            logger_1.logger.info(pc.red(`- ${e.message}`));
+        }
+        // if we are running this function alone, we need to install deps internally
+    }
+    else if (handleInstallDeps) {
+        await installDepsIfChanged();
+    }
+    return { changes, nextSteps };
+}
+async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix, shouldSkipInstall = false) {
+    if (!shouldSkipInstall && !process.env.NX_MIGRATE_SKIP_INSTALL) {
+        await runInstall();
+    }
+    if (!__dirname.startsWith(workspace_root_1.workspaceRoot)) {
+        // we are running from a temp installation with nx latest, switch to running
+        // from local installation
+        const exitCode = runOrReturnExitCode(() => (0, child_process_2.runNxSync)(`migrate ${args.join(' ')}`, {
+            stdio: ['inherit', 'inherit', 'inherit'],
+            env: {
+                ...process.env,
+                NX_MIGRATE_SKIP_INSTALL: 'true',
+                NX_MIGRATE_USE_LOCAL: 'true',
+            },
+        }));
+        if (exitCode !== 0) {
+            return exitCode;
+        }
+        return;
+    }
+    const migrationsExists = (0, fileutils_1.fileExists)(opts.runMigrations);
+    if (opts.ifExists && !migrationsExists) {
+        output_1.output.log({
+            title: `Migrations file '${opts.runMigrations}' doesn't exist`,
+        });
+        return;
+    }
+    else if (!opts.ifExists && !migrationsExists) {
+        throw new Error(`File '${opts.runMigrations}' doesn't exist, can't run migrations. Use flag --if-exists to run migrations only if the file exists`);
+    }
+    output_1.output.log({
+        title: `Running migrations from '${opts.runMigrations}'` +
+            (shouldCreateCommits ? ', with each applied in a dedicated commit' : ''),
+    });
+    const migrations = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, opts.runMigrations)).migrations;
+    const { migrationsWithNoChanges, nextSteps } = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall);
+    if (migrationsWithNoChanges.length < migrations.length) {
+        output_1.output.success({
+            title: `Successfully finished running migrations from '${opts.runMigrations}'. This workspace is up to date!`,
+        });
+    }
+    else {
+        output_1.output.success({
+            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 {
+        const { dependencies, devDependencies } = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
+        return JSON.stringify([dependencies, devDependencies]);
+    }
+    catch {
+        // We don't really care if the .nx/installation property changes,
+        // whenever nxw is invoked it will handle the dep updates.
+        return '';
+    }
+}
+async function runNxMigration(root, collectionPath, collection, name, migrationVersion) {
+    const { path: implPath, fnSymbol } = getImplementationPath(collection, collectionPath, name, migrationVersion);
+    const fn = require(implPath)[fnSymbol];
+    const host = new tree_1.FsTree(root, process.env.NX_VERBOSE_LOGGING === 'true', `migration ${collection.name}:${name}`);
+    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, nextSteps };
+}
+async function migrate(root, args, rawArgs) {
+    await client_1.daemonClient.stop();
+    return (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+        const opts = await parseMigrationsOptions(args);
+        if (opts.type === 'generateMigrations') {
+            await generateMigrationsJsonAndUpdatePackageJson(root, opts);
+        }
+        else {
+            try {
+                return await runMigrations(root, opts, rawArgs, args['verbose'], args['createCommits'], args['commitPrefix'], args['skipInstall']);
+            }
+            catch (e) {
+                // The remediation guidance is already logged by `runInstall`; swallow
+                // the error here so `handleErrors` doesn't print a noisy stack after
+                // the friendly output.
+                if (e instanceof NpmPeerDepsInstallError) {
+                    return 1;
+                }
+                throw e;
+            }
+        }
+    });
+}
+async function runMigration() {
+    return (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+        const runLocalMigrate = () => runOrReturnExitCode(() => (0, child_process_2.runNxSync)(`_migrate ${process.argv.slice(3).join(' ')}`, {
+            stdio: ['inherit', 'inherit', 'inherit'],
+        }));
+        if (process.env.NX_USE_LOCAL !== 'true' &&
+            process.env.NX_MIGRATE_USE_LOCAL === undefined) {
+            const p = await nxCliPath();
+            if (p === null) {
+                return runLocalMigrate();
+            }
+            // ensure local registry from process is not interfering with the install
+            // when we start the process from temp folder the local registry would override the custom registry
+            if (process.env.npm_config_registry &&
+                process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
+                delete process.env.npm_config_registry;
+            }
+            return runOrReturnExitCode(() => (0, child_process_1.execSync)(`${p} _migrate ${process.argv.slice(3).join(' ')}`, {
+                stdio: ['inherit', 'inherit', 'inherit'],
+                windowsHide: true,
+            }));
+        }
+        return runLocalMigrate();
+    });
+}
+function readMigrationCollection(packageName, root) {
+    const collectionPath = readPackageMigrationConfig(packageName, root).migrations;
+    const collection = (0, fileutils_1.readJsonFile)(collectionPath);
+    collection.name ??= packageName;
+    return {
+        collection,
+        collectionPath,
+    };
+}
+function getImplementationPath(collection, collectionPath, name, migrationVersion) {
+    const g = collection.generators?.[name] || collection.schematics?.[name];
+    if (!g) {
+        throw new MigrationImplementationMissingError(`Unable to determine implementation path for "${collectionPath}:${name}"`, collectionPath, migrationVersion);
+    }
+    const implRelativePathAndMaybeSymbol = g.implementation || g.factory;
+    const [implRelativePath, fnSymbol = 'default'] = implRelativePathAndMaybeSymbol.split('#');
+    let implPath;
+    try {
+        implPath = require.resolve(implRelativePath, {
+            paths: [(0, path_1.dirname)(collectionPath)],
+        });
+    }
+    catch (e) {
+        try {
+            // workaround for a bug in node 12
+            implPath = require.resolve(`${(0, path_1.dirname)(collectionPath)}/${implRelativePath}`);
+        }
+        catch {
+            throw new MigrationImplementationMissingError(`Could not resolve implementation for migration "${name}" from "${collectionPath}"`, collectionPath, migrationVersion ?? g.version);
+        }
+    }
+    return { path: implPath, fnSymbol };
+}
+class MigrationImplementationMissingError extends Error {
+    constructor(baseMessage, collectionPath, migrationVersion) {
+        super(buildMigrationMissingMessage(baseMessage, collectionPath, migrationVersion));
+        this.name = 'MigrationImplementationMissingError';
+    }
+}
+function buildMigrationMissingMessage(baseMessage, collectionPath, migrationVersion) {
+    if (!migrationVersion) {
+        return baseMessage;
+    }
+    try {
+        const packageJsonPath = (0, path_1.join)((0, path_1.dirname)(collectionPath), 'package.json');
+        if (!(0, fs_1.existsSync)(packageJsonPath)) {
+            return baseMessage;
+        }
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        const installedVersion = packageJson.version;
+        if (installedVersion &&
+            (0, semver_1.lt)(normalizeVersion(installedVersion), normalizeVersion(migrationVersion))) {
+            const packageManager = (0, package_manager_1.detectPackageManager)();
+            const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+            const overrideFieldName = getOverrideFieldName(packageManager);
+            return (`${baseMessage}\n\n` +
+                `The installed version of "${packageJson.name}" is ${installedVersion}, ` +
+                `but this migration requires version ${migrationVersion}. ` +
+                `This likely means the package version is being held back by an ${overrideFieldName} ` +
+                `in your package.json. ` +
+                `Remove the ${overrideFieldName} and run "${pmc.install}" to install the correct version.`);
+        }
+    }
+    catch {
+        // Fall through to return the base message if we can't read package info
+    }
+    return baseMessage;
+}
+function getOverrideFieldName(packageManager) {
+    switch (packageManager) {
+        case 'pnpm':
+            return '"pnpm.overrides"';
+        case 'yarn':
+            return '"resolutions"';
+        case 'npm':
+        case 'bun':
+            return '"overrides"';
+    }
+}
+async function nxCliPath(nxWorkspaceRoot) {
+    const version = process.env.NX_MIGRATE_CLI_VERSION || 'latest';
+    const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+    await (0, provenance_1.ensurePackageHasProvenance)('nx', version);
+    try {
+        const packageManager = (0, package_manager_1.detectPackageManager)();
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+        const { dirSync } = require('tmp');
+        const tmpDir = dirSync().name;
+        (0, fileutils_1.writeJsonFile)((0, path_1.join)(tmpDir, 'package.json'), {
+            dependencies: {
+                nx: version,
+            },
+            license: 'MIT',
+        });
+        const root = nxWorkspaceRoot ?? workspace_root_1.workspaceRoot;
+        const isNonJs = !(0, fs_1.existsSync)((0, path_1.join)(root, 'package.json'));
+        (0, package_manager_1.copyPackageManagerConfigurationFiles)(isNonJs ? (0, installation_directory_1.getNxInstallationPath)(root) : root, tmpDir);
+        // Let's print the output of the install process to the console when verbose
+        // is enabled, so it's easier to debug issues with the installation process
+        const stdio = isVerbose
+            ? ['ignore', 'inherit', 'inherit']
+            : 'ignore';
+        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, {
+                cwd: tmpDir,
+                stdio,
+                windowsHide: true,
+            });
+            // if it's berry ensure we set the node_linker to node-modules
+            if (packageManager === 'yarn' && pmc.ciInstall.includes('immutable')) {
+                (0, child_process_1.execSync)('yarn config set nodeLinker node-modules', {
+                    cwd: tmpDir,
+                    stdio,
+                    windowsHide: true,
+                });
+            }
+        }
+        (0, child_process_1.execSync)(`${pmc.install} ${pmc.ignoreScriptsFlag ?? ''}`, {
+            cwd: tmpDir,
+            stdio,
+            windowsHide: true,
+        });
+        // 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)(nxWorkspaceRoot ?? workspace_root_1.workspaceRoot, 'node_modules'));
+        return (0, path_1.join)(tmpDir, `node_modules`, '.bin', 'nx');
+    }
+    catch (e) {
+        console.error(`Failed to install the ${version} version of the migration script. Using the current version.`);
+        if (isVerbose) {
+            console.error(e);
+        }
+        return null;
+    }
+}
+function addToNodePath(dir) {
+    // NODE_PATH is a delimited list of paths.
+    // The delimiter is different for windows.
+    const delimiter = require('os').platform() === 'win32' ? ';' : ':';
+    const paths = process.env.NODE_PATH
+        ? process.env.NODE_PATH.split(delimiter)
+        : [];
+    // Add the tmp path
+    paths.push(dir);
+    // Update the env variable.
+    process.env.NODE_PATH = paths.join(delimiter);
+}
+function isAngularMigration(collection, name) {
+    return !collection.generators?.[name] && collection.schematics?.[name];
+}
+const getNgCompatLayer = (() => {
+    let _ngCliAdapter;
+    return async function getNgCompatLayer() {
+        if (!_ngCliAdapter) {
+            _ngCliAdapter = await (0, handle_import_1.handleImport)('../../adapter/ngcli-adapter.js', __dirname);
+            require('../../adapter/compat');
+        }
+        return _ngCliAdapter;
+    };
+})();
+function isStringArray(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every((v) => typeof v === 'string');
+}