@angular/cli 14.0.0-next.1 → 14.0.0-next.12

package/{commands/update-impl.js → src/commands/update/cli.js}

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -29,45 +33,164 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateCommand = void 0;
+exports.UpdateCommandModule = void 0;
 const schematics_1 = require("@angular-devkit/schematics");
 const tools_1 = require("@angular-devkit/schematics/tools");
 const child_process_1 = require("child_process");
-const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
 const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
 const npm_pick_manifest_1 = __importDefault(require("npm-pick-manifest"));
 const path = __importStar(require("path"));
+const path_1 = require("path");
 const semver = __importStar(require("semver"));
-const workspace_schema_1 = require("../lib/config/workspace-schema");
-const command_1 = require("../models/command");
-const schematic_engine_host_1 = require("../models/schematic-engine-host");
-const version_1 = require("../models/version");
-const color_1 = require("../utilities/color");
-const install_package_1 = require("../utilities/install-package");
-const log_file_1 = require("../utilities/log-file");
-const package_manager_1 = require("../utilities/package-manager");
-const package_metadata_1 = require("../utilities/package-metadata");
-const package_tree_1 = require("../utilities/package-tree");
-const UPDATE_SCHEMATIC_COLLECTION = path.join(__dirname, '../src/commands/update/schematic/collection.json');
-/**
- * Disable CLI version mismatch checks and forces usage of the invoked CLI
- * instead of invoking the local installed version.
- */
-const disableVersionCheckEnv = process.env['NG_DISABLE_VERSION_CHECK'];
-const disableVersionCheck = disableVersionCheckEnv !== undefined &&
-    disableVersionCheckEnv !== '0' &&
-    disableVersionCheckEnv.toLowerCase() !== 'false';
+const workspace_schema_1 = require("../../../lib/config/workspace-schema");
+const command_module_1 = require("../../command-builder/command-module");
+const schematic_engine_host_1 = require("../../command-builder/utilities/schematic-engine-host");
+const schematic_workflow_1 = require("../../command-builder/utilities/schematic-workflow");
+const color_1 = require("../../utilities/color");
+const environment_options_1 = require("../../utilities/environment-options");
+const log_file_1 = require("../../utilities/log-file");
+const package_metadata_1 = require("../../utilities/package-metadata");
+const package_tree_1 = require("../../utilities/package-tree");
+const version_1 = require("../../utilities/version");
 const ANGULAR_PACKAGES_REGEXP = /^@(?:angular|nguniversal)\//;
-class UpdateCommand extends command_1.Command {
+const UPDATE_SCHEMATIC_COLLECTION = path.join(__dirname, 'schematic/collection.json');
+class UpdateCommandModule extends command_module_1.CommandModule {
     constructor() {
         super(...arguments);
-        this.allowMissingWorkspace = true;
-        this.packageManager = workspace_schema_1.PackageManager.Npm;
+        this.shouldReportAnalytics = false;
+        this.command = 'update [packages..]';
+        this.describe = 'Updates your workspace and its dependencies. See https://update.angular.io/.';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    }
+    builder(localYargs) {
+        return localYargs
+            .positional('packages', {
+            description: 'The names of package(s) to update.',
+            type: 'string',
+            array: true,
+        })
+            .option('force', {
+            description: 'Ignore peer dependency version mismatches. ' +
+                `Passes the '--force' flag to the package manager when installing packages.`,
+            type: 'boolean',
+            default: false,
+        })
+            .option('next', {
+            description: 'Use the prerelease version, including beta and RCs.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('migrate-only', {
+            description: 'Only perform a migration, do not update the installed version.',
+            type: 'boolean',
+        })
+            .option('name', {
+            description: 'The name of the migration to run. ' +
+                `Only available with a single package being updated, and only with 'migrate-only' option.`,
+            type: 'string',
+            implies: ['migrate-only'],
+            conflicts: ['to', 'from'],
+        })
+            .option('from', {
+            description: 'Version from which to migrate from. ' +
+                `Only available with a single package being updated, and only with 'migrate-only'.`,
+            type: 'string',
+            implies: ['to', 'migrate-only'],
+            conflicts: ['name'],
+        })
+            .option('to', {
+            describe: 'Version up to which to apply migrations. Only available with a single package being updated, ' +
+                `and only with 'migrate-only' option. Requires 'from' to be specified. Default to the installed version detected.`,
+            type: 'string',
+            implies: ['from', 'migrate-only'],
+            conflicts: ['name'],
+        })
+            .option('allow-dirty', {
+            describe: 'Whether to allow updating when the repository contains modified or untracked files.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            describe: 'Display additional details about internal operations during execution.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('create-commits', {
+            describe: 'Create source control commits for updates and migrations.',
+            type: 'boolean',
+            alias: ['C'],
+            default: false,
+        })
+            .check(({ packages, next, 'allow-dirty': allowDirty, 'migrate-only': migrateOnly }) => {
+            const { logger } = this.context;
+            // This allows the user to easily reset any changes from the update.
+            if ((packages === null || packages === void 0 ? void 0 : packages.length) && !this.checkCleanGit()) {
+                if (allowDirty) {
+                    logger.warn('Repository is not clean. Update changes will be mixed with pre-existing changes.');
+                }
+                else {
+                    throw new command_module_1.CommandModuleError('Repository is not clean. Please commit or stash any changes before updating.');
+                }
+            }
+            if (migrateOnly) {
+                if ((packages === null || packages === void 0 ? void 0 : packages.length) !== 1) {
+                    throw new command_module_1.CommandModuleError(`A single package must be specified when using the 'migrate-only' option.`);
+                }
+                if (next) {
+                    logger.warn(`'next' option has no effect when using 'migrate-only' option.`);
+                }
+            }
+            return true;
+        })
+            .strict();
     }
-    async initialize(options) {
-        this.packageManager = await (0, package_manager_1.getPackageManager)(this.context.root);
-        this.workflow = new tools_1.NodeWorkflow(this.context.root, {
-            packageManager: this.packageManager,
+    async run(options) {
+        var _a, _b;
+        const { logger, packageManager } = this.context;
+        packageManager.ensureCompatibility();
+        // Check if the current installed CLI version is older than the latest compatible version.
+        if (!environment_options_1.disableVersionCheck) {
+            const cliVersionToInstall = await this.checkCLIVersion(options.packages, options.verbose, options.next);
+            if (cliVersionToInstall) {
+                logger.warn('The installed Angular CLI version is outdated.\n' +
+                    `Installing a temporary Angular CLI versioned ${cliVersionToInstall} to perform the update.`);
+                return this.runTempBinary(`@angular/cli@${cliVersionToInstall}`, process.argv.slice(2));
+            }
+        }
+        const packages = [];
+        for (const request of (_a = options.packages) !== null && _a !== void 0 ? _a : []) {
+            try {
+                const packageIdentifier = (0, npm_package_arg_1.default)(request);
+                // only registry identifiers are supported
+                if (!packageIdentifier.registry) {
+                    logger.error(`Package '${request}' is not a registry package identifer.`);
+                    return 1;
+                }
+                if (packages.some((v) => v.name === packageIdentifier.name)) {
+                    logger.error(`Duplicate package '${packageIdentifier.name}' specified.`);
+                    return 1;
+                }
+                if (options.migrateOnly && packageIdentifier.rawSpec) {
+                    logger.warn('Package specifier has no effect when using "migrate-only" option.');
+                }
+                // If next option is used and no specifier supplied, use next tag
+                if (options.next && !packageIdentifier.rawSpec) {
+                    packageIdentifier.fetchSpec = 'next';
+                }
+                packages.push(packageIdentifier);
+            }
+            catch (e) {
+                logger.error(e.message);
+                return 1;
+            }
+        }
+        logger.info(`Using package manager: ${color_1.colors.grey(packageManager.name)}`);
+        logger.info('Collecting installed dependencies...');
+        const rootDependencies = await (0, package_tree_1.getProjectDependencies)(this.context.root);
+        logger.info(`Found ${rootDependencies.size} dependencies.`);
+        const workflow = new tools_1.NodeWorkflow(this.context.root, {
+            packageManager: packageManager.name,
             packageManagerForce: options.force,
             // __dirname -> favor @schematics/update from this package
             // Otherwise, use packages from the active workspace (migrations)
@@ -75,99 +198,77 @@ class UpdateCommand extends command_1.Command {
             schemaValidation: true,
             engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
         });
+        if (packages.length === 0) {
+            // Show status
+            const { success } = await this.executeSchematic(workflow, UPDATE_SCHEMATIC_COLLECTION, 'update', {
+                force: options.force,
+                next: options.next,
+                verbose: options.verbose,
+                packageManager: packageManager.name,
+                packages: [],
+            });
+            return success ? 0 : 1;
+        }
+        return options.migrateOnly
+            ? this.migrateOnly(workflow, ((_b = options.packages) !== null && _b !== void 0 ? _b : [])[0], rootDependencies, options)
+            : this.updatePackagesAndMigrate(workflow, rootDependencies, options, packages);
     }
-    async executeSchematic(collection, schematic, options = {}) {
-        let error = false;
-        let logs = [];
-        const files = new Set();
-        const reporterSubscription = this.workflow.reporter.subscribe((event) => {
-            // Strip leading slash to prevent confusion.
-            const eventPath = event.path.startsWith('/') ? event.path.substr(1) : event.path;
-            switch (event.kind) {
-                case 'error':
-                    error = true;
-                    const desc = event.description == 'alreadyExist' ? 'already exists' : 'does not exist.';
-                    this.logger.error(`ERROR! ${eventPath} ${desc}.`);
-                    break;
-                case 'update':
-                    logs.push(`${color_1.colors.cyan('UPDATE')} ${eventPath} (${event.content.length} bytes)`);
-                    files.add(eventPath);
-                    break;
-                case 'create':
-                    logs.push(`${color_1.colors.green('CREATE')} ${eventPath} (${event.content.length} bytes)`);
-                    files.add(eventPath);
-                    break;
-                case 'delete':
-                    logs.push(`${color_1.colors.yellow('DELETE')} ${eventPath}`);
-                    files.add(eventPath);
-                    break;
-                case 'rename':
-                    const eventToPath = event.to.startsWith('/') ? event.to.substr(1) : event.to;
-                    logs.push(`${color_1.colors.blue('RENAME')} ${eventPath} => ${eventToPath}`);
-                    files.add(eventPath);
-                    break;
-            }
-        });
-        const lifecycleSubscription = this.workflow.lifeCycle.subscribe((event) => {
-            if (event.kind == 'end' || event.kind == 'post-tasks-start') {
-                if (!error) {
-                    // Output the logging queue, no error happened.
-                    logs.forEach((log) => this.logger.info(`  ${log}`));
-                    logs = [];
-                }
-            }
-        });
+    async executeSchematic(workflow, collection, schematic, options = {}) {
+        const { logger } = this.context;
+        const workflowSubscription = (0, schematic_workflow_1.subscribeToWorkflow)(workflow, logger);
         // TODO: Allow passing a schematic instance directly
         try {
-            await this.workflow
+            await workflow
                 .execute({
                 collection,
                 schematic,
                 options,
-                logger: this.logger,
+                logger,
             })
                 .toPromise();
-            reporterSubscription.unsubscribe();
-            lifecycleSubscription.unsubscribe();
-            return { success: !error, files };
+            return { success: !workflowSubscription.error, files: workflowSubscription.files };
         }
         catch (e) {
             if (e instanceof schematics_1.UnsuccessfulWorkflowExecution) {
-                this.logger.error(`${color_1.colors.symbols.cross} Migration failed. See above for further details.\n`);
+                logger.error(`${color_1.colors.symbols.cross} Migration failed. See above for further details.\n`);
             }
             else {
                 const logPath = (0, log_file_1.writeErrorToLogFile)(e);
-                this.logger.fatal(`${color_1.colors.symbols.cross} Migration failed: ${e.message}\n` +
+                logger.fatal(`${color_1.colors.symbols.cross} Migration failed: ${e.message}\n` +
                     `  See "${logPath}" for further details.\n`);
             }
-            return { success: false, files };
+            return { success: false, files: workflowSubscription.files };
+        }
+        finally {
+            workflowSubscription.unsubscribe();
         }
     }
     /**
      * @return Whether or not the migration was performed successfully.
      */
-    async executeMigration(packageName, collectionPath, migrationName, commit) {
-        const collection = this.workflow.engine.createCollection(collectionPath);
+    async executeMigration(workflow, packageName, collectionPath, migrationName, commit) {
+        const { logger } = this.context;
+        const collection = workflow.engine.createCollection(collectionPath);
         const name = collection.listSchematicNames().find((name) => name === migrationName);
         if (!name) {
-            this.logger.error(`Cannot find migration '${migrationName}' in '${packageName}'.`);
-            return false;
+            logger.error(`Cannot find migration '${migrationName}' in '${packageName}'.`);
+            return 1;
         }
-        const schematic = this.workflow.engine.createSchematic(name, collection);
-        this.logger.info(color_1.colors.cyan(`** Executing '${migrationName}' of package '${packageName}' **\n`));
-        return this.executePackageMigrations([schematic.description], packageName, commit);
+        logger.info(color_1.colors.cyan(`** Executing '${migrationName}' of package '${packageName}' **\n`));
+        const schematic = workflow.engine.createSchematic(name, collection);
+        return this.executePackageMigrations(workflow, [schematic.description], packageName, commit);
     }
     /**
      * @return Whether or not the migrations were performed successfully.
      */
-    async executeMigrations(packageName, collectionPath, from, to, commit) {
-        const collection = this.workflow.engine.createCollection(collectionPath);
+    async executeMigrations(workflow, packageName, collectionPath, from, to, commit) {
+        const collection = workflow.engine.createCollection(collectionPath);
         const migrationRange = new semver.Range('>' + (semver.prerelease(from) ? from.split('-')[0] + '-0' : from) + ' <=' + to.split('-')[0]);
         const migrations = [];
         for (const name of collection.listSchematicNames()) {
-            const schematic = this.workflow.engine.createSchematic(name, collection);
+            const schematic = workflow.engine.createSchematic(name, collection);
             const description = schematic.description;
-            description.version = coerceVersionNumber(description.version) || undefined;
+            description.version = coerceVersionNumber(description.version);
             if (!description.version) {
                 continue;
             }
@@ -175,27 +276,28 @@ class UpdateCommand extends command_1.Command {
                 migrations.push(description);
             }
         }
-        migrations.sort((a, b) => semver.compare(a.version, b.version) || a.name.localeCompare(b.name));
         if (migrations.length === 0) {
-            return true;
+            return 0;
         }
-        this.logger.info(color_1.colors.cyan(`** Executing migrations of package '${packageName}' **\n`));
-        return this.executePackageMigrations(migrations, packageName, commit);
+        migrations.sort((a, b) => semver.compare(a.version, b.version) || a.name.localeCompare(b.name));
+        this.context.logger.info(color_1.colors.cyan(`** Executing migrations of package '${packageName}' **\n`));
+        return this.executePackageMigrations(workflow, migrations, packageName, commit);
     }
-    async executePackageMigrations(migrations, packageName, commit = false) {
+    async executePackageMigrations(workflow, migrations, packageName, commit = false) {
+        const { logger } = this.context;
         for (const migration of migrations) {
             const [title, ...description] = migration.description.split('. ');
-            this.logger.info(color_1.colors.cyan(color_1.colors.symbols.pointer) +
+            logger.info(color_1.colors.cyan(color_1.colors.symbols.pointer) +
                 ' ' +
                 color_1.colors.bold(title.endsWith('.') ? title : title + '.'));
             if (description.length) {
-                this.logger.info('  ' + description.join('.\n  '));
+                logger.info('  ' + description.join('.\n  '));
             }
-            const result = await this.executeSchematic(migration.collection.name, migration.name);
+            const result = await this.executeSchematic(workflow, migration.collection.name, migration.name);
             if (!result.success) {
-                return false;
+                return 1;
             }
-            this.logger.info('  Migration completed.');
+            logger.info('  Migration completed.');
             // Commit migration
             if (commit) {
                 const commitPrefix = `${packageName} migration - ${migration.name}`;
@@ -205,188 +307,107 @@ class UpdateCommand extends command_1.Command {
                 const committed = this.commit(commitMessage);
                 if (!committed) {
                     // Failed to commit, something went wrong. Abort the update.
-                    return false;
+                    return 1;
                 }
             }
-            this.logger.info(''); // Extra trailing newline.
+            logger.info(''); // Extra trailing newline.
         }
-        return true;
+        return 0;
     }
-    // eslint-disable-next-line max-lines-per-function
-    async run(options) {
-        var _a;
-        await (0, package_manager_1.ensureCompatibleNpm)(this.context.root);
-        // Check if the current installed CLI version is older than the latest compatible version.
-        if (!disableVersionCheck) {
-            const cliVersionToInstall = await this.checkCLIVersion(options['--'], options.verbose, options.next);
-            if (cliVersionToInstall) {
-                this.logger.warn('The installed Angular CLI version is outdated.\n' +
-                    `Installing a temporary Angular CLI versioned ${cliVersionToInstall} to perform the update.`);
-                return (0, install_package_1.runTempPackageBin)(`@angular/cli@${cliVersionToInstall}`, this.packageManager, process.argv.slice(2));
-            }
+    async migrateOnly(workflow, packageName, rootDependencies, options) {
+        const { logger } = this.context;
+        const packageDependency = rootDependencies.get(packageName);
+        let packagePath = packageDependency === null || packageDependency === void 0 ? void 0 : packageDependency.path;
+        let packageNode = packageDependency === null || packageDependency === void 0 ? void 0 : packageDependency.package;
+        if (packageDependency && !packageNode) {
+            logger.error('Package found in package.json but is not installed.');
+            return 1;
         }
-        const logVerbose = (message) => {
-            if (options.verbose) {
-                this.logger.info(message);
-            }
-        };
-        const packages = [];
-        for (const request of options['--'] || []) {
-            try {
-                const packageIdentifier = (0, npm_package_arg_1.default)(request);
-                // only registry identifiers are supported
-                if (!packageIdentifier.registry) {
-                    this.logger.error(`Package '${request}' is not a registry package identifer.`);
-                    return 1;
-                }
-                if (packages.some((v) => v.name === packageIdentifier.name)) {
-                    this.logger.error(`Duplicate package '${packageIdentifier.name}' specified.`);
-                    return 1;
-                }
-                if (options.migrateOnly && packageIdentifier.rawSpec) {
-                    this.logger.warn('Package specifier has no effect when using "migrate-only" option.');
-                }
-                // If next option is used and no specifier supplied, use next tag
-                if (options.next && !packageIdentifier.rawSpec) {
-                    packageIdentifier.fetchSpec = 'next';
-                }
-                packages.push(packageIdentifier);
-            }
-            catch (e) {
-                this.logger.error(e.message);
-                return 1;
+        else if (!packageDependency) {
+            // Allow running migrations on transitively installed dependencies
+            // There can technically be nested multiple versions
+            // TODO: If multiple, this should find all versions and ask which one to use
+            const packageJson = (0, package_tree_1.findPackageJson)(this.context.root, packageName);
+            if (packageJson) {
+                packagePath = path.dirname(packageJson);
+                packageNode = await (0, package_tree_1.readPackageJson)(packageJson);
             }
         }
-        if (!options.migrateOnly && (options.from || options.to)) {
-            this.logger.error('Can only use "from" or "to" options with "migrate-only" option.');
+        if (!packageNode || !packagePath) {
+            logger.error('Package is not installed.');
             return 1;
         }
-        // If not asking for status then check for a clean git repository.
-        // This allows the user to easily reset any changes from the update.
-        if (packages.length && !this.checkCleanGit()) {
-            if (options.allowDirty) {
-                this.logger.warn('Repository is not clean. Update changes will be mixed with pre-existing changes.');
-            }
-            else {
-                this.logger.error('Repository is not clean. Please commit or stash any changes before updating.');
-                return 2;
-            }
+        const updateMetadata = packageNode['ng-update'];
+        let migrations = updateMetadata === null || updateMetadata === void 0 ? void 0 : updateMetadata.migrations;
+        if (migrations === undefined) {
+            logger.error('Package does not provide migrations.');
+            return 1;
         }
-        this.logger.info(`Using package manager: '${this.packageManager}'`);
-        this.logger.info('Collecting installed dependencies...');
-        const rootDependencies = await (0, package_tree_1.getProjectDependencies)(this.context.root);
-        this.logger.info(`Found ${rootDependencies.size} dependencies.`);
-        if (packages.length === 0) {
-            // Show status
-            const { success } = await this.executeSchematic(UPDATE_SCHEMATIC_COLLECTION, 'update', {
-                force: options.force || false,
-                next: options.next || false,
-                verbose: options.verbose || false,
-                packageManager: this.packageManager,
-                packages: [],
-            });
-            return success ? 0 : 1;
+        else if (typeof migrations !== 'string') {
+            logger.error('Package contains a malformed migrations field.');
+            return 1;
         }
-        if (options.migrateOnly) {
-            if (!options.from && typeof options.migrateOnly !== 'string') {
-                this.logger.error('"from" option is required when using the "migrate-only" option without a migration name.');
-                return 1;
-            }
-            else if (packages.length !== 1) {
-                this.logger.error('A single package must be specified when using the "migrate-only" option.');
-                return 1;
-            }
-            if (options.next) {
-                this.logger.warn('"next" option has no effect when using "migrate-only" option.');
-            }
-            const packageName = packages[0].name;
-            const packageDependency = rootDependencies.get(packageName);
-            let packagePath = packageDependency === null || packageDependency === void 0 ? void 0 : packageDependency.path;
-            let packageNode = packageDependency === null || packageDependency === void 0 ? void 0 : packageDependency.package;
-            if (packageDependency && !packageNode) {
-                this.logger.error('Package found in package.json but is not installed.');
-                return 1;
-            }
-            else if (!packageDependency) {
-                // Allow running migrations on transitively installed dependencies
-                // There can technically be nested multiple versions
-                // TODO: If multiple, this should find all versions and ask which one to use
-                const packageJson = (0, package_tree_1.findPackageJson)(this.context.root, packageName);
-                if (packageJson) {
-                    packagePath = path.dirname(packageJson);
-                    packageNode = await (0, package_tree_1.readPackageJson)(packageJson);
-                }
-            }
-            if (!packageNode || !packagePath) {
-                this.logger.error('Package is not installed.');
-                return 1;
-            }
-            const updateMetadata = packageNode['ng-update'];
-            let migrations = updateMetadata === null || updateMetadata === void 0 ? void 0 : updateMetadata.migrations;
-            if (migrations === undefined) {
-                this.logger.error('Package does not provide migrations.');
-                return 1;
-            }
-            else if (typeof migrations !== 'string') {
-                this.logger.error('Package contains a malformed migrations field.');
-                return 1;
-            }
-            else if (path.posix.isAbsolute(migrations) || path.win32.isAbsolute(migrations)) {
-                this.logger.error('Package contains an invalid migrations field. Absolute paths are not permitted.');
-                return 1;
-            }
-            // Normalize slashes
-            migrations = migrations.replace(/\\/g, '/');
-            if (migrations.startsWith('../')) {
-                this.logger.error('Package contains an invalid migrations field. Paths outside the package root are not permitted.');
-                return 1;
-            }
-            // Check if it is a package-local location
-            const localMigrations = path.join(packagePath, migrations);
-            if (fs.existsSync(localMigrations)) {
-                migrations = localMigrations;
+        else if (path.posix.isAbsolute(migrations) || path.win32.isAbsolute(migrations)) {
+            logger.error('Package contains an invalid migrations field. Absolute paths are not permitted.');
+            return 1;
+        }
+        // Normalize slashes
+        migrations = migrations.replace(/\\/g, '/');
+        if (migrations.startsWith('../')) {
+            logger.error('Package contains an invalid migrations field. Paths outside the package root are not permitted.');
+            return 1;
+        }
+        // Check if it is a package-local location
+        const localMigrations = path.join(packagePath, migrations);
+        if ((0, fs_1.existsSync)(localMigrations)) {
+            migrations = localMigrations;
+        }
+        else {
+            // Try to resolve from package location.
+            // This avoids issues with package hoisting.
+            try {
+                migrations = require.resolve(migrations, { paths: [packagePath] });
             }
-            else {
-                // Try to resolve from package location.
-                // This avoids issues with package hoisting.
-                try {
-                    migrations = require.resolve(migrations, { paths: [packagePath] });
-                }
-                catch (e) {
-                    if (e.code === 'MODULE_NOT_FOUND') {
-                        this.logger.error('Migrations for package were not found.');
-                    }
-                    else {
-                        this.logger.error(`Unable to resolve migrations for package.  [${e.message}]`);
-                    }
-                    return 1;
+            catch (e) {
+                if (e.code === 'MODULE_NOT_FOUND') {
+                    logger.error('Migrations for package were not found.');
                 }
-            }
-            let result;
-            if (typeof options.migrateOnly == 'string') {
-                result = await this.executeMigration(packageName, migrations, options.migrateOnly, options.createCommits);
-            }
-            else {
-                const from = coerceVersionNumber(options.from);
-                if (!from) {
-                    this.logger.error(`"from" value [${options.from}] is not a valid version.`);
-                    return 1;
+                else {
+                    logger.error(`Unable to resolve migrations for package.  [${e.message}]`);
                 }
-                result = await this.executeMigrations(packageName, migrations, from, options.to || packageNode.version, options.createCommits);
+                return 1;
             }
-            return result ? 0 : 1;
         }
+        if (options.name) {
+            return this.executeMigration(workflow, packageName, migrations, options.name, options.createCommits);
+        }
+        const from = coerceVersionNumber(options.from);
+        if (!from) {
+            logger.error(`"from" value [${options.from}] is not a valid version.`);
+            return 1;
+        }
+        return this.executeMigrations(workflow, packageName, migrations, from, options.to || packageNode.version, options.createCommits);
+    }
+    // eslint-disable-next-line max-lines-per-function
+    async updatePackagesAndMigrate(workflow, rootDependencies, options, packages) {
+        var _a;
+        const { logger } = this.context;
+        const logVerbose = (message) => {
+            if (options.verbose) {
+                logger.info(message);
+            }
+        };
         const requests = [];
         // Validate packages actually are part of the workspace
         for (const pkg of packages) {
             const node = rootDependencies.get(pkg.name);
             if (!(node === null || node === void 0 ? void 0 : node.package)) {
-                this.logger.error(`Package '${pkg.name}' is not a dependency.`);
+                logger.error(`Package '${pkg.name}' is not a dependency.`);
                 return 1;
             }
             // If a specific version is requested and matches the installed version, skip.
             if (pkg.type === 'version' && node.package.version === pkg.fetchSpec) {
-                this.logger.info(`Package '${pkg.name}' is already at '${pkg.fetchSpec}'.`);
+                logger.info(`Package '${pkg.name}' is already at '${pkg.fetchSpec}'.`);
                 continue;
             }
             requests.push({ identifier: pkg, node });
@@ -394,20 +415,20 @@ class UpdateCommand extends command_1.Command {
         if (requests.length === 0) {
             return 0;
         }
+        logger.info('Fetching dependency metadata from registry...');
         const packagesToUpdate = [];
-        this.logger.info('Fetching dependency metadata from registry...');
         for (const { identifier: requestIdentifier, node } of requests) {
             const packageName = requestIdentifier.name;
             let metadata;
             try {
                 // Metadata requests are internally cached; multiple requests for same name
                 // does not result in additional network traffic
-                metadata = await (0, package_metadata_1.fetchPackageMetadata)(packageName, this.logger, {
+                metadata = await (0, package_metadata_1.fetchPackageMetadata)(packageName, logger, {
                     verbose: options.verbose,
                 });
             }
             catch (e) {
-                this.logger.error(`Error fetching metadata for '${packageName}': ` + e.message);
+                logger.error(`Error fetching metadata for '${packageName}': ` + e.message);
                 return 1;
             }
             // Try to find a package version based on the user requested package specifier
@@ -442,11 +463,11 @@ class UpdateCommand extends command_1.Command {
                 }
             }
             if (!manifest) {
-                this.logger.error(`Package specified by '${requestIdentifier.raw}' does not exist within the registry.`);
+                logger.error(`Package specified by '${requestIdentifier.raw}' does not exist within the registry.`);
                 return 1;
             }
             if (manifest.version === ((_a = node.package) === null || _a === void 0 ? void 0 : _a.version)) {
-                this.logger.info(`Package '${packageName}' is already up to date.`);
+                logger.info(`Package '${packageName}' is already up to date.`);
                 continue;
             }
             if (node.package && ANGULAR_PACKAGES_REGEXP.test(node.package.name)) {
@@ -458,12 +479,12 @@ class UpdateCommand extends command_1.Command {
                     if (currentMajorVersion < 6) {
                         // Before version 6, the major versions were not always sequential.
                         // Example @angular/core skipped version 3, @angular/cli skipped versions 2-5.
-                        this.logger.error(`Updating multiple major versions of '${name}' at once is not supported. Please migrate each major version individually.\n` +
+                        logger.error(`Updating multiple major versions of '${name}' at once is not supported. Please migrate each major version individually.\n` +
                             `For more information about the update process, see https://update.angular.io/.`);
                     }
                     else {
                         const nextMajorVersionFromCurrent = currentMajorVersion + 1;
-                        this.logger.error(`Updating multiple major versions of '${name}' at once is not supported. Please migrate each major version individually.\n` +
+                        logger.error(`Updating multiple major versions of '${name}' at once is not supported. Please migrate each major version individually.\n` +
                             `Run 'ng update ${name}@${nextMajorVersionFromCurrent}' in your workspace directory ` +
                             `to update to latest '${nextMajorVersionFromCurrent}.x' version of '${name}'.\n\n` +
                             `For more information about the update process, see https://update.angular.io/?v=${currentMajorVersion}.0-${nextMajorVersionFromCurrent}.0`);
@@ -476,42 +497,29 @@ class UpdateCommand extends command_1.Command {
         if (packagesToUpdate.length === 0) {
             return 0;
         }
-        const { success } = await this.executeSchematic(UPDATE_SCHEMATIC_COLLECTION, 'update', {
-            verbose: options.verbose || false,
-            force: options.force || false,
-            next: !!options.next,
-            packageManager: this.packageManager,
+        const { success } = await this.executeSchematic(workflow, UPDATE_SCHEMATIC_COLLECTION, 'update', {
+            verbose: options.verbose,
+            force: options.force,
+            next: options.next,
+            packageManager: this.context.packageManager.name,
             packages: packagesToUpdate,
         });
         if (success) {
             try {
-                // Remove existing node modules directory to provide a stronger guarantee that packages
-                // will be hoisted into the correct locations.
-                // The below should be removed and replaced with just `rm` when support for Node.Js 12 is removed.
-                const { rm, rmdir } = fs.promises;
-                if (rm) {
-                    await rm(path.join(this.context.root, 'node_modules'), {
-                        force: true,
-                        recursive: true,
-                        maxRetries: 3,
-                    });
-                }
-                else {
-                    await rmdir(path.join(this.context.root, 'node_modules'), {
-                        recursive: true,
-                        maxRetries: 3,
-                    });
-                }
+                await fs_1.promises.rm(path.join(this.context.root, 'node_modules'), {
+                    force: true,
+                    recursive: true,
+                    maxRetries: 3,
+                });
             }
             catch { }
-            const result = await (0, install_package_1.installAllPackages)(this.packageManager, options.force ? ['--force'] : [], this.context.root);
-            if (result !== 0) {
-                return result;
+            const installationSuccess = await this.context.packageManager.installAll(options.force ? ['--force'] : [], this.context.root);
+            if (!installationSuccess) {
+                return 1;
             }
         }
         if (success && options.createCommits) {
-            const committed = this.commit(`Angular CLI update for packages - ${packagesToUpdate.join(', ')}`);
-            if (!committed) {
+            if (!this.commit(`Angular CLI update for packages - ${packagesToUpdate.join(', ')}`)) {
                 return 1;
             }
         }
@@ -545,18 +553,18 @@ class UpdateCommand extends command_1.Command {
                 catch (e) {
                     if (e.code === 'MODULE_NOT_FOUND') {
                         logVerbose(e.toString());
-                        this.logger.error(`Migrations for package (${migration.package}) were not found.` +
+                        logger.error(`Migrations for package (${migration.package}) were not found.` +
                             ' The package could not be found in the workspace.');
                     }
                     else {
-                        this.logger.error(`Unable to resolve migrations for package (${migration.package}).  [${e.message}]`);
+                        logger.error(`Unable to resolve migrations for package (${migration.package}).  [${e.message}]`);
                     }
                     return 1;
                 }
                 let migrations;
                 // Check if it is a package-local location
                 const localMigrations = path.join(packagePath, migration.collection);
-                if (fs.existsSync(localMigrations)) {
+                if ((0, fs_1.existsSync)(localMigrations)) {
                     migrations = localMigrations;
                 }
                 else {
@@ -567,15 +575,15 @@ class UpdateCommand extends command_1.Command {
                     }
                     catch (e) {
                         if (e.code === 'MODULE_NOT_FOUND') {
-                            this.logger.error(`Migrations for package (${migration.package}) were not found.`);
+                            logger.error(`Migrations for package (${migration.package}) were not found.`);
                         }
                         else {
-                            this.logger.error(`Unable to resolve migrations for package (${migration.package}).  [${e.message}]`);
+                            logger.error(`Unable to resolve migrations for package (${migration.package}).  [${e.message}]`);
                         }
                         return 1;
                     }
                 }
-                const result = await this.executeMigrations(migration.package, migrations, migration.from, migration.to, options.createCommits);
+                const result = await this.executeMigrations(workflow, migration.package, migrations, migration.from, migration.to, options.createCommits);
                 if (!result) {
                     return 0;
                 }
@@ -587,17 +595,18 @@ class UpdateCommand extends command_1.Command {
      * @return Whether or not the commit was successful.
      */
     commit(message) {
+        const { logger } = this.context;
         // Check if a commit is needed.
         let commitNeeded;
         try {
             commitNeeded = hasChangesToCommit();
         }
         catch (err) {
-            this.logger.error(`  Failed to read Git tree:\n${err.stderr}`);
+            logger.error(`  Failed to read Git tree:\n${err.stderr}`);
             return false;
         }
         if (!commitNeeded) {
-            this.logger.info('  No changes to commit after migration.');
+            logger.info('  No changes to commit after migration.');
             return true;
         }
         // Commit changes and abort on error.
@@ -605,20 +614,20 @@ class UpdateCommand extends command_1.Command {
             createCommit(message);
         }
         catch (err) {
-            this.logger.error(`Failed to commit update (${message}):\n${err.stderr}`);
+            logger.error(`Failed to commit update (${message}):\n${err.stderr}`);
             return false;
         }
         // Notify user of the commit.
         const hash = findCurrentGitSha();
         const shortMessage = message.split('\n')[0];
         if (hash) {
-            this.logger.info(`  Committed migration step (${getShortHash(hash)}): ${shortMessage}.`);
+            logger.info(`  Committed migration step (${getShortHash(hash)}): ${shortMessage}.`);
         }
         else {
             // Commit was successful, but reading the hash was not. Something weird happened,
             // but nothing that would stop the update. Just log the weirdness and continue.
-            this.logger.info(`  Committed migration step: ${shortMessage}.`);
-            this.logger.warn('  Failed to look up hash of most recent commit, continuing anyways.');
+            logger.info(`  Committed migration step: ${shortMessage}.`);
+            logger.warn('  Failed to look up hash of most recent commit, continuing anyways.');
         }
         return true;
     }
@@ -648,9 +657,9 @@ class UpdateCommand extends command_1.Command {
      * @returns the version to install or null when there is no update to install.
      */
     async checkCLIVersion(packagesToUpdate, verbose = false, next = false) {
-        const { version } = await (0, package_metadata_1.fetchPackageManifest)(`@angular/cli@${this.getCLIUpdateRunnerVersion(packagesToUpdate, next)}`, this.logger, {
+        const { version } = await (0, package_metadata_1.fetchPackageManifest)(`@angular/cli@${this.getCLIUpdateRunnerVersion(packagesToUpdate, next)}`, this.context.logger, {
             verbose,
-            usingYarn: this.packageManager === workspace_schema_1.PackageManager.Yarn,
+            usingYarn: this.context.packageManager.name === workspace_schema_1.PackageManager.Yarn,
         });
         return version_1.VERSION.full === version ? null : version;
     }
@@ -677,16 +686,54 @@ class UpdateCommand extends command_1.Command {
         // We end up using Angular ClI v13 to run the migrations if we run the migrations using the CLI installed major version + 1 logic.
         return version_1.VERSION.major;
     }
+    async runTempBinary(packageName, args = []) {
+        const { success, tempNodeModules } = await this.context.packageManager.installTemp(packageName);
+        if (!success) {
+            return 1;
+        }
+        // Remove version/tag etc... from package name
+        // Ex: @angular/cli@latest -> @angular/cli
+        const packageNameNoVersion = packageName.substring(0, packageName.lastIndexOf('@'));
+        const pkgLocation = (0, path_1.join)(tempNodeModules, packageNameNoVersion);
+        const packageJsonPath = (0, path_1.join)(pkgLocation, 'package.json');
+        // Get a binary location for this package
+        let binPath;
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            const content = await fs_1.promises.readFile(packageJsonPath, 'utf-8');
+            if (content) {
+                const { bin = {} } = JSON.parse(content);
+                const binKeys = Object.keys(bin);
+                if (binKeys.length) {
+                    binPath = (0, path_1.resolve)(pkgLocation, bin[binKeys[0]]);
+                }
+            }
+        }
+        if (!binPath) {
+            throw new Error(`Cannot locate bin for temporary package: ${packageNameNoVersion}.`);
+        }
+        const { status, error } = (0, child_process_1.spawnSync)(process.execPath, [binPath, ...args], {
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                NG_DISABLE_VERSION_CHECK: 'true',
+                NG_CLI_ANALYTICS: 'false',
+            },
+        });
+        if (status === null && error) {
+            throw error;
+        }
+        return status !== null && status !== void 0 ? status : 0;
+    }
 }
-exports.UpdateCommand = UpdateCommand;
+exports.UpdateCommandModule = UpdateCommandModule;
+UpdateCommandModule.scope = command_module_1.CommandScope.In;
 /**
  * @return Whether or not the working directory has Git changes to commit.
  */
 function hasChangesToCommit() {
     // List all modified files not covered by .gitignore.
-    const files = (0, child_process_1.execSync)('git ls-files -m -d -o --exclude-standard').toString();
     // If any files are returned, then there must be something to commit.
-    return files !== '';
+    return (0, child_process_1.execSync)('git ls-files -m -d -o --exclude-standard').toString() !== '';
 }
 /**
  * Precondition: Must have pending changes to commit, they do not need to be staged.
@@ -704,8 +751,7 @@ function createCommit(message) {
  */
 function findCurrentGitSha() {
     try {
-        const hash = (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf8', stdio: 'pipe' });
-        return hash.trim();
+        return (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf8', stdio: 'pipe' }).trim();
     }
     catch {
         return null;
@@ -715,23 +761,24 @@ function getShortHash(commitHash) {
     return commitHash.slice(0, 9);
 }
 function coerceVersionNumber(version) {
+    var _a;
     if (!version) {
-        return null;
+        return undefined;
     }
-    if (!version.match(/^\d{1,30}\.\d{1,30}\.\d{1,30}/)) {
+    if (!/^\d{1,30}\.\d{1,30}\.\d{1,30}/.test(version)) {
         const match = version.match(/^\d{1,30}(\.\d{1,30})*/);
         if (!match) {
-            return null;
+            return undefined;
         }
         if (!match[1]) {
-            version = version.substr(0, match[0].length) + '.0.0' + version.substr(match[0].length);
+            version = version.substring(0, match[0].length) + '.0.0' + version.substring(match[0].length);
         }
         else if (!match[2]) {
-            version = version.substr(0, match[0].length) + '.0' + version.substr(match[0].length);
+            version = version.substring(0, match[0].length) + '.0' + version.substring(match[0].length);
         }
         else {
-            return null;
+            return undefined;
         }
     }
-    return semver.valid(version);
+    return (_a = semver.valid(version)) !== null && _a !== void 0 ? _a : undefined;
 }