3abd87a test: update update-7.0 E2E to reflect 8.0-rc.4 changes

Author: Angular Builds

commands/update-impl.d.ts

@@ -3,8 +3,6 @@ import { SchematicCommand } from '../models/schematic-command';
 import { Schema as UpdateCommandSchema } from './update';
 export declare class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
     readonly allowMissingWorkspace = true;
-    collectionName: string;
-    schematicName: string;
-    parseArguments(schematicOptions: string[], schema: Option[]): Promise<Arguments>;
+    parseArguments(_schematicOptions: string[], _schema: Option[]): Promise<Arguments>;
     run(options: UpdateCommandSchema & Arguments): Promise<number | void>;
 }

commands/update-impl.js

@@ -7,54 +7,217 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const core_1 = require("@angular-devkit/core");
+const path = require("path");
+const semver = require("semver");
 const schematic_command_1 = require("../models/schematic-command");
 const find_up_1 = require("../utilities/find-up");
 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 npa = require('npm-package-arg');
+const oldConfigFileNames = [
+    '.angular-cli.json',
+    'angular-cli.json',
+];
 class UpdateCommand extends schematic_command_1.SchematicCommand {
     constructor() {
         super(...arguments);
         this.allowMissingWorkspace = true;
-        this.collectionName = '@schematics/update';
-        this.schematicName = 'update';
     }
-    async parseArguments(schematicOptions, schema) {
-        const args = await super.parseArguments(schematicOptions, schema);
-        const maybeArgsLeftovers = args['--'];
-        if (maybeArgsLeftovers
-            && maybeArgsLeftovers.length == 1
-            && maybeArgsLeftovers[0] == '@angular/cli'
-            && args.migrateOnly === undefined
-            && args.from === undefined) {
-            // Check for a 1.7 angular-cli.json file.
-            const oldConfigFileNames = [
-                core_1.normalize('.angular-cli.json'),
-                core_1.normalize('angular-cli.json'),
-            ];
-            const oldConfigFilePath = find_up_1.findUp(oldConfigFileNames, process.cwd())
-                || find_up_1.findUp(oldConfigFileNames, __dirname);
-            if (oldConfigFilePath) {
-                args.migrateOnly = true;
-                args.from = '1.0.0';
-            }
-        }
-        // Move `--` to packages.
-        if (args.packages == undefined && args['--']) {
-            args.packages = args['--'];
-            delete args['--'];
-        }
-        return args;
+    async parseArguments(_schematicOptions, _schema) {
+        return {};
     }
+    // tslint:disable-next-line:no-big-function
     async run(options) {
+        const packages = [];
+        for (const request of options['--'] || []) {
+            try {
+                const packageIdentifier = npa(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 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;
+            }
+        }
+        if (options.all && packages.length > 0) {
+            this.logger.error('Cannot specify packages when using the "all" option.');
+            return 1;
+        }
+        else if (options.all && options.migrateOnly) {
+            this.logger.error('Cannot use "all" option with "migrate-only" option.');
+            return 1;
+        }
+        else if (!options.migrateOnly && (options.from || options.to)) {
+            this.logger.error('Can only use "from" or "to" options with "migrate-only" option.');
+            return 1;
+        }
         const packageManager = package_manager_1.getPackageManager(this.workspace.root);
+        this.logger.info(`Using package manager: '${packageManager}'`);
+        // Special handling for Angular CLI 1.x migrations
+        if (options.migrateOnly === undefined && options.from === undefined) {
+            if (!options.all && packages.length === 1 && packages[0].name === '@angular/cli') {
+                const oldConfigFilePath = find_up_1.findUp(oldConfigFileNames, process.cwd());
+                if (oldConfigFilePath) {
+                    options.migrateOnly = true;
+                    options.from = '1.0.0';
+                }
+            }
+        }
+        this.logger.info('Collecting installed dependencies...');
+        const packageTree = await package_tree_1.readPackageTree(this.workspace.root);
+        const rootDependencies = package_tree_1.findNodeDependencies(packageTree);
+        this.logger.info(`Found ${Object.keys(rootDependencies).length} dependencies.`);
+        if (options.all || packages.length === 0) {
+            // Either update all packages or show status
+            return this.runSchematic({
+                collectionName: '@schematics/update',
+                schematicName: 'update',
+                dryRun: !!options.dryRun,
+                showNothingDone: false,
+                additionalOptions: {
+                    force: options.force || false,
+                    next: options.next || false,
+                    packageManager,
+                    packages: options.all ? Object.keys(rootDependencies) : [],
+                },
+            });
+        }
+        if (options.migrateOnly) {
+            if (!options.from) {
+                this.logger.error('"from" option is required when using the "migrate-only" option.');
+                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;
+            let packageNode = rootDependencies[packageName];
+            if (typeof packageNode === 'string') {
+                this.logger.error('Package found in package.json but is not installed.');
+                return 1;
+            }
+            else if (!packageNode) {
+                // 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 child = packageTree.children.find(c => c.name === packageName);
+                if (child) {
+                    // A link represents a symlinked package so use the actual in this case
+                    packageNode = child.isLink ? child.target : child;
+                }
+                if (!packageNode) {
+                    this.logger.error('Package is not installed.');
+                    return 1;
+                }
+            }
+            const updateMetadata = packageNode.package['ng-update'];
+            let migrations = updateMetadata && 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;
+            }
+            // if not non-relative, add package name
+            if (migrations.startsWith('.') || migrations.startsWith('/')) {
+                migrations = path.join(packageName, migrations);
+            }
+            return this.runSchematic({
+                collectionName: '@schematics/update',
+                schematicName: 'migrate',
+                dryRun: !!options.dryRun,
+                force: false,
+                showNothingDone: false,
+                additionalOptions: {
+                    package: packageName,
+                    collection: migrations,
+                    from: options.from,
+                    to: options.to || packageNode.package.version,
+                },
+            });
+        }
+        const requests = [];
+        // Validate packages actually are part of the workspace
+        for (const pkg of packages) {
+            const node = rootDependencies[pkg.name];
+            if (!node) {
+                this.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' &&
+                typeof node === 'object' &&
+                node.package.version === pkg.fetchSpec) {
+                this.logger.info(`Package '${pkg.name}' is already at '${pkg.fetchSpec}'.`);
+                continue;
+            }
+            requests.push(pkg);
+        }
+        if (requests.length === 0) {
+            return 0;
+        }
+        this.logger.info('Fetching dependency metadata from registry...');
+        for (const requestIdentifier of requests) {
+            let metadata;
+            try {
+                // Metadata requests are internally cached; multiple requests for same name
+                // does not result in additional network traffic
+                metadata = await package_metadata_1.fetchPackageMetadata(requestIdentifier.name, this.logger);
+            }
+            catch (e) {
+                this.logger.error(`Error fetching metadata for '${requestIdentifier.name}': ` + e.message);
+                return 1;
+            }
+            // Try to find a package version based on the user requested package specifier
+            // registry specifier types are either version, range, or tag
+            let manifest;
+            if (requestIdentifier.type === 'version') {
+                manifest = metadata.versions.get(requestIdentifier.fetchSpec);
+            }
+            else if (requestIdentifier.type === 'range') {
+                const maxVersion = semver.maxSatisfying(Array.from(metadata.versions.keys()), requestIdentifier.fetchSpec);
+                if (maxVersion) {
+                    manifest = metadata.versions.get(maxVersion);
+                }
+            }
+            else if (requestIdentifier.type === 'tag') {
+                manifest = metadata.tags[requestIdentifier.fetchSpec];
+            }
+            if (!manifest) {
+                this.logger.error(`Package specified by '${requestIdentifier.raw}' does not exist within the registry.`);
+                return 1;
+            }
+        }
         return this.runSchematic({
-            collectionName: this.collectionName,
-            schematicName: this.schematicName,
-            schematicOptions: options['--'],
+            collectionName: '@schematics/update',
+            schematicName: 'update',
             dryRun: !!options.dryRun,
-            force: false,
             showNothingDone: false,
-            additionalOptions: { packageManager },
+            additionalOptions: {
+                force: options.force || false,
+                packageManager,
+                packages: requests.map(p => p.toString()),
+            },
         });
     }
 }

commands/update.d.ts

@@ -2,10 +2,41 @@
  * Updates your application and its dependencies. See https://update.angular.io/
  */
 export interface Schema {
+    /**
+     * Whether to update all packages in package.json.
+     */
+    all?: boolean;
+    /**
+     * If false, will error out if installed packages are incompatible with the update.
+     */
+    force?: boolean;
+    /**
+     * Version from which to migrate from. Only available with a single package being updated,
+     * and only on migration only.
+     */
+    from?: string;
     /**
      * Shows a help message for this command in the console.
      */
     help?: HelpUnion;
+    /**
+     * Only perform a migration, does not update the installed version.
+     */
+    migrateOnly?: boolean;
+    /**
+     * Use the largest version, including beta and RCs.
+     */
+    next?: boolean;
+    /**
+     * The names of package(s) to update.
+     */
+    packages?: string[];
+    /**
+     * Version up to which to apply migrations. Only available with a single package being
+     * updated, and only on migrations only. Requires from to be specified. Default to the
+     * installed version detected.
+     */
+    to?: string;
 }
 /**
  * Shows a help message for this command in the console.

commands/update.json

@@ -13,6 +13,48 @@
   "allOf": [
     {
       "$ref": "./definitions.json#/definitions/base"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "packages": {
+          "description": "The names of package(s) to update.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "$default": {
+            "$source": "argv"
+          }
+        },
+        "force": {
+          "description": "If false, will error out if installed packages are incompatible with the update.",
+          "default": false,
+          "type": "boolean"
+        },
+        "all": {
+          "description": "Whether to update all packages in package.json.",
+          "default": false,
+          "type": "boolean"
+        },
+        "next": {
+          "description": "Use the largest version, including beta and RCs.",
+          "default": false,
+          "type": "boolean"
+        },
+        "migrateOnly": {
+          "description": "Only perform a migration, does not update the installed version.",
+          "type": "boolean"
+        },
+        "from": {
+          "description": "Version from which to migrate from. Only available with a single package being updated, and only on migration only.",
+          "type": "string"
+        },
+        "to": {
+          "description": "Version up to which to apply migrations. Only available with a single package being updated, and only on migrations only. Requires from to be specified. Default to the installed version detected.",
+          "type": "string"
+        }
+      }
     }
   ]
 }