@angular-devkit/architect 0.1500.0-next.4 → 0.1500.0-next.5

package/src/jobs/simple-scheduler.js

@@ -0,0 +1,382 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleScheduler = exports.JobOutputSchemaValidationError = exports.JobInboundMessageSchemaValidationError = exports.JobArgumentSchemaValidationError = void 0;
+const core_1 = require("@angular-devkit/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const api_1 = require("./api");
+const exception_1 = require("./exception");
+class JobArgumentSchemaValidationError extends core_1.schema.SchemaValidationException {
+    constructor(errors) {
+        super(errors, 'Job Argument failed to validate. Errors: ');
+    }
+}
+exports.JobArgumentSchemaValidationError = JobArgumentSchemaValidationError;
+class JobInboundMessageSchemaValidationError extends core_1.schema.SchemaValidationException {
+    constructor(errors) {
+        super(errors, 'Job Inbound Message failed to validate. Errors: ');
+    }
+}
+exports.JobInboundMessageSchemaValidationError = JobInboundMessageSchemaValidationError;
+class JobOutputSchemaValidationError extends core_1.schema.SchemaValidationException {
+    constructor(errors) {
+        super(errors, 'Job Output failed to validate. Errors: ');
+    }
+}
+exports.JobOutputSchemaValidationError = JobOutputSchemaValidationError;
+function _jobShare() {
+    // This is the same code as a `shareReplay()` operator, but uses a dumber Subject rather than a
+    // ReplaySubject.
+    return (source) => {
+        let refCount = 0;
+        let subject;
+        let hasError = false;
+        let isComplete = false;
+        let subscription;
+        return new rxjs_1.Observable((subscriber) => {
+            let innerSub;
+            refCount++;
+            if (!subject) {
+                subject = new rxjs_1.Subject();
+                innerSub = subject.subscribe(subscriber);
+                subscription = source.subscribe({
+                    next(value) {
+                        subject.next(value);
+                    },
+                    error(err) {
+                        hasError = true;
+                        subject.error(err);
+                    },
+                    complete() {
+                        isComplete = true;
+                        subject.complete();
+                    },
+                });
+            }
+            else {
+                innerSub = subject.subscribe(subscriber);
+            }
+            return () => {
+                refCount--;
+                innerSub.unsubscribe();
+                if (subscription && refCount === 0 && (isComplete || hasError)) {
+                    subscription.unsubscribe();
+                }
+            };
+        });
+    };
+}
+/**
+ * Simple scheduler. Should be the base of all registries and schedulers.
+ */
+class SimpleScheduler {
+    constructor(_jobRegistry, _schemaRegistry = new core_1.schema.CoreSchemaRegistry()) {
+        this._jobRegistry = _jobRegistry;
+        this._schemaRegistry = _schemaRegistry;
+        this._internalJobDescriptionMap = new Map();
+        this._queue = [];
+        this._pauseCounter = 0;
+    }
+    _getInternalDescription(name) {
+        const maybeHandler = this._internalJobDescriptionMap.get(name);
+        if (maybeHandler !== undefined) {
+            return (0, rxjs_1.of)(maybeHandler);
+        }
+        const handler = this._jobRegistry.get(name);
+        return handler.pipe((0, operators_1.switchMap)((handler) => {
+            if (handler === null) {
+                return (0, rxjs_1.of)(null);
+            }
+            const description = {
+                // Make a copy of it to be sure it's proper JSON.
+                ...JSON.parse(JSON.stringify(handler.jobDescription)),
+                name: handler.jobDescription.name || name,
+                argument: handler.jobDescription.argument || true,
+                input: handler.jobDescription.input || true,
+                output: handler.jobDescription.output || true,
+                channels: handler.jobDescription.channels || {},
+            };
+            const handlerWithExtra = Object.assign(handler.bind(undefined), {
+                jobDescription: description,
+                argumentV: this._schemaRegistry.compile(description.argument).pipe((0, operators_1.shareReplay)(1)),
+                inputV: this._schemaRegistry.compile(description.input).pipe((0, operators_1.shareReplay)(1)),
+                outputV: this._schemaRegistry.compile(description.output).pipe((0, operators_1.shareReplay)(1)),
+            });
+            this._internalJobDescriptionMap.set(name, handlerWithExtra);
+            return (0, rxjs_1.of)(handlerWithExtra);
+        }));
+    }
+    /**
+     * Get a job description for a named job.
+     *
+     * @param name The name of the job.
+     * @returns A description, or null if the job is not registered.
+     */
+    getDescription(name) {
+        return (0, rxjs_1.concat)(this._getInternalDescription(name).pipe((0, operators_1.map)((x) => x && x.jobDescription)), (0, rxjs_1.of)(null)).pipe((0, operators_1.first)());
+    }
+    /**
+     * Returns true if the job name has been registered.
+     * @param name The name of the job.
+     * @returns True if the job exists, false otherwise.
+     */
+    has(name) {
+        return this.getDescription(name).pipe((0, operators_1.map)((x) => x !== null));
+    }
+    /**
+     * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be
+     * used to resume execution. If multiple `pause()` were called, all their resume functions must
+     * be called before the Scheduler actually starts new jobs. Additional calls to the same resume
+     * function will have no effect.
+     *
+     * Jobs already running are NOT paused. This is pausing the scheduler only.
+     */
+    pause() {
+        let called = false;
+        this._pauseCounter++;
+        return () => {
+            if (!called) {
+                called = true;
+                if (--this._pauseCounter == 0) {
+                    // Resume the queue.
+                    const q = this._queue;
+                    this._queue = [];
+                    q.forEach((fn) => fn());
+                }
+            }
+        };
+    }
+    /**
+     * Schedule a job to be run, using its name.
+     * @param name The name of job to be run.
+     * @param argument The argument to send to the job when starting it.
+     * @param options Scheduling options.
+     * @returns The Job being run.
+     */
+    schedule(name, argument, options) {
+        if (this._pauseCounter > 0) {
+            const waitable = new rxjs_1.Subject();
+            this._queue.push(() => waitable.complete());
+            return this._scheduleJob(name, argument, options || {}, waitable);
+        }
+        return this._scheduleJob(name, argument, options || {}, rxjs_1.EMPTY);
+    }
+    /**
+     * Filter messages.
+     * @private
+     */
+    _filterJobOutboundMessages(message, state) {
+        switch (message.kind) {
+            case api_1.JobOutboundMessageKind.OnReady:
+                return state == api_1.JobState.Queued;
+            case api_1.JobOutboundMessageKind.Start:
+                return state == api_1.JobState.Ready;
+            case api_1.JobOutboundMessageKind.End:
+                return state == api_1.JobState.Started || state == api_1.JobState.Ready;
+        }
+        return true;
+    }
+    /**
+     * Return a new state. This is just to simplify the reading of the _createJob method.
+     * @private
+     */
+    _updateState(message, state) {
+        switch (message.kind) {
+            case api_1.JobOutboundMessageKind.OnReady:
+                return api_1.JobState.Ready;
+            case api_1.JobOutboundMessageKind.Start:
+                return api_1.JobState.Started;
+            case api_1.JobOutboundMessageKind.End:
+                return api_1.JobState.Ended;
+        }
+        return state;
+    }
+    /**
+     * Create the job.
+     * @private
+     */
+    _createJob(name, argument, handler, inboundBus, outboundBus) {
+        const schemaRegistry = this._schemaRegistry;
+        const channelsSubject = new Map();
+        const channels = new Map();
+        let state = api_1.JobState.Queued;
+        let pingId = 0;
+        // Create the input channel by having a filter.
+        const input = new rxjs_1.Subject();
+        input
+            .pipe((0, operators_1.concatMap)((message) => handler.pipe((0, operators_1.switchMap)((handler) => {
+            if (handler === null) {
+                throw new exception_1.JobDoesNotExistException(name);
+            }
+            else {
+                return handler.inputV.pipe((0, operators_1.switchMap)((validate) => validate(message)));
+            }
+        }))), (0, operators_1.filter)((result) => result.success), (0, operators_1.map)((result) => result.data))
+            .subscribe((value) => inboundBus.next({ kind: api_1.JobInboundMessageKind.Input, value }));
+        outboundBus = (0, rxjs_1.concat)(outboundBus, 
+        // Add an End message at completion. This will be filtered out if the job actually send an
+        // End.
+        handler.pipe((0, operators_1.switchMap)((handler) => {
+            if (handler) {
+                return (0, rxjs_1.of)({
+                    kind: api_1.JobOutboundMessageKind.End,
+                    description: handler.jobDescription,
+                });
+            }
+            else {
+                return rxjs_1.EMPTY;
+            }
+        }))).pipe((0, operators_1.filter)((message) => this._filterJobOutboundMessages(message, state)), 
+        // Update internal logic and Job<> members.
+        (0, operators_1.tap)((message) => {
+            // Update the state.
+            state = this._updateState(message, state);
+            switch (message.kind) {
+                case api_1.JobOutboundMessageKind.ChannelCreate: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    // If it doesn't exist or it's closed on the other end.
+                    if (!maybeSubject) {
+                        const s = new rxjs_1.Subject();
+                        channelsSubject.set(message.name, s);
+                        channels.set(message.name, s.asObservable());
+                    }
+                    break;
+                }
+                case api_1.JobOutboundMessageKind.ChannelMessage: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    if (maybeSubject) {
+                        maybeSubject.next(message.message);
+                    }
+                    break;
+                }
+                case api_1.JobOutboundMessageKind.ChannelComplete: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    if (maybeSubject) {
+                        maybeSubject.complete();
+                        channelsSubject.delete(message.name);
+                    }
+                    break;
+                }
+                case api_1.JobOutboundMessageKind.ChannelError: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    if (maybeSubject) {
+                        maybeSubject.error(message.error);
+                        channelsSubject.delete(message.name);
+                    }
+                    break;
+                }
+            }
+        }, () => {
+            state = api_1.JobState.Errored;
+        }), 
+        // Do output validation (might include default values so this might have side
+        // effects). We keep all messages in order.
+        (0, operators_1.concatMap)((message) => {
+            if (message.kind !== api_1.JobOutboundMessageKind.Output) {
+                return (0, rxjs_1.of)(message);
+            }
+            return handler.pipe((0, operators_1.switchMap)((handler) => {
+                if (handler === null) {
+                    throw new exception_1.JobDoesNotExistException(name);
+                }
+                else {
+                    return handler.outputV.pipe((0, operators_1.switchMap)((validate) => validate(message.value)), (0, operators_1.switchMap)((output) => {
+                        if (!output.success) {
+                            throw new JobOutputSchemaValidationError(output.errors);
+                        }
+                        return (0, rxjs_1.of)({
+                            ...message,
+                            output: output.data,
+                        });
+                    }));
+                }
+            }));
+        }), _jobShare());
+        const output = outboundBus.pipe((0, operators_1.filter)((x) => x.kind == api_1.JobOutboundMessageKind.Output), (0, operators_1.map)((x) => x.value), (0, operators_1.shareReplay)(1));
+        // Return the Job.
+        return {
+            get state() {
+                return state;
+            },
+            argument,
+            description: handler.pipe((0, operators_1.switchMap)((handler) => {
+                if (handler === null) {
+                    throw new exception_1.JobDoesNotExistException(name);
+                }
+                else {
+                    return (0, rxjs_1.of)(handler.jobDescription);
+                }
+            })),
+            output,
+            getChannel(name, schema = true) {
+                let maybeObservable = channels.get(name);
+                if (!maybeObservable) {
+                    const s = new rxjs_1.Subject();
+                    channelsSubject.set(name, s);
+                    channels.set(name, s.asObservable());
+                    maybeObservable = s.asObservable();
+                }
+                return maybeObservable.pipe(
+                // Keep the order of messages.
+                (0, operators_1.concatMap)((message) => {
+                    return schemaRegistry.compile(schema).pipe((0, operators_1.switchMap)((validate) => validate(message)), (0, operators_1.filter)((x) => x.success), (0, operators_1.map)((x) => x.data));
+                }));
+            },
+            ping() {
+                const id = pingId++;
+                inboundBus.next({ kind: api_1.JobInboundMessageKind.Ping, id });
+                return outboundBus.pipe((0, operators_1.filter)((x) => x.kind === api_1.JobOutboundMessageKind.Pong && x.id == id), (0, operators_1.first)(), (0, operators_1.ignoreElements)());
+            },
+            stop() {
+                inboundBus.next({ kind: api_1.JobInboundMessageKind.Stop });
+            },
+            input,
+            inboundBus,
+            outboundBus,
+        };
+    }
+    _scheduleJob(name, argument, options, waitable) {
+        // Get handler first, since this can error out if there's no handler for the job name.
+        const handler = this._getInternalDescription(name);
+        const optionsDeps = (options && options.dependencies) || [];
+        const dependencies = Array.isArray(optionsDeps) ? optionsDeps : [optionsDeps];
+        const inboundBus = new rxjs_1.Subject();
+        const outboundBus = (0, rxjs_1.concat)(
+        // Wait for dependencies, make sure to not report messages from dependencies. Subscribe to
+        // all dependencies at the same time so they run concurrently.
+        (0, rxjs_1.merge)(...dependencies.map((x) => x.outboundBus)).pipe((0, operators_1.ignoreElements)()), 
+        // Wait for pause() to clear (if necessary).
+        waitable, (0, rxjs_1.from)(handler).pipe((0, operators_1.switchMap)((handler) => new rxjs_1.Observable((subscriber) => {
+            if (!handler) {
+                throw new exception_1.JobDoesNotExistException(name);
+            }
+            // Validate the argument.
+            return handler.argumentV
+                .pipe((0, operators_1.switchMap)((validate) => validate(argument)), (0, operators_1.switchMap)((output) => {
+                if (!output.success) {
+                    throw new JobArgumentSchemaValidationError(output.errors);
+                }
+                const argument = output.data;
+                const description = handler.jobDescription;
+                subscriber.next({ kind: api_1.JobOutboundMessageKind.OnReady, description });
+                const context = {
+                    description,
+                    dependencies: [...dependencies],
+                    inboundBus: inboundBus.asObservable(),
+                    scheduler: this,
+                };
+                return handler(argument, context);
+            }))
+                .subscribe(subscriber);
+        }))));
+        return this._createJob(name, argument, handler, inboundBus, outboundBus);
+    }
+}
+exports.SimpleScheduler = SimpleScheduler;

package/src/jobs/strategy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright Google LLC 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 { JsonValue } from '@angular-devkit/core';
+import { JobDescription, JobHandler } from './api';
+export declare namespace strategy {
+    type JobStrategy<A extends JsonValue = JsonValue, I extends JsonValue = JsonValue, O extends JsonValue = JsonValue> = (handler: JobHandler<A, I, O>, options?: Partial<Readonly<JobDescription>>) => JobHandler<A, I, O>;
+    /**
+     * Creates a JobStrategy that serializes every call. This strategy can be mixed between jobs.
+     */
+    function serialize<A extends JsonValue = JsonValue, I extends JsonValue = JsonValue, O extends JsonValue = JsonValue>(): JobStrategy<A, I, O>;
+    /**
+     * Creates a JobStrategy that will always reuse a running job, and restart it if the job ended.
+     * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
+     * is.
+     */
+    function reuse<A extends JsonValue = JsonValue, I extends JsonValue = JsonValue, O extends JsonValue = JsonValue>(replayMessages?: boolean): JobStrategy<A, I, O>;
+    /**
+     * Creates a JobStrategy that will reuse a running job if the argument matches.
+     * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
+     * is.
+     */
+    function memoize<A extends JsonValue = JsonValue, I extends JsonValue = JsonValue, O extends JsonValue = JsonValue>(replayMessages?: boolean): JobStrategy<A, I, O>;
+}

package/src/jobs/strategy.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strategy = void 0;
+const core_1 = require("@angular-devkit/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const api_1 = require("./api");
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var strategy;
+(function (strategy) {
+    /**
+     * Creates a JobStrategy that serializes every call. This strategy can be mixed between jobs.
+     */
+    function serialize() {
+        let latest = (0, rxjs_1.of)();
+        return (handler, options) => {
+            const newHandler = (argument, context) => {
+                const previous = latest;
+                latest = (0, rxjs_1.concat)(previous.pipe((0, operators_1.ignoreElements)()), new rxjs_1.Observable((o) => handler(argument, context).subscribe(o))).pipe((0, operators_1.shareReplay)(0));
+                return latest;
+            };
+            return Object.assign(newHandler, {
+                jobDescription: Object.assign({}, handler.jobDescription, options),
+            });
+        };
+    }
+    strategy.serialize = serialize;
+    /**
+     * Creates a JobStrategy that will always reuse a running job, and restart it if the job ended.
+     * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
+     * is.
+     */
+    function reuse(replayMessages = false) {
+        let inboundBus = new rxjs_1.Subject();
+        let run = null;
+        let state = null;
+        return (handler, options) => {
+            const newHandler = (argument, context) => {
+                // Forward inputs.
+                const subscription = context.inboundBus.subscribe(inboundBus);
+                if (run) {
+                    return (0, rxjs_1.concat)(
+                    // Update state.
+                    (0, rxjs_1.of)(state), run).pipe((0, operators_1.finalize)(() => subscription.unsubscribe()));
+                }
+                run = handler(argument, { ...context, inboundBus: inboundBus.asObservable() }).pipe((0, operators_1.tap)((message) => {
+                    if (message.kind == api_1.JobOutboundMessageKind.Start ||
+                        message.kind == api_1.JobOutboundMessageKind.OnReady ||
+                        message.kind == api_1.JobOutboundMessageKind.End) {
+                        state = message;
+                    }
+                }, undefined, () => {
+                    subscription.unsubscribe();
+                    inboundBus = new rxjs_1.Subject();
+                    run = null;
+                }), replayMessages ? (0, operators_1.shareReplay)() : (0, operators_1.share)());
+                return run;
+            };
+            return Object.assign(newHandler, handler, options || {});
+        };
+    }
+    strategy.reuse = reuse;
+    /**
+     * Creates a JobStrategy that will reuse a running job if the argument matches.
+     * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
+     * is.
+     */
+    function memoize(replayMessages = false) {
+        const runs = new Map();
+        return (handler, options) => {
+            const newHandler = (argument, context) => {
+                const argumentJson = JSON.stringify((0, core_1.isJsonObject)(argument)
+                    ? Object.keys(argument)
+                        .sort()
+                        .reduce((result, key) => {
+                        result[key] = argument[key];
+                        return result;
+                    }, {})
+                    : argument);
+                const maybeJob = runs.get(argumentJson);
+                if (maybeJob) {
+                    return maybeJob;
+                }
+                const run = handler(argument, context).pipe(replayMessages ? (0, operators_1.shareReplay)() : (0, operators_1.share)());
+                runs.set(argumentJson, run);
+                return run;
+            };
+            return Object.assign(newHandler, handler, options || {});
+        };
+    }
+    strategy.memoize = memoize;
+})(strategy = exports.strategy || (exports.strategy = {}));

package/src/jobs/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+export declare type DeepReadonly<T> = T extends (infer R)[] ? DeepReadonlyArray<R> : T extends Function ? T : T extends object ? DeepReadonlyObject<T> : T;
+export declare type DeepReadonlyArray<T> = Array<DeepReadonly<T>>;
+export declare type DeepReadonlyObject<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+export declare type Readwrite<T> = {
+    -readonly [P in keyof T]: T[P];
+};

package/src/jobs/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/schedule-by-name.d.ts

@@ -5,20 +5,19 @@
  * 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 { analytics, experimental, json, logging } from '@angular-devkit/core';
+import { json, logging } from '@angular-devkit/core';
 import { BuilderRun, Target } from './api';
+import { Scheduler } from './jobs';
 export declare function scheduleByName(name: string, buildOptions: json.JsonObject, options: {
     target?: Target;
-    scheduler: experimental.jobs.Scheduler;
+    scheduler: Scheduler;
     logger: logging.LoggerApi;
     workspaceRoot: string | Promise<string>;
     currentDirectory: string | Promise<string>;
-    analytics?: analytics.Analytics;
 }): Promise<BuilderRun>;
 export declare function scheduleByTarget(target: Target, overrides: json.JsonObject, options: {
-    scheduler: experimental.jobs.Scheduler;
+    scheduler: Scheduler;
     logger: logging.LoggerApi;
     workspaceRoot: string | Promise<string>;
     currentDirectory: string | Promise<string>;
-    analytics?: analytics.Analytics;
 }): Promise<BuilderRun>;

package/src/schedule-by-name.js

@@ -8,10 +8,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scheduleByTarget = exports.scheduleByName = void 0;
-const core_1 = require("@angular-devkit/core");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const api_1 = require("./api");
+const jobs_1 = require("./jobs");
 const progressSchema = require('./progress-schema.json');
 let _uniqueId = 0;
 async function scheduleByName(name, buildOptions, options) {
@@ -33,9 +33,9 @@ async function scheduleByName(name, buildOptions, options) {
         ...(options.target ? { target: options.target } : {}),
     };
     // Wait for the job to be ready.
-    if (job.state !== core_1.experimental.jobs.JobState.Started) {
+    if (job.state !== jobs_1.JobState.Started) {
         stateSubscription = job.outboundBus.subscribe((event) => {
-            if (event.kind === core_1.experimental.jobs.JobOutboundMessageKind.Start) {
+            if (event.kind === jobs_1.JobOutboundMessageKind.Start) {
                 job.input.next(message);
             }
         }, () => { });
@@ -61,13 +61,6 @@ async function scheduleByName(name, buildOptions, options) {
         ...(options.target ? { target: options.target } : 0),
         info,
     })), (0, operators_1.shareReplay)());
-    // If there's an analytics object, take the job channel and report it to the analytics.
-    if (options.analytics) {
-        const reporter = new core_1.analytics.AnalyticsReporter(options.analytics);
-        job
-            .getChannel('analytics')
-            .subscribe((report) => reporter.report(report));
-    }
     // Start the builder.
     output.pipe((0, operators_1.first)()).subscribe({
         error() { },