refactor(@angular/cli): simplify update command schematic execution

Author: clydin

packages/angular/cli/commands/update-impl.ts

@@ -5,12 +5,17 @@
  * 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
  */
+import { normalize, virtualFs } from '@angular-devkit/core';
+import { NodeJsSyncHost } from '@angular-devkit/core/node';
+import { UnsuccessfulWorkflowExecution } from '@angular-devkit/schematics';
+import { NodeWorkflow, validateOptionsWithSchema } from '@angular-devkit/schematics/tools';
 import { execSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as semver from 'semver';
-import { Arguments, Option } from '../models/interface';
-import { SchematicCommand } from '../models/schematic-command';
+import { Command } from '../models/command';
+import { Arguments } from '../models/interface';
+import { colors } from '../utilities/color';
 import { getPackageManager } from '../utilities/package-manager';
 import {
   PackageIdentifier,
@@ -28,11 +33,96 @@ const npa = require('npm-package-arg');
 
 const oldConfigFileNames = ['.angular-cli.json', 'angular-cli.json'];
 
-export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
+export class UpdateCommand extends Command<UpdateCommandSchema> {
   public readonly allowMissingWorkspace = true;
 
-  async parseArguments(_schematicOptions: string[], _schema: Option[]): Promise<Arguments> {
-    return {};
+  private workflow: NodeWorkflow;
+
+  async initialize() {
+    this.workflow = new NodeWorkflow(
+      new virtualFs.ScopedHost(new NodeJsSyncHost(), normalize(this.workspace.root)),
+      {
+        packageManager: await getPackageManager(this.workspace.root),
+        root: normalize(this.workspace.root),
+      },
+    );
+
+    this.workflow.engineHost.registerOptionsTransform(
+      validateOptionsWithSchema(this.workflow.registry),
+    );
+  }
+
+  async executeSchematic(
+    collection: string,
+    schematic: string,
+    options = {},
+  ): Promise<{ success: boolean; files: Set<string> }> {
+    let error = false;
+    const logs: string[] = [];
+    const files = new Set<string>();
+
+    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.warn(`ERROR! ${eventPath} ${desc}.`);
+          break;
+        case 'update':
+          logs.push(`${colors.whiteBright('UPDATE')} ${eventPath} (${event.content.length} bytes)`);
+          files.add(eventPath);
+          break;
+        case 'create':
+          logs.push(`${colors.green('CREATE')} ${eventPath} (${event.content.length} bytes)`);
+          files.add(eventPath);
+          break;
+        case 'delete':
+          logs.push(`${colors.yellow('DELETE')} ${eventPath}`);
+          files.add(eventPath);
+          break;
+        case 'rename':
+          logs.push(`${colors.blue('RENAME')} ${eventPath} => ${event.to}`);
+          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));
+        }
+      }
+    });
+
+    // TODO: Allow passing a schematic instance directly
+    try {
+      await this.workflow
+        .execute({
+          collection,
+          schematic,
+          options,
+          logger: this.logger,
+        })
+        .toPromise();
+
+      reporterSubscription.unsubscribe();
+      lifecycleSubscription.unsubscribe();
+
+      return { success: true, files };
+    } catch (e) {
+      if (e instanceof UnsuccessfulWorkflowExecution) {
+        this.logger.error('The update failed. See above.');
+      } else {
+        this.logger.fatal(e.message);
+      }
+
+      return { success: !error, files };
+    }
   }
 
   async executeMigrations(
@@ -41,11 +131,11 @@ export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
     range: semver.Range,
     commit = false,
   ) {
-    const collection = this.getEngine().createCollection(collectionPath);
+    const collection = this.workflow.engine.createCollection(collectionPath);
 
     const migrations = [];
     for (const name of collection.listSchematicNames()) {
-      const schematic = this.getEngine().createSchematic(name, collection);
+      const schematic = this.workflow.engine.createSchematic(name, collection);
       const description = schematic.description as typeof schematic.description & {
         version?: string;
       };
@@ -71,16 +161,8 @@ export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
         `** Executing migrations for version ${migration.version} of package '${packageName}' **`,
       );
 
-      // TODO: run the schematic directly; most of the logic in the following is unneeded
-      const result = await this.runSchematic({
-        collectionName: migration.collection.name,
-        schematicName: migration.name,
-        force: false,
-        showNothingDone: false,
-      });
-
-      // 1 = failure
-      if (result === 1) {
+      const result = await this.executeSchematic(migration.collection.name, migration.name);
+      if (!result.success) {
         if (startingGitSha !== null) {
           const currentGitSha = this.findCurrentGitSha();
           if (currentGitSha !== startingGitSha) {
@@ -97,7 +179,8 @@ export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
         if (migration.description) {
           message += '\n' + migration.description;
         }
-        this.createCommit([], message);
+        // TODO: Use result.files once package install tasks are accounted
+        this.createCommit(message, []);
       }
     }
   }
@@ -192,19 +275,15 @@ export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
 
     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,
-          verbose: options.verbose || false,
-          packageManager,
-          packages: options.all ? Object.keys(rootDependencies) : [],
-        },
+      const { success } = await this.executeSchematic('@schematics/update', 'update', {
+        force: options.force || false,
+        next: options.next || false,
+        verbose: options.verbose || false,
+        packageManager,
+        packages: options.all ? Object.keys(rootDependencies) : [],
       });
+
+      return success ? 0 : 1;
     }
 
     if (options.migrateOnly) {
@@ -408,18 +487,14 @@ export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
       return 0;
     }
 
-    return this.runSchematic({
-      collectionName: '@schematics/update',
-      schematicName: 'update',
-      dryRun: !!options.dryRun,
-      showNothingDone: false,
-      additionalOptions: {
-        verbose: options.verbose || false,
-        force: options.force || false,
-        packageManager,
-        packages: packagesToUpdate,
-      },
+    const { success } = await this.executeSchematic('@schematics/update', 'update', {
+      verbose: options.verbose || false,
+      force: options.force || false,
+      packageManager,
+      packages: packagesToUpdate,
     });
+
+    return success ? 0 : 1;
   }
 
   checkCleanGit() {
@@ -445,7 +520,7 @@ export class UpdateCommand extends SchematicCommand<UpdateCommandSchema> {
     return true;
   }
 
-  createCommit(files: string[], message: string) {
+  createCommit(message: string, files: string[]) {
     try {
       execSync('git add -A ' + files.join(' '), { encoding: 'utf8', stdio: 'pipe' });