wip: .

Author: hansl

packages/angular_devkit/architect/builders/builders.json

@@ -1,20 +1,22 @@
 {
-  "$schema": "../architect/src/builders-schema.json",
-  "version": 2,
+  "$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."
     },
     "and": {
+      "version": 2,
       "implementation": "./and",
-      "schema": "./and-schema.json",
+      "schema": "./operator-schema.json",
       "description": "A builder that executes many builders in parallel, and succeed if both succeeds."
     }
   }

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

@@ -8,7 +8,7 @@
 import { experimental, json } from '@angular-devkit/core';
 import { resolve } from '@angular-devkit/core/node';
 import * as path from 'path';
-import { ArchitectHost, BuilderInfo } from '../src/api';
+import { ArchitectHost, BuilderInfo, BuilderJobHandler, BuilderSymbol } from '../src/api';
 import { Schema as BuilderSchema } from '../src/builders-schema';
 import { Target } from '../src/input-schema';
 
@@ -51,7 +51,7 @@ export class WorkspaceNodeModulesArchitectHost implements ArchitectHost {
     const builderJsonPath = path.resolve(path.dirname(packageJsonPath), packageJson['builders']);
     const builderJson = require(builderJsonPath) as BuilderSchema;
 
-    const builder = builderJson.builders[builderName];
+    const builder = builderJson.builders && builderJson.builders[builderName];
 
     if (!builder) {
       throw new Error('Cannot find builder.');
@@ -92,4 +92,13 @@ export class WorkspaceNodeModulesArchitectHost implements ArchitectHost {
       ...(target.configuration ? targetSpec['configurations'][target.configuration] : 0),
     };
   }
+
+  async loadBuilder(info: BuilderInfo): Promise<BuilderJobHandler> {
+    const builder = (await import(info.import)).default;
+    if (builder[BuilderSymbol]) {
+      return builder.handler;
+    }
+
+    throw new Error('Builder is not a builder');
+  }
 }

packages/angular_devkit/architect/src/api.ts

@@ -6,14 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { experimental, isPromise, json, logging } from '@angular-devkit/core';
-import { Observable, from, isObservable, of } from 'rxjs';
+import { Observable, from, isObservable, of, Observer } from 'rxjs';
 import { concatMap, first, map, shareReplay, switchMap, tap } from 'rxjs/operators';
-import { JobInboundMessageKind, JobOutboundMessageKind } from '../../core/src/experimental/jobs';
-import { Schema as RealBuilderInput, Target } from './input-schema';
+import { JobInboundMessageKind } from '../../core/src/experimental/jobs';
+import { Schema as RealBuilderInput, Target as RealTarget } from './input-schema';
 import { Schema as RealBuilderOutput } from './output-schema';
-import { Schema as RealBuilderProgress } from './progress-schema';
+import { Schema as RealBuilderProgress, State as BuilderProgressState } from './progress-schema';
 
-export type Target = Target;
+export type Target = json.JsonObject & RealTarget;
 
 // Type short hands.
 export type BuilderJobHandler<
@@ -27,9 +27,15 @@ export type BuilderRegistry<
   O extends BuilderOutput = BuilderOutput,
 > = experimental.jobs.Registry<A, I, O>;
 
+export type TypedBuilderProgress =
+    { state: BuilderProgressState.Stopped }
+  | { state: BuilderProgressState.Error; error: json.JsonValue; }
+  | { state: BuilderProgressState.Waiting; status?: string; }
+  | { state: BuilderProgressState.Running; status?: string; current: number; total?: number; }
+
 export type BuilderInput = json.JsonObject & RealBuilderInput;
 export type BuilderOutput = json.JsonObject & RealBuilderOutput;
-export type BuilderProgress = json.JsonObject & RealBuilderProgress;
+export type BuilderProgress = RealBuilderProgress & TypedBuilderProgress;
 
 const inputSchema = require('./input-schema.json');
 const outputSchema = require('./output-schema.json');
@@ -55,7 +61,7 @@ export const VersionSymbol = Symbol.for('@angular-devkit/architect:version');
 
 
 export interface Builder<OptionT extends json.JsonObject> {
-  handler: experimental.jobs.JobHandler<boolean, BuilderInput, BuilderOutput>;
+  handler: experimental.jobs.JobHandler<json.JsonObject, BuilderInput, BuilderOutput>;
   [BuilderSymbol]: true;
   [VersionSymbol]: string;
 }
@@ -79,7 +85,7 @@ export interface BuilderContext {
   // dependencies?: BuilderRun[];
 
   // bep: Observer<BuildEventMessage>
-  // progress: Observer<{ current: number; total: number }>;
+  progress(progress: BuilderProgress): void;
 
   // building: () => void;
 }
@@ -122,6 +128,8 @@ export interface ArchitectHost {
   getWorkspaceRoot(): string;
 
   getOptionsForTarget(target: Target): Promise<json.JsonObject>;
+
+  loadBuilder(info: BuilderInfo): Promise<BuilderJobHandler>;
 }
 
 /**
@@ -154,11 +162,17 @@ async function _scheduleTarget(
           reason: 'initial',
           options: overrides,
           target,
-        } as BuilderInput);
+        });
       }
     });
   } else {
-
+    job.input.next({
+      currentDirectory: options.workspaceRoot,
+      workspaceRoot: options.currentDirectory,
+      reason: 'schedule',
+      options: overrides,
+      target,
+    });
   }
 
   job.outboundBus.subscribe(
@@ -181,70 +195,42 @@ async function _scheduleTarget(
 export function createBuilder<OptT extends json.JsonObject>(
   fn: BuilderHandlerFn<OptT>,
 ): Builder<OptT> {
-  function handler(
-    options: boolean,
-    context: experimental.jobs.JobHandlerContext<boolean, BuilderInput, BuilderOutput>,
-  ) {
-    const description = context.description;
+  const cjh = experimental.jobs.createJobHandler;
+  const handler = cjh<json.JsonObject, BuilderInput, BuilderOutput>((options, context) => {
     const scheduler = context.scheduler;
-
-    return new Observable<experimental.jobs.JobOutboundMessage<BuilderOutput>>(observer => {
-      const logger = new logging.Logger('job');
-      logger.subscribe(entry => {
-        observer.next({
-          kind: JobOutboundMessageKind.Log,
-          description,
-          entry,
-        });
-      });
-
-      context.inboundBus.subscribe(x => {
-        if (x.kind === experimental.jobs.JobInboundMessageKind.Input) {
-          const i = x.value;
-          const context: BuilderContext = {
-            workspaceRoot: i.workspaceRoot,
-            currentDirectory: i.currentDirectory,
-            target: i.target,
-            logger,
-            scheduleTarget(target: Target, overrides: json.JsonObject) {
-              return _scheduleTarget(target, overrides, scheduler, {
-                logger,
-                workspaceRoot: i.workspaceRoot,
-                currentDirectory: i.currentDirectory,
-              });
-            },
-          };
-
-          let result = fn(i.options as OptT, context);
-
-          if (isPromise(result)) {
-            result = from(result);
-          } else if (!isObservable(result)) {
-            result = of(result);
-          }
-
-          result.subscribe(
-            value => observer.next({
-              kind: experimental.jobs.JobOutboundMessageKind.Output,
-              description,
-              value,
-            }),
-            err => observer.error(err),
-            () => observer.complete(),
-          );
+    const logger = context.logger;
+
+    return new Observable<BuilderOutput>(observer => {
+      context.input.subscribe(i => {
+        const context: BuilderContext = {
+          workspaceRoot: i.workspaceRoot,
+          currentDirectory: i.currentDirectory,
+          target: i.target as Target,
+          logger: logger,
+          scheduleTarget(target: Target, overrides: json.JsonObject) {
+            return _scheduleTarget(target, overrides, scheduler, {
+              logger: logger.createChild(''),
+              workspaceRoot: i.workspaceRoot,
+              currentDirectory: i.currentDirectory,
+            });
+          },
+        };
+
+        let result = fn(i.options as OptT, context);
+
+        if (isPromise(result)) {
+          result = from(result);
+        } else if (!isObservable(result)) {
+          result = of(result);
         }
-      });
 
-      // The job is ready to listen.
-      observer.next({
-        description,
-        kind: experimental.jobs.JobOutboundMessageKind.Start,
+        return result.subscribe(observer);
       });
     });
-  }
+  });
 
   return {
-    handler: Object.assign(handler, { jobDescription: {} }),
+    handler,
     [BuilderSymbol]: true,
     [VersionSymbol]: require('../package.json').version,
   };
@@ -253,6 +239,7 @@ export function createBuilder<OptT extends json.JsonObject>(
 function _createBackwardCompatibleJobHandlerFromBuilderInfo(
   info: BuilderInfo,
   target: Target | undefined,
+  host: ArchitectHost,
   registry: json.schema.SchemaRegistry,
   baseOptions: json.JsonObject,
 ): Observable<BuilderJobHandler | null> {
@@ -263,6 +250,7 @@ function _createBackwardCompatibleJobHandlerFromBuilderInfo(
       return from(module.createBackwardCompatibleJobHandlerFromBuilderInfo(
         info,
         target,
+        host,
         registry,
         baseOptions,
       ));
@@ -273,6 +261,7 @@ function _createBackwardCompatibleJobHandlerFromBuilderInfo(
 function _createJobHandlerFromBuilderInfo(
   info: BuilderInfo,
   _target: Target | undefined,
+  host: ArchitectHost,
   registry: json.schema.SchemaRegistry,
   baseOptions: json.JsonObject,
 ): Observable<BuilderJobHandler> {
@@ -284,15 +273,6 @@ function _createJobHandlerFromBuilderInfo(
     info,
   };
 
-  const loader = async () => {
-    const builder = (await import(info.import)).default;
-    if (builder[BuilderSymbol]) {
-      return builder.handler;
-    }
-
-    throw new Error('Builder is not a builder');
-  };
-
   function handler(argument: json.JsonObject, context: experimental.jobs.JobHandlerContext) {
     const inboundBus = context.inboundBus.pipe(
       concatMap(message => {
@@ -323,7 +303,7 @@ function _createJobHandlerFromBuilderInfo(
       }),
     );
 
-    return from(loader()).pipe(
+    return from(host.loadBuilder(info)).pipe(
       switchMap(fn => fn(argument, { ...context, inboundBus })),
     );
   }
@@ -372,10 +352,17 @@ export class ArchitectBuilderJobRegistry implements BuilderRegistry {
       result = _createBackwardCompatibleJobHandlerFromBuilderInfo(
         info,
         target,
+        this._host,
         this._registry,
         options || {});
     } else {
-      result = _createJobHandlerFromBuilderInfo(info, target, this._registry, options || {});
+      result = _createJobHandlerFromBuilderInfo(
+        info,
+        target,
+        this._host,
+        this._registry,
+        options || {},
+      );
     }
 
     if (cache) {

packages/angular_devkit/architect/src/backward-compatible.ts

@@ -20,6 +20,7 @@ import * as fs from 'fs';
 import { Observable, concat, from, of } from 'rxjs';
 import { concatMap, ignoreElements, map, mergeMap, switchMap, tap } from 'rxjs/operators';
 import {
+  ArchitectHost,
   BuilderDescription,
   BuilderInfo,
   BuilderInput,
@@ -73,6 +74,7 @@ class BackwardCompatibleArchitect implements ArchitectPublicInterface {
     private _workspace: experimental.workspace.Workspace,
     private _root: Path,
     private _scheduler: experimental.jobs.Scheduler,
+    private _host: ArchitectHost,
   ) {}
 
   asArchitect() {
@@ -107,7 +109,6 @@ class BackwardCompatibleArchitect implements ArchitectPublicInterface {
             const info = (desc as BuilderDescription).info;
 
             const builderModule = require(info.import);
-            // tslint:disable-next-line:no-non-null-assertion
             this._builderConstructorMap.set(builderName, builderModule['default']);
           }),
         );
@@ -251,6 +252,7 @@ class BackwardCompatibleArchitect implements ArchitectPublicInterface {
 export async function createBackwardCompatibleJobHandlerFromBuilderInfo(
   info: BuilderInfo,
   target: Target | undefined,
+  architectHost: ArchitectHost,
   registry: json.schema.SchemaRegistry,
   baseOptions: json.JsonObject,
 ): Promise<BuilderJobHandler> {
@@ -296,6 +298,7 @@ export async function createBackwardCompatibleJobHandlerFromBuilderInfo(
           workspace,
           root,
           context.scheduler,
+          architectHost,
         ) as {} as legacy.Architect;
 
         instance = new ClassImpl({