nx 13.10.3 → 14.0.0-beta.2

package/src/command-line/migrate.js

@@ -2,91 +2,87 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrate = exports.parseMigrationsOptions = exports.Migrator = exports.normalizeVersion = void 0;
 const tslib_1 = require("tslib");
+const chalk = require("chalk");
 const child_process_1 = require("child_process");
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const semver_1 = require("semver");
-const tmp_1 = require("tmp");
+const util_1 = require("util");
 const tree_1 = require("../config/tree");
 const fileutils_1 = require("../utils/fileutils");
 const logger_1 = require("../utils/logger");
 const package_manager_1 = require("../utils/package-manager");
 const params_1 = require("../utils/params");
+const connect_to_nx_cloud_1 = require("./connect-to-nx-cloud");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
 function normalizeVersion(version) {
-    const [v, t] = version.split('-');
-    const [major, minor, patch] = v.split('.');
-    const newV = `${major || 0}.${minor || 0}.${patch || 0}`;
-    const newVersion = t ? `${newV}-${t}` : newV;
-    try {
-        (0, semver_1.gt)(newVersion, '0.0.0');
-        return newVersion;
-    }
-    catch (e) {
+    const [semver, prereleaseTag] = version.split('-');
+    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 {
-            (0, semver_1.gt)(newV, '0.0.0');
-            return newV;
-        }
-        catch (e) {
-            const withoutPatch = `${major || 0}.${minor || 0}.0`;
-            try {
-                if ((0, semver_1.gt)(withoutPatch, '0.0.0')) {
-                    return withoutPatch;
-                }
-            }
-            catch (e) {
-                const withoutPatchAndMinor = `${major || 0}.0.0`;
-                try {
-                    if ((0, semver_1.gt)(withoutPatchAndMinor, '0.0.0')) {
-                        return withoutPatchAndMinor;
-                    }
-                }
-                catch (e) {
-                    return '0.0.0';
-                }
+            if ((0, semver_1.gt)(variation, '0.0.0')) {
+                return variation;
             }
         }
+        catch (_a) { }
     }
+    return '0.0.0';
 }
 exports.normalizeVersion = normalizeVersion;
-function slash(packageName) {
+function normalizeSlashes(packageName) {
     return packageName.replace(/\\/g, '/');
 }
 class Migrator {
     constructor(opts) {
+        this.collectedVersions = {};
         this.packageJson = opts.packageJson;
         this.versions = opts.versions;
         this.fetch = opts.fetch;
-        this.from = opts.from;
         this.to = opts.to;
     }
     updatePackageJson(targetPackage, targetVersion) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const packageJson = yield this._updatePackageJson(targetPackage, { version: targetVersion, addToPackageJson: false }, {});
+            const packageJson = yield this._updatePackageJson(targetPackage, {
+                version: targetVersion,
+                addToPackageJson: false,
+            });
             const migrations = yield this._createMigrateJson(packageJson);
             return { packageJson, migrations };
         });
     }
     _createMigrateJson(versions) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const migrations = yield Promise.all(Object.keys(versions).map((c) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                const currentVersion = this.versions(c);
+            const migrations = yield Promise.all(Object.keys(versions).map((packageName) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const currentVersion = this.versions(packageName);
                 if (currentVersion === null)
                     return [];
-                const target = versions[c];
-                const migrationsJson = yield this.fetch(c, target.version);
-                const generators = migrationsJson.generators;
+                const { version } = versions[packageName];
+                const { generators } = yield this.fetch(packageName, version);
                 if (!generators)
                     return [];
-                return Object.keys(generators)
-                    .filter((r) => generators[r].version &&
-                    this.gt(generators[r].version, currentVersion) &&
-                    this.lte(generators[r].version, target.version))
-                    .map((r) => (Object.assign(Object.assign({}, migrationsJson.generators[r]), { package: c, name: r })));
+                return Object.entries(generators)
+                    .filter(([, migration]) => migration.version &&
+                    this.gt(migration.version, currentVersion) &&
+                    this.lte(migration.version, version))
+                    .map(([migrationName, migration]) => (Object.assign(Object.assign({}, migration), { package: packageName, name: migrationName })));
             })));
-            return migrations.reduce((m, c) => [...m, ...c], []);
+            return migrations.flat();
         });
     }
-    _updatePackageJson(targetPackage, target, collectedVersions) {
+    _updatePackageJson(targetPackage, target) {
+        var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             let targetVersion = target.version;
             if (this.to[targetPackage]) {
@@ -104,9 +100,10 @@ class Migrator {
             try {
                 migrationsJson = yield this.fetch(targetPackage, targetVersion);
                 targetVersion = migrationsJson.version;
+                this.collectedVersions[targetPackage] = targetVersion;
             }
             catch (e) {
-                if (e.message.indexOf('No matching version') > -1) {
+                if ((_a = e === null || e === void 0 ? void 0 : e.message) === null || _a === void 0 ? void 0 : _a.includes('No matching version')) {
                     throw new Error(`${e.message}\nRun migrate with --to="package1@version1,package2@version2"`);
                 }
                 else {
@@ -114,19 +111,18 @@ class Migrator {
                 }
             }
             const packages = this.collapsePackages(targetPackage, targetVersion, migrationsJson);
-            const childCalls = yield Promise.all(Object.keys(packages)
-                .filter((r) => {
-                return (!collectedVersions[r] ||
-                    this.gt(packages[r].version, collectedVersions[r].version));
-            })
-                .map((u) => this._updatePackageJson(u, packages[u], Object.assign(Object.assign({}, collectedVersions), { [targetPackage]: target }))));
-            return childCalls.reduce((m, c) => {
-                Object.keys(c).forEach((r) => {
-                    if (!m[r] || this.gt(c[r].version, m[r].version)) {
-                        m[r] = c[r];
+            const childPackageMigrations = yield Promise.all(Object.keys(packages)
+                .filter((packageName) => !this.collectedVersions[packageName] ||
+                this.gt(packages[packageName].version, this.collectedVersions[packageName]))
+                .map((packageName) => this._updatePackageJson(packageName, packages[packageName])));
+            return childPackageMigrations.reduce((migrations, childMigrations) => {
+                for (const migrationName of Object.keys(childMigrations)) {
+                    if (!migrations[migrationName] ||
+                        this.gt(childMigrations[migrationName].version, migrations[migrationName].version)) {
+                        migrations[migrationName] = childMigrations[migrationName];
                     }
-                });
-                return m;
+                }
+                return migrations;
             }, {
                 [targetPackage]: {
                     version: migrationsJson.version,
@@ -135,66 +131,77 @@ class Migrator {
             });
         });
     }
-    collapsePackages(packageName, targetVersion, m) {
+    collapsePackages(packageName, targetVersion, migration) {
         // this should be used to know what version to include
         // we should use from everywhere we use versions
-        if (packageName === '@nrwl/workspace') {
-            if (!m.packageJsonUpdates)
-                m.packageJsonUpdates = {};
-            m.packageJsonUpdates[`${targetVersion}-defaultPackages`] = {
+        var _a;
+        // Support Migrating to older versions of Nx
+        // Use the packageGroup of the latest version of Nx instead of the one from the target version which could be older.
+        if (packageName === '@nrwl/workspace' &&
+            (0, semver_1.lt)(targetVersion, '14.0.0-beta.0')) {
+            migration.packageGroup = {
+                '@nrwl/workspace': targetVersion,
+                '@nrwl/angular': targetVersion,
+                '@nrwl/cypress': targetVersion,
+                '@nrwl/devkit': targetVersion,
+                '@nrwl/eslint-plugin-nx': targetVersion,
+                '@nrwl/express': targetVersion,
+                '@nrwl/jest': targetVersion,
+                '@nrwl/linter': targetVersion,
+                '@nrwl/nest': targetVersion,
+                '@nrwl/next': targetVersion,
+                '@nrwl/node': targetVersion,
+                '@nrwl/nx-plugin': targetVersion,
+                '@nrwl/react': targetVersion,
+                '@nrwl/storybook': targetVersion,
+                '@nrwl/web': targetVersion,
+                '@nrwl/js': targetVersion,
+                '@nrwl/cli': targetVersion,
+                '@nrwl/nx-cloud': 'latest',
+                '@nrwl/react-native': targetVersion,
+                '@nrwl/detox': targetVersion,
+            };
+        }
+        if (migration.packageGroup) {
+            (_a = migration.packageJsonUpdates) !== null && _a !== void 0 ? _a : (migration.packageJsonUpdates = {});
+            const packageGroup = normalizePackageGroup(migration.packageGroup);
+            migration.packageJsonUpdates[targetVersion + '--PackageGroup'] = {
                 version: targetVersion,
-                packages: [
-                    'nx',
-                    '@nrwl/angular',
-                    '@nrwl/cypress',
-                    '@nrwl/devkit',
-                    '@nrwl/eslint-plugin-nx',
-                    '@nrwl/express',
-                    '@nrwl/jest',
-                    '@nrwl/js',
-                    '@nrwl/cli',
-                    '@nrwl/linter',
-                    '@nrwl/nest',
-                    '@nrwl/next',
-                    '@nrwl/node',
-                    '@nrwl/nx-cloud',
-                    '@nrwl/nx-plugin',
-                    '@nrwl/react',
-                    '@nrwl/storybook',
-                    '@nrwl/web',
-                    '@nrwl/react-native',
-                    '@nrwl/detox',
-                ].reduce((m, c) => (Object.assign(Object.assign({}, m), { [c]: {
-                        version: c === '@nrwl/nx-cloud' ? 'latest' : targetVersion,
-                        alwaysAddToPackageJson: false,
-                    } })), {}),
+                packages: packageGroup.reduce((acc, packageConfig) => {
+                    const { package: pkg, version } = typeof packageConfig === 'string'
+                        ? { package: packageConfig, version: targetVersion }
+                        : packageConfig;
+                    return Object.assign(Object.assign({}, acc), { [pkg]: {
+                            version,
+                            alwaysAddToPackageJson: false,
+                        } });
+                }, {}),
             };
         }
-        if (!m.packageJsonUpdates || !this.versions(packageName))
+        if (!migration.packageJsonUpdates || !this.versions(packageName))
             return {};
-        return Object.keys(m.packageJsonUpdates)
-            .filter((r) => {
-            return (this.gt(m.packageJsonUpdates[r].version, this.versions(packageName)) && this.lte(m.packageJsonUpdates[r].version, targetVersion));
+        return Object.values(migration.packageJsonUpdates)
+            .filter(({ version, packages }) => {
+            return (packages &&
+                this.gt(version, this.versions(packageName)) &&
+                this.lte(version, targetVersion));
         })
-            .map((r) => m.packageJsonUpdates[r].packages)
-            .map((packages) => {
-            if (!packages)
-                return {};
-            return Object.keys(packages)
-                .filter((pkg) => {
-                const { dependencies, devDependencies } = this.packageJson;
-                return ((!packages[pkg].ifPackageInstalled ||
-                    this.versions(packages[pkg].ifPackageInstalled)) &&
-                    (packages[pkg].alwaysAddToPackageJson ||
-                        packages[pkg].addToPackageJson ||
-                        !!(dependencies === null || dependencies === void 0 ? void 0 : dependencies[pkg]) ||
-                        !!(devDependencies === null || devDependencies === void 0 ? void 0 : devDependencies[pkg])));
+            .map(({ packages }) => {
+            const { dependencies, devDependencies } = this.packageJson;
+            return Object.entries(packages)
+                .filter(([packageName, packageUpdate]) => {
+                return ((!packageUpdate.ifPackageInstalled ||
+                    this.versions(packageUpdate.ifPackageInstalled)) &&
+                    (packageUpdate.alwaysAddToPackageJson ||
+                        packageUpdate.addToPackageJson ||
+                        !!(dependencies === null || dependencies === void 0 ? void 0 : dependencies[packageName]) ||
+                        !!(devDependencies === null || devDependencies === void 0 ? void 0 : devDependencies[packageName])));
             })
-                .reduce((m, c) => (Object.assign(Object.assign({}, m), { [c]: {
-                    version: packages[c].version,
-                    addToPackageJson: packages[c].alwaysAddToPackageJson
+                .reduce((acc, [packageName, packageUpdate]) => (Object.assign(Object.assign({}, acc), { [packageName]: {
+                    version: packageUpdate.version,
+                    addToPackageJson: packageUpdate.alwaysAddToPackageJson
                         ? 'dependencies'
-                        : packages[c].addToPackageJson || false,
+                        : packageUpdate.addToPackageJson || false,
                 } })), {});
         })
             .reduce((m, c) => (Object.assign(Object.assign({}, m), c)), {});
@@ -207,6 +214,15 @@ class Migrator {
     }
 }
 exports.Migrator = Migrator;
+function normalizePackageGroup(packageGroup) {
+    if (!Array.isArray(packageGroup)) {
+        return Object.entries(packageGroup).map(([pkg, version]) => ({
+            package: pkg,
+            version,
+        }));
+    }
+    return packageGroup;
+}
 function normalizeVersionWithTagCheck(version) {
     if (version === 'latest' || version === 'next')
         return version;
@@ -224,13 +240,14 @@ function versionOverrides(overrides, param) {
         if (!selectedPackage || !selectedVersion) {
             throw new Error(`Incorrect '${param}' section. Use --${param}="package@version"`);
         }
-        res[slash(selectedPackage)] = normalizeVersionWithTagCheck(selectedVersion);
+        res[normalizeSlashes(selectedPackage)] =
+            normalizeVersionWithTagCheck(selectedVersion);
     });
     return res;
 }
 function parseTargetPackageAndVersion(args) {
     if (!args) {
-        throw new Error(`Provide the correct package name and version. E.g., @nrwl/workspace@9.0.0.`);
+        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('@');
@@ -243,7 +260,7 @@ function parseTargetPackageAndVersion(args) {
             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., @nrwl/workspace@9.0.0.`);
+                throw new Error(`Provide the correct package name and version. E.g., my-package@9.0.0.`);
             }
             const targetVersion = normalizeVersionWithTagCheck(maybeVersion);
             return { targetPackage, targetVersion };
@@ -253,9 +270,14 @@ function parseTargetPackageAndVersion(args) {
         if (args.match(/^\d+(?:\.\d+)?(?:\.\d+)?$/) ||
             args === 'latest' ||
             args === 'next') {
+            const targetVersion = normalizeVersionWithTagCheck(args);
+            const targetPackage = args.match(/^\d+(?:\.\d+)?(?:\.\d+)?$/) &&
+                (0, semver_1.lt)(targetVersion, '14.0.0-beta.0')
+                ? '@nrwl/workspace'
+                : 'nx';
             return {
-                targetPackage: '@nrwl/workspace',
-                targetVersion: normalizeVersionWithTagCheck(args),
+                targetPackage,
+                targetVersion,
             };
         }
         else {
@@ -278,7 +300,7 @@ function parseMigrationsOptions(options) {
         const { targetPackage, targetVersion } = parseTargetPackageAndVersion(options['packageAndVersion']);
         return {
             type: 'generateMigrations',
-            targetPackage: slash(targetPackage),
+            targetPackage: normalizeSlashes(targetPackage),
             targetVersion,
             from,
             to,
@@ -293,15 +315,19 @@ function parseMigrationsOptions(options) {
 }
 exports.parseMigrationsOptions = parseMigrationsOptions;
 function versions(root, from) {
+    const cache = {};
     return (packageName) => {
         try {
             if (from[packageName]) {
                 return from[packageName];
             }
-            const packageJsonPath = require.resolve(`${packageName}/package.json`, {
-                paths: [root],
-            });
-            return (0, fileutils_1.readJsonFile)(packageJsonPath).version;
+            if (!cache[packageName]) {
+                const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+                    paths: [root],
+                });
+                cache[packageName] = (0, fileutils_1.readJsonFile)(packageJsonPath).version;
+            }
+            return cache[packageName];
         }
         catch (_a) {
             return null;
@@ -310,177 +336,177 @@ function versions(root, from) {
 }
 // testing-fetch-start
 function createFetcher() {
-    const cache = {};
-    return function f(packageName, packageVersion) {
-        var _a;
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (cache[`${packageName}-${packageVersion}`]) {
-                return cache[`${packageName}-${packageVersion}`];
-            }
-            let resolvedVersion;
-            let migrations;
-            try {
-                resolvedVersion = (0, package_manager_1.resolvePackageVersionUsingRegistry)(packageName, packageVersion);
-                if (cache[`${packageName}-${resolvedVersion}`]) {
-                    return cache[`${packageName}-${resolvedVersion}`];
-                }
-                logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
-                migrations = yield getPackageMigrations(packageName, resolvedVersion);
+    const migrationsCache = {};
+    const resolvedVersionCache = {};
+    function fetchMigrations(packageName, packageVersion, setCache) {
+        const cacheKey = packageName + '-' + packageVersion;
+        return Promise.resolve(resolvedVersionCache[cacheKey])
+            .then((cachedResolvedVersion) => {
+            if (cachedResolvedVersion) {
+                return cachedResolvedVersion;
             }
-            catch (_b) {
-                logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
-                const result = yield installPackageAndGetVersionAngMigrations(packageName, packageVersion);
-                resolvedVersion = result.resolvedVersion;
-                migrations = result.migrations;
-            }
-            if (migrations) {
-                cache[`${packageName}-${packageVersion}`] = cache[`${packageName}-${resolvedVersion}`] = {
-                    version: resolvedVersion,
-                    generators: (_a = migrations.generators) !== null && _a !== void 0 ? _a : migrations.schematics,
-                    packageJsonUpdates: migrations.packageJsonUpdates,
-                };
+            resolvedVersionCache[cacheKey] = (0, package_manager_1.resolvePackageVersionUsingRegistry)(packageName, packageVersion);
+            return resolvedVersionCache[cacheKey];
+        })
+            .then((resolvedVersion) => {
+            if (resolvedVersion !== packageVersion &&
+                migrationsCache[`${packageName}-${resolvedVersion}`]) {
+                return migrationsCache[`${packageName}-${resolvedVersion}`];
             }
-            else {
-                cache[`${packageName}-${packageVersion}`] = cache[`${packageName}-${resolvedVersion}`] = {
-                    version: resolvedVersion,
-                };
+            setCache(packageName, resolvedVersion);
+            return getPackageMigrationsUsingRegistry(packageName, resolvedVersion);
+        })
+            .catch(() => {
+            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;
+                delete result.schematics;
             }
-            return cache[`${packageName}-${packageVersion}`];
+            resolvedVersion = result.version;
+            return result;
         });
+        setCache(packageName, packageVersion);
+        return migrations;
     };
 }
 // testing-fetch-end
-function getPackageMigrations(packageName, packageVersion) {
+function getPackageMigrationsUsingRegistry(packageName, packageVersion) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        try {
-            // check if there are migrations in the packages by looking at the
-            // registry directly
-            const migrationsPath = getPackageMigrationsPathFromRegistry(packageName, packageVersion);
-            if (!migrationsPath) {
-                return null;
-            }
-            // try to obtain the migrations from the registry directly
-            return yield getPackageMigrationsUsingRegistry(packageName, packageVersion, migrationsPath);
+        // check if there are migrations in the packages by looking at the
+        // registry directly
+        const migrationsConfig = yield getPackageMigrationsConfigFromRegistry(packageName, packageVersion);
+        if (!migrationsConfig) {
+            return {
+                version: packageVersion,
+            };
         }
-        catch (_a) {
-            // fall back to installing the package
-            const { migrations } = yield installPackageAndGetVersionAngMigrations(packageName, packageVersion);
-            return migrations;
+        if (!migrationsConfig.migrations) {
+            return {
+                version: packageVersion,
+                packageGroup: migrationsConfig.packageGroup,
+            };
         }
+        logger_1.logger.info(`Fetching ${packageName}@${packageVersion}`);
+        // try to obtain the migrations from the registry directly
+        return yield downloadPackageMigrationsFromRegistry(packageName, packageVersion, migrationsConfig);
     });
 }
-function getPackageMigrationsPathFromRegistry(packageName, packageVersion) {
-    var _a, _b;
-    let pm = (0, package_manager_1.detectPackageManager)();
-    if (pm === 'yarn') {
-        pm = 'npm';
-    }
-    const result = (0, child_process_1.execSync)(`${pm} view ${packageName}@${packageVersion} nx-migrations ng-update --json`, {
-        stdio: [],
-    })
-        .toString()
-        .trim();
-    if (!result) {
-        return null;
-    }
-    const json = JSON.parse(result);
-    let migrationsFilePath = (_b = (_a = json['nx-migrations']) !== null && _a !== void 0 ? _a : json['ng-update']) !== null && _b !== void 0 ? _b : json;
-    if (typeof json === 'object') {
-        migrationsFilePath = migrationsFilePath.migrations;
-    }
-    return migrationsFilePath;
+function resolveNxMigrationConfig(json) {
+    const parseNxMigrationsConfig = (fromJson) => {
+        if (!fromJson) {
+            return {};
+        }
+        if (typeof fromJson === 'string') {
+            return { migrations: fromJson, packageGroup: [] };
+        }
+        return Object.assign(Object.assign({}, (fromJson.migrations ? { migrations: fromJson.migrations } : {})), (fromJson.packageGroup ? { packageGroup: fromJson.packageGroup } : {}));
+    };
+    const config = Object.assign(Object.assign(Object.assign({}, parseNxMigrationsConfig(json['ng-update'])), parseNxMigrationsConfig(json['nx-migrations'])), parseNxMigrationsConfig(json));
+    return config;
 }
-function getPackageMigrationsUsingRegistry(packageName, packageVersion, migrationsFilePath) {
+function getPackageMigrationsConfigFromRegistry(packageName, packageVersion) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const dir = (0, tmp_1.dirSync)().name;
-        createNPMRC(dir);
-        let pm = (0, package_manager_1.detectPackageManager)();
-        if (pm === 'yarn') {
-            pm = 'npm';
-        }
-        const tarballPath = (0, child_process_1.execSync)(`${pm} pack ${packageName}@${packageVersion}`, {
-            cwd: dir,
-            stdio: [],
-        })
-            .toString()
-            .trim();
-        let migrations = null;
-        migrationsFilePath = (0, path_1.join)('package', migrationsFilePath);
-        const migrationDestinationPath = (0, path_1.join)(dir, migrationsFilePath);
+        const result = yield (0, package_manager_1.packageRegistryView)(packageName, packageVersion, 'nx-migrations ng-update --json');
+        if (!result) {
+            return null;
+        }
+        return resolveNxMigrationConfig(JSON.parse(result));
+    });
+}
+function downloadPackageMigrationsFromRegistry(packageName, packageVersion, { migrations: migrationsFilePath, packageGroup }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const dir = (0, package_manager_1.createTempNpmDirectory)();
+        let result;
         try {
-            yield (0, fileutils_1.extractFileFromTarball)((0, path_1.join)(dir, tarballPath), migrationsFilePath, migrationDestinationPath);
-            migrations = (0, fileutils_1.readJsonFile)(migrationDestinationPath);
+            const { tarballPath } = yield (0, package_manager_1.packageRegistryPack)(dir, packageName, packageVersion);
+            const migrations = yield (0, fileutils_1.extractFileFromTarball)((0, path_1.join)(dir, tarballPath), (0, path_1.join)('package', migrationsFilePath), (0, path_1.join)(dir, migrationsFilePath)).then((path) => (0, fileutils_1.readJsonFile)(path));
+            result = Object.assign(Object.assign({}, migrations), { packageGroup, version: packageVersion });
         }
         catch (_a) {
             throw new Error(`Failed to find migrations file "${migrationsFilePath}" in package "${packageName}@${packageVersion}".`);
         }
-        try {
-            (0, fs_extra_1.removeSync)(dir);
-        }
-        catch (_b) {
-            // It's okay if this fails, the OS will clean it up eventually
+        finally {
+            try {
+                yield (0, fs_extra_1.remove)(dir);
+            }
+            catch (_b) {
+                // It's okay if this fails, the OS will clean it up eventually
+            }
         }
-        return migrations;
+        return result;
     });
 }
-function installPackageAndGetVersionAngMigrations(packageName, packageVersion) {
+function getPackageMigrationsUsingInstall(packageName, packageVersion) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const dir = (0, tmp_1.dirSync)().name;
-        createNPMRC(dir);
-        const pmc = (0, package_manager_1.getPackageManagerCommand)();
-        (0, child_process_1.execSync)(`${pmc.add} ${packageName}@${packageVersion}`, {
-            stdio: [],
-            cwd: dir,
-        });
-        const packageJsonPath = require.resolve(`${packageName}/package.json`, {
-            paths: [dir],
-        });
-        const { version: resolvedVersion } = (0, fileutils_1.readJsonFile)(packageJsonPath);
-        const migrationsFilePath = packageToMigrationsFilePath(packageName, dir);
-        let migrations = null;
-        if (migrationsFilePath) {
-            migrations = (0, fileutils_1.readJsonFile)(migrationsFilePath);
-        }
+        const dir = (0, package_manager_1.createTempNpmDirectory)();
+        let result;
         try {
-            (0, fs_extra_1.removeSync)(dir);
+            const pmc = (0, package_manager_1.getPackageManagerCommand)();
+            yield execAsync(`${pmc.add} ${packageName}@${packageVersion}`, {
+                cwd: dir,
+            });
+            const { migrations: migrationsFilePath, packageGroup, packageJson, } = readPackageMigrationConfig(packageName, dir);
+            let migrations = undefined;
+            if (migrationsFilePath) {
+                migrations = (0, fileutils_1.readJsonFile)(migrationsFilePath);
+            }
+            result = Object.assign(Object.assign({}, migrations), { packageGroup, version: packageJson.version });
         }
-        catch (_a) {
-            // It's okay if this fails, the OS will clean it up eventually
+        finally {
+            try {
+                yield (0, fs_extra_1.remove)(dir);
+            }
+            catch (_a) {
+                // It's okay if this fails, the OS will clean it up eventually
+            }
         }
-        return { migrations, resolvedVersion };
+        return result;
     });
 }
-function createNPMRC(dir) {
-    // A package.json is needed for pnpm pack and for .npmrc to resolve
-    (0, fileutils_1.writeJsonFile)(`${dir}/package.json`, {});
-    const npmrc = (0, package_manager_1.checkForNPMRC)();
-    if (npmrc) {
-        // Copy npmrc if it exists, so that npm still follows it.
-        (0, fs_extra_1.copyFileSync)(npmrc, `${dir}/.npmrc`);
-    }
-}
-function packageToMigrationsFilePath(packageName, dir) {
+function readPackageMigrationConfig(packageName, dir) {
     const packageJsonPath = require.resolve(`${packageName}/package.json`, {
         paths: [dir],
     });
     const json = (0, fileutils_1.readJsonFile)(packageJsonPath);
-    let migrationsFile = json['nx-migrations'] || json['ng-update'];
-    // migrationsFile is an object
-    if (migrationsFile && migrationsFile.migrations) {
-        migrationsFile = migrationsFile.migrations;
+    const migrationConfigOrFile = json['nx-migrations'] || json['ng-update'];
+    if (!migrationConfigOrFile) {
+        return { packageJson: json, migrations: null, packageGroup: [] };
     }
-    try {
-        if (migrationsFile && typeof migrationsFile === 'string') {
-            return require.resolve(migrationsFile, {
-                paths: [(0, path_1.dirname)(packageJsonPath)],
-            });
-        }
-        else {
-            return null;
+    const migrationsConfig = typeof migrationConfigOrFile === 'string'
+        ? {
+            migrations: migrationConfigOrFile,
+            packageGroup: [],
         }
+        : migrationConfigOrFile;
+    try {
+        const migrationFile = require.resolve(migrationsConfig.migrations, {
+            paths: [(0, path_1.dirname)(packageJsonPath)],
+        });
+        return {
+            packageJson: json,
+            migrations: migrationFile,
+            packageGroup: migrationsConfig.packageGroup,
+        };
     }
     catch (_a) {
-        return null;
+        return {
+            packageJson: json,
+            migrations: null,
+            packageGroup: migrationsConfig.packageGroup,
+        };
     }
 }
 function createMigrationsFile(root, migrations) {
@@ -491,41 +517,56 @@ function updatePackageJson(root, updatedPackages) {
     const parseOptions = {};
     const json = (0, fileutils_1.readJsonFile)(packageJsonPath, parseOptions);
     Object.keys(updatedPackages).forEach((p) => {
-        if (json.devDependencies && json.devDependencies[p]) {
+        var _a, _b, _c;
+        if ((_a = json.devDependencies) === null || _a === void 0 ? void 0 : _a[p]) {
             json.devDependencies[p] = updatedPackages[p].version;
+            return;
         }
-        else if (json.dependencies && json.dependencies[p]) {
+        if ((_b = json.dependencies) === null || _b === void 0 ? void 0 : _b[p]) {
             json.dependencies[p] = updatedPackages[p].version;
+            return;
         }
-        else if (updatedPackages[p].addToPackageJson) {
-            if (updatedPackages[p].addToPackageJson === 'dependencies') {
-                if (!json.dependencies)
-                    json.dependencies = {};
-                json.dependencies[p] = updatedPackages[p].version;
-            }
-            else if (updatedPackages[p].addToPackageJson === 'devDependencies') {
-                if (!json.devDependencies)
-                    json.devDependencies = {};
-                json.devDependencies[p] = updatedPackages[p].version;
-            }
+        const dependencyType = updatedPackages[p].addToPackageJson;
+        if (typeof dependencyType === 'string') {
+            (_c = json[dependencyType]) !== null && _c !== void 0 ? _c : (json[dependencyType] = {});
+            json[dependencyType][p] = updatedPackages[p].version;
         }
     });
     (0, fileutils_1.writeJsonFile)(packageJsonPath, json, {
         appendNewLine: parseOptions.endsWithNewline,
     });
 }
+function isMigratingToNewMajor(from, to) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        from = normalizeVersion(from);
+        to = ['latest', 'next'].includes(to) ? to : normalizeVersion(to);
+        if (!(0, semver_1.valid)(from)) {
+            from = yield (0, package_manager_1.resolvePackageVersionUsingRegistry)('nx', from);
+        }
+        if (!(0, semver_1.valid)(to)) {
+            to = yield (0, package_manager_1.resolvePackageVersionUsingRegistry)('nx', to);
+        }
+        console.log({ from, to });
+        return (0, semver_1.major)(from) < (0, semver_1.major)(to);
+    });
+}
 function generateMigrationsJsonAndUpdatePackageJson(root, opts) {
+    var _a, _b, _c;
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const pmc = (0, package_manager_1.getPackageManagerCommand)();
         try {
+            let originalPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
+            if (['nx', '@nrwl/workspace'].includes(opts.targetPackage) &&
+                (yield isMigratingToNewMajor((_b = (_a = originalPackageJson.devDependencies) === null || _a === void 0 ? void 0 : _a['nx']) !== null && _b !== void 0 ? _b : (_c = originalPackageJson.devDependencies) === null || _c === void 0 ? void 0 : _c['@nrwl/workspace'], opts.targetVersion))) {
+                yield (0, connect_to_nx_cloud_1.connectToNxCloudCommand)('We noticed you are migrating to a new major version, but are not taking advantage of Nx Cloud. Nx Cloud can make your CI up to 10 times faster. Learn more about it here: nx.app. Would you like to add it?');
+                originalPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
+            }
             logger_1.logger.info(`Fetching meta data about packages.`);
             logger_1.logger.info(`It may take a few minutes.`);
-            const originalPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
             const migrator = new Migrator({
                 packageJson: originalPackageJson,
                 versions: versions(root, opts.from),
                 fetch: createFetcher(),
-                from: opts.from,
                 to: opts.to,
             });
             const { migrations, packageJson } = yield migrator.updatePackageJson(opts.targetPackage, opts.targetVersion);
@@ -544,11 +585,12 @@ function generateMigrationsJsonAndUpdatePackageJson(root, opts) {
             logger_1.logger.info(`NX Next steps:`);
             logger_1.logger.info(`- Make sure package.json changes make sense and then run '${pmc.install}'`);
             if (migrations.length > 0) {
-                logger_1.logger.info(`- Run 'nx migrate --run-migrations'`);
+                logger_1.logger.info(`- Run '${pmc.run('nx', 'migrate --run-migrations')}'`);
             }
             logger_1.logger.info(`- To learn more go to https://nx.dev/using-nx/updating-nx`);
             if (showConnectToCloudMessage()) {
-                logger_1.logger.info(`- You may run "nx connect-to-nx-cloud" to get faster builds, GitHub integration, and more. Check out https://nx.app`);
+                const cmd = pmc.run('nx', 'connect-to-nx-cloud');
+                logger_1.logger.info(`- You may run '${cmd}' to get faster builds, GitHub integration, and more. Check out https://nx.app`);
             }
         }
         catch (e) {
@@ -573,14 +615,16 @@ function runInstall() {
     logger_1.logger.info(`NX Running '${pmCommands.install}' to make sure necessary packages are installed`);
     (0, child_process_1.execSync)(pmCommands.install, { stdio: [0, 1, 2] });
 }
-function runMigrations(root, opts, isVerbose) {
+const NO_CHANGES = 'NO_CHANGES';
+function runMigrations(root, opts, isVerbose, shouldCreateCommits = false, commitPrefix) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         if (!process.env.NX_MIGRATE_SKIP_INSTALL) {
             runInstall();
         }
-        logger_1.logger.info(`NX Running migrations from '${opts.runMigrations}'`);
+        logger_1.logger.info(`NX 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;
-        for (let m of migrations) {
+        for (const m of migrations) {
             logger_1.logger.info(`Running migration ${m.name}`);
             if (m.cli === 'nx') {
                 yield runNxMigration(root, m.package, m.name);
@@ -589,14 +633,79 @@ function runMigrations(root, opts, isVerbose) {
                 yield (yield Promise.resolve().then(() => require('../adapter/ngcli-adapter'))).runMigration(root, m.package, m.name, isVerbose);
             }
             logger_1.logger.info(`Successfully finished ${m.name}`);
+            if (shouldCreateCommits) {
+                const commitMessage = `${commitPrefix}${m.name}`;
+                const { sha: committedSha, reasonForNoCommit } = commitChangesIfAny(commitMessage);
+                if (committedSha) {
+                    logger_1.logger.info(chalk.dim(`- Commit created for changes: ${committedSha}`));
+                }
+                else {
+                    switch (true) {
+                        // Isolate the NO_CHANGES case so that we can render it differently to errors
+                        case reasonForNoCommit === NO_CHANGES:
+                            logger_1.logger.info(chalk.dim(`- There were no changes to commit`));
+                            break;
+                        case typeof reasonForNoCommit === 'string': // Any other string is a specific error we captured
+                            logger_1.logger.info(chalk.red(`- ${reasonForNoCommit}`));
+                            break;
+                        default:
+                            logger_1.logger.info(chalk.red(`- A commit could not be created/retrieved for an unknown reason`));
+                    }
+                }
+            }
             logger_1.logger.info(`---------------------------------------------------------`);
         }
         logger_1.logger.info(`NX Successfully finished running migrations from '${opts.runMigrations}'`);
     });
 }
+function commitChangesIfAny(commitMessage) {
+    try {
+        if ((0, child_process_1.execSync)('git ls-files -m -d -o --exclude-standard').toString() === '') {
+            return {
+                sha: null,
+                reasonForNoCommit: NO_CHANGES,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            sha: null,
+            reasonForNoCommit: `Error determining git changes:\n${err.stderr}`,
+        };
+    }
+    try {
+        (0, child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
+        (0, child_process_1.execSync)('git commit --no-verify -F -', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            input: commitMessage,
+        });
+    }
+    catch (err) {
+        return {
+            sha: null,
+            reasonForNoCommit: `Error committing changes:\n${err.stderr}`,
+        };
+    }
+    return {
+        sha: getLatestCommitSha(),
+        reasonForNoCommit: null,
+    };
+}
+function getLatestCommitSha() {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse HEAD', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+        }).trim();
+    }
+    catch (_a) {
+        return null;
+    }
+}
 function runNxMigration(root, packageName, name) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const collectionPath = packageToMigrationsFilePath(packageName, root);
+        const collectionPath = readPackageMigrationConfig(packageName, root).migrations;
         const collection = (0, fileutils_1.readJsonFile)(collectionPath);
         const g = collection.generators || collection.schematics;
         const implRelativePath = g[name].implementation || g[name].factory;
@@ -625,7 +734,7 @@ function migrate(root, args) {
                 yield generateMigrationsJsonAndUpdatePackageJson(root, opts);
             }
             else {
-                yield runMigrations(root, opts, args['verbose']);
+                yield runMigrations(root, opts, args['verbose'], args['createCommits'], args['commitPrefix']);
             }
         }));
     });