wip: .

Author: Angular Builds

packages/angular_devkit/architect/builders/builders.json

@@ -2,22 +2,24 @@
   "$schema": "../src/builders-schema.json",
   "builders": {
     "true": {
-      "version": 2,
       "implementation": "./true",
       "schema": "./noop-schema.json",
       "description": "Always succeed."
     },
     "false": {
-      "version": 2,
       "implementation": "./false",
       "schema": "./noop-schema.json",
       "description": "Always fails."
     },
     "allOf": {
-      "version": 2,
       "implementation": "./all-of",
       "schema": "./operator-schema.json",
       "description": "A builder that executes many builders in parallel, and succeed if both succeeds."
+    },
+    "concat": {
+      "implementation": "./concat",
+      "schema": "./operator-schema.json",
+      "description": "A builder that executes many builders one after the other, and stops when one fail. It will succeed if all builders succeeds (and return the last output)"
     }
   }
 }

packages/angular_devkit/architect/builders/concat.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * 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 { json } from '@angular-devkit/core';
+import { from, of } from 'rxjs';
+import { concatMap, first, last, map, switchMap } from 'rxjs/operators';
+import { BuilderOutput, BuilderRun, createBuilder } from '../src';
+import { Schema as OperatorSchema } from './operator-schema';
+
+export default createBuilder<json.JsonObject & OperatorSchema>((options, context) => {
+  const allRuns: (() => Promise<BuilderRun>)[] = [];
+
+  context.progress(0,
+    (options.targets ? options.targets.length : 0)
+    + (options.builders ? options.builders.length : 0),
+  );
+
+
+  if (options.targets) {
+    allRuns.push(...options.targets.map(({ target: targetStr, overrides }) => {
+      const [project, target, configuration] = targetStr.split(/:/g, 3);
+
+      return () => context.scheduleTarget({ project, target, configuration }, overrides || {});
+    }));
+  }
+
+  if (options.builders) {
+    allRuns.push(...options.builders.map(({ builder, options }) => {
+      return () => context.scheduleBuilder(builder, options || {});
+    }));
+  }
+
+  let stop: BuilderOutput | null = null;
+  let i = 0;
+  context.progress(i++, allRuns.length);
+
+  return from(allRuns).pipe(
+    concatMap(fn => stop ? of(null) : from(fn()).pipe(
+      switchMap(run => run === null ? of(null) : run.output.pipe(first())),
+    )),
+    map(output => {
+      context.progress(i++, allRuns.length);
+      if (output === null || stop !== null) {
+        return stop || { success: false };
+      } else if (output.success === false) {
+        return stop = output;
+      } else {
+        return output;
+      }
+    }),
+    last(),
+  );
+});

packages/angular_devkit/architect/node/node-modules-architect-host.ts

@@ -8,12 +8,18 @@
 import { experimental, json } from '@angular-devkit/core';
 import { resolve } from '@angular-devkit/core/node';
 import * as path from 'path';
-import { ArchitectHost, BuilderInfo, BuilderJobHandler, BuilderSymbol } from '../src/api';
+import { ArchitectHost, BuilderInfo, BuilderJobHandler, BuilderSymbol } from '../src';
 import { Schema as BuilderSchema } from '../src/builders-schema';
 import { Target } from '../src/input-schema';
 
+
+export type NodeModulesBuilderInfo = BuilderInfo & {
+  import: string;
+};
+
+
 // TODO: create a base class for all workspace related hosts.
-export class WorkspaceNodeModulesArchitectHost implements ArchitectHost {
+export class WorkspaceNodeModulesArchitectHost implements ArchitectHost<NodeModulesBuilderInfo> {
   constructor(
     protected _workspace: experimental.workspace.Workspace,
     protected _root: string,
@@ -30,7 +36,7 @@ export class WorkspaceNodeModulesArchitectHost implements ArchitectHost {
    * @param builderStr The name of the builder to be used.
    * @returns All the info needed for the builder itself.
    */
-  resolveBuilder(builderStr: string): Promise<BuilderInfo> {
+  resolveBuilder(builderStr: string): Promise<NodeModulesBuilderInfo> {
     const [packageName, builderName] = builderStr.split(':', 2);
     if (!builderName) {
       throw new Error('No builder name specified.');
@@ -57,27 +63,25 @@ export class WorkspaceNodeModulesArchitectHost implements ArchitectHost {
       throw new Error(`Cannot find builder ${JSON.stringify(builderName)}.`);
     }
 
-    const importPath = builder.version == 2 ? builder.implementation : builder.class;
+    const importPath = builder.implementation;
     if (!importPath) {
       throw new Error('Invalid builder JSON');
     }
 
     return Promise.resolve({
       name: builderStr,
-      version: builder.version || 1,
-      packageName,
       builderName,
       description: builder['description'],
       optionSchema: require(path.resolve(path.dirname(builderJsonPath), builder.schema)),
       import: path.resolve(path.dirname(builderJsonPath), importPath),
     });
   }
 
-  getCurrentDirectory(): string {
+  async getCurrentDirectory() {
     return process.cwd();
   }
 
-  getWorkspaceRoot(): string {
+  async getWorkspaceRoot() {
     return this._root;
   }
 
@@ -93,7 +97,7 @@ export class WorkspaceNodeModulesArchitectHost implements ArchitectHost {
     };
   }
 
-  async loadBuilder(info: BuilderInfo): Promise<BuilderJobHandler> {
+  async loadBuilder(info: NodeModulesBuilderInfo): Promise<BuilderJobHandler> {
     const builder = (await import(info.import)).default;
     if (builder[BuilderSymbol]) {
       return builder.handler;