@angular-devkit/core 7.2.0-beta.1 → 7.2.1

package/src/experimental/jobs/architecture.md

@@ -0,0 +1,257 @@
+
+# Overview
+Jobs is a high-order API that adds inputs, runtime type checking, sequencing, and other
+functionality on top of RxJS' `Observable`s.
+
+# Background
+An `Observable` (at a higher level) is a function that receives a `Subscriber`, and outputs
+multiple values, and finishes once it calls the `Subscriber.prototype.complete()` method (in
+JavaScript):
+
+```javascript
+const output1To10EverySecond = function (subscriber) {
+  let t = 0;
+  const i = setInterval(() => {
+    t++;
+    subscriber.next(t);
+    if (t === 10) {
+      subscriber.complete(t);
+    }
+  }, 1000);
+  return () => clearInterval(i);
+};
+
+const stream$ = new Observable(output1To10EverySecond);
+// Start the function, and output 1 to 100, once per line.
+stream$.subscribe(x => console.log(x));
+```
+
+This, of course, can be typed in TypeScript, but those types are not enforced at runtime.
+
+# Glossary
+- `job handler`. The function that implements the job's logic.
+- `raw input`. The input observable sending messages to the job. These messages are of type
+    `JobInboundMessage`.
+- `raw output`. The output observer returned from the `job handler`. Messages on this observable
+    are of type `JobOutboundMessage`.
+
+# Description
+
+A `JobHandler`, similar to observables, is a function that receives an argument and a context, and
+returns an `Observable` of messages, which can include outputs that are typed at runtime (using a
+Json Schema):
+
+```javascript
+const output1ToXEverySecond = function (x, context) {
+  return new Observable(subscriber => {
+    let t = 0;
+
+    // Notify our users that the actual work is started.
+    subscriber.next({ kind: JobOutboundMessageKind.Start });
+    const i = setInterval(() => {
+      t++;
+      subscriber.next({ kind: JobOutboundMessageKind.Output, value: t });
+      if (t === x) {
+        subscriber.next({ kind: JobOutboundMessageKind.End });
+        subscriber.complete();
+      }
+    }, 1000);
+
+    return () => {
+      clearInterval(i);
+    };
+  })
+};
+
+// For now, jobs can not be called without a registry and scheduler.
+const registry = new SimpleJobRegistry();
+registry.register('output-from-1-to-x', output1ToXEverySecond, {
+  argument: { type: 'number' },
+  output: { type: 'number' },
+});
+const scheduler = new SimpleScheduler(registry);
+
+// Need to keep the same name that the registry would understand.
+// Count from 1 to 10.
+const job = scheduler.schedule('output-from-1-to-x', 10);
+
+// A Job<> instance has more members, but we only want the output values here.
+job.output.subscribe(x => console.log(x));
+```
+
+This seems like a lot of boilerplate in comparison, but there are a few advantages;
+
+1. lifecycle. Jobs can tell when they start doing work and when work is done.
+1. everything is typed, even at runtime.
+1. the context also contains an input Observable that receives typed input messages, including
+    input values, and stop requests.
+1. jobs can also schedule other jobs and wait for them, even if they don't know if a job is
+    implemented in the system.
+
+## Diagram
+A simpler way to think about jobs in contrast to observables is that job are closer to a Unix
+process. It has an argument (command line flags), receive inputs (STDIN and interupt signals),
+and output values (STDOUT) as well as diagnostic (STDERR). They can be plugged one into another
+(piping), and can be transformed, synchronized and scheduled (fork, exec, cron).
+
+```plain
+- given A the type of the argument
+- given I the type of the input
+- given O the type of the output
+
+                              ,______________________   
+    JobInboundMessage<I> --> | handler(argument: A) |  --> JobOutboundMessage<O>
+                              `⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻       - JobOutboundMessageKind.Log
+                                                            - JobOutboundMessageKind.Output
+                                                            - ...
+```
+
+`JobInboundMessage` includes:
+
+1. `JobInboundMessageKind.Ping`. A simple message that should be answered with
+    `JobOutboundMessageKind.Pong` when the job is responsive. The `id` field of the message should
+    be used when returning `Pong`.
+1. `JobInboundMessageKind.Stop`. The job should be stopped. This is used when
+    cancelling/unsubscribing from the `output` (or by calling `stop()`). Any inputs or outputs
+    after this message will be ignored.
+1. `JobInboundMessageKind.Input` is used when sending inputs to a job. These correspond to the
+    `next` methods of an `Observer` and are reported to the job through its `context.input`
+    Observable. There is no way to communicate an error to the job.
+
+`JobOutboundMessage` includes:
+
+1. `JobOutboundMessageKind.Ready`. The `Job<>` was created, its dependencies are done, and the
+    library is validating Argument and calling the internal job code.
+1. `JobOutboundMessageKind.Start`. The job code itself should send that message when started.
+    `createJobHandler()` will do it automatically.
+1. `JobOutboundMessageKind.End`. The job has ended. This is done by the job itself and should
+    always be sent when completed. The scheduler will listen to this message to set the state and
+    unblock dependent jobs. `createJobHandler()` automatically send this message.
+1. `JobOutboundMessageKind.Pong`. The job should answer a `JobInboundMessageKind.Ping` message with
+    this. Automatically done by `createJobHandler()`.
+1. `JobOutboundMessageKind.Log`. A logging message (side effect that should be shown to the user).
+1. `JobOutboundMessageKind.Output`. An `Output` has been generated by the job.
+1. `JobOutboundMessageKind.ChannelMessage`, `JobOutboundMessageKind.ChannelError` and
+    `JobOutboundMessageKind.ChannelComplete` are used for output channels. These correspond to
+    the `next`, `error` and `complete` methods of an `Observer` and are available to the callee
+    through the `job.channels` map of Observable.
+
+Utilities should have some filtering and dispatching to separate observables, as a convenience for
+the user. An example of this would be the `Job.prototype.output` observable which only contains
+the value contained by messages of type `JobOutboundMessageKind.Output`.
+
+# Higher Order Jobs
+Because jobs are expected to be pure functions, they can be composed or transformed to create
+more complex behaviour, similar to how RxJS operators can transform observables.
+
+```javascript
+// Runs a job on the hour, every hour, regardless of how long the job takes.
+// This creates a job function that can be registered by itself.
+function scheduleJobOnTheHour(jobFunction) {
+  return function(argument, context) {
+    return new Observable(observer => {
+      let timeout = 0;
+   
+      function _timeoutToNextHour() {
+        // Just wait until the next hour.
+        const t = new Date();
+        const secondsToNextHour = 3600 - t.getSeconds() - t.getMinutes() * 60;
+        timeout = setTimeout(_scheduleJobAndWaitAnHour, secondsToNextHour);
+      }
+   
+      function _scheduleJobAndWaitAnHour() {
+        jobFunction(argument, context).subscribe(
+          message => observer.next(message),
+          error => observer.error(error),
+          // Do not forward completion, but use it to schedule the next job run.
+          () => {
+            _timeoutToNextHour();
+          },
+        );
+      }
+   
+      // Kick off by waiting for next hour.
+      _timeoutToNextHour();
+   
+      return () => clearTimeout(timeout);
+    });
+  };
+}
+```
+
+Another way to compose jobs is to schedule jobs based on their name, from other jobs.
+
+```javascript
+// Runs a job on the hour, every hour, regardless of how long the job takes.
+// This creates a high order job by getting a job name and an argument, and scheduling the job
+// every hour.
+function scheduleJobOnTheHour(job, context) {
+  const { name, argument } = job;  // Destructure our input.
+
+  return new Observable(observer => {
+    let timeout = 0;
+
+    function _timeoutToNextHour() {
+      // Just wait until the next hour.
+      const t = new Date();
+      const secondsToNextHour = 3600 - t.getSeconds() - t.getMinutes() * 60;
+      timeout = setTimeout(_scheduleJobAndWaitAnHour, secondsToNextHour);
+    }
+
+    function _scheduleJobAndWaitAnHour() {
+      const subJob = context.scheduler.schedule(name, argument);
+      // We do not forward the input to the sub-job but that would be a valid example as well.
+      subJob.outboundBus.subscribe(
+        message => observer.next(message),
+        error => observer.error(error),
+        // Do not forward completion, but use it to schedule the next job run.
+        () => {
+          _timeoutToNextHour();
+        },
+      );
+    }
+
+    // Kick off by waiting for next hour.
+    _timeoutToNextHour();
+
+    return () => clearTimeout(timeout);
+  });
+}
+
+const registry = new SimpleJobRegistry();
+registry.register('schedule-job-on-the-hour', scheduleJobOnTheHour, {
+  argument: {
+    properties: {
+      name: { type: 'string' },
+      argument: { type: true },
+    },
+  },
+});
+
+// Implementation left to the reader.
+registry.register('copy-files-from-a-to-b', require('some-package/copy-job'));
+
+const scheduler = new SimpleScheduler(registry);
+
+// A rudimentary backup system.
+const job = scheduler.schedule('schedule-job-on-the-hour', {
+  name: 'copy-files-from-a-to-b',
+  argument: {
+    from: '/some-directory/to/backup',
+    to: '/volumes/usb-key',
+  },
+});
+job.output.subscribe(x => console.log(x));
+```
+
+# Limitations
+Jobs input, output and argument must be serializable to JSONs. This is a big limitation in usage,
+but comes with the benefit that jobs can be serialized and called across memory boundaries. An
+example would be an operator that takes a module path and run the job from that path in a separate
+process. Or even a separate server, using HTTP calls.
+ 
+Another limitation is that the boilerplate is complex. Manually managing start/end life cycle, and
+other messages such as logging, etc. is tedious and requires a lot of code. A good way to keep
+this limitation under control is to provide helpers to create `JobHandler`s which manage those
+messages for the developer. A simple handler could be to get a `Promise` and return the output of
+that promise automatically.

package/src/experimental/jobs/create-job-handler.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @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 { Observable, Observer } from 'rxjs';
+import { BaseException } from '../../exception/index';
+import { JsonValue } from '../../json/index';
+import { LoggerApi } from '../../logger/index';
+import { JobDescription, JobHandler, JobHandlerContext } from './api';
+export declare class ChannelAlreadyExistException extends BaseException {
+    constructor(name: string);
+}
+/**
+ * Interface for the JobHandler context that is used when using `createJobHandler()`. It extends
+ * the basic `JobHandlerContext` with additional functionality.
+ */
+export interface SimpleJobHandlerContext<A extends JsonValue, I extends JsonValue, O extends JsonValue> extends JobHandlerContext<A, I, O> {
+    logger: LoggerApi;
+    createChannel: (name: string) => Observer<JsonValue>;
+    input: Observable<JsonValue>;
+}
+/**
+ * A simple version of the JobHandler. This simplifies a lot of the interaction with the job
+ * scheduler and registry. For example, instead of returning a JobOutboundMessage observable, you
+ * can directly return an output.
+ */
+export declare type SimpleJobHandlerFn<A extends JsonValue, I extends JsonValue, O extends JsonValue> = (input: A, context: SimpleJobHandlerContext<A, I, O>) => O | Promise<O> | Observable<O>;
+/**
+ * Make a simple job handler that sets start and end from a function that's synchronous.
+ *
+ * @param fn The function to create a handler for.
+ * @param options An optional set of properties to set on the handler. Some fields might be
+ *   required by registry or schedulers.
+ */
+export declare function createJobHandler<A extends JsonValue, I extends JsonValue, O extends JsonValue>(fn: SimpleJobHandlerFn<A, I, O>, options?: Partial<JobDescription>): JobHandler<A, I, O>;
+/**
+ * Lazily create a job using a function.
+ * @param loader A factory function that returns a promise/observable of a JobHandler.
+ * @param options Same options as createJob.
+ */
+export declare function createJobFactory<A extends JsonValue, I extends JsonValue, O extends JsonValue>(loader: () => Promise<JobHandler<A, I, O>>, options: Partial<JobDescription>): JobHandler<A, I, O>;
+/**
+ * Creates a job that logs out input/output messages of another Job. The messages are still
+ * propagated to the other job.
+ */
+export declare function createLoggerJob<A extends JsonValue, I extends JsonValue, O extends JsonValue>(job: JobHandler<A, I, O>, logger: LoggerApi): JobHandler<A, I, O>;

package/src/experimental/jobs/create-job-handler.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @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
+ *
+ */
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const index_1 = require("../../exception/index");
+const index_2 = require("../../logger/index");
+const index_3 = require("../../utils/index");
+const api_1 = require("./api");
+class ChannelAlreadyExistException extends index_1.BaseException {
+    constructor(name) {
+        super(`Channel ${JSON.stringify(name)} already exist.`);
+    }
+}
+exports.ChannelAlreadyExistException = ChannelAlreadyExistException;
+/**
+ * Make a simple job handler that sets start and end from a function that's synchronous.
+ *
+ * @param fn The function to create a handler for.
+ * @param options An optional set of properties to set on the handler. Some fields might be
+ *   required by registry or schedulers.
+ */
+function createJobHandler(fn, options = {}) {
+    const handler = (argument, context) => {
+        const description = context.description;
+        const inboundBus = context.inboundBus;
+        const inputChannel = new rxjs_1.Subject();
+        let subscription;
+        return new rxjs_1.Observable(subject => {
+            // Handle input.
+            inboundBus.subscribe(message => {
+                switch (message.kind) {
+                    case api_1.JobInboundMessageKind.Ping:
+                        subject.next({ kind: api_1.JobOutboundMessageKind.Pong, description, id: message.id });
+                        break;
+                    case api_1.JobInboundMessageKind.Stop:
+                        // There's no way to cancel a promise or a synchronous function, but we do cancel
+                        // observables where possible.
+                        if (subscription) {
+                            subscription.unsubscribe();
+                        }
+                        subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
+                        subject.complete();
+                        // Close all channels.
+                        channels.forEach(x => x.complete());
+                        break;
+                    case api_1.JobInboundMessageKind.Input:
+                        inputChannel.next(message.value);
+                        break;
+                }
+            });
+            // Configure a logger to pass in as additional context.
+            const logger = new index_2.Logger('job');
+            logger.subscribe(entry => {
+                subject.next({
+                    kind: api_1.JobOutboundMessageKind.Log,
+                    description,
+                    entry,
+                });
+            });
+            // Execute the function with the additional context.
+            subject.next({ kind: api_1.JobOutboundMessageKind.Start, description });
+            const channels = new Map();
+            const newContext = Object.assign({}, context, { input: inputChannel.asObservable(), logger,
+                createChannel(name) {
+                    if (channels.has(name)) {
+                        throw new ChannelAlreadyExistException(name);
+                    }
+                    const channelSubject = new rxjs_1.Subject();
+                    channelSubject.subscribe(message => {
+                        subject.next({
+                            kind: api_1.JobOutboundMessageKind.ChannelMessage, description, name, message,
+                        });
+                    }, error => {
+                        subject.next({ kind: api_1.JobOutboundMessageKind.ChannelError, description, name, error });
+                        // This can be reopened.
+                        channels.delete(name);
+                    }, () => {
+                        subject.next({ kind: api_1.JobOutboundMessageKind.ChannelComplete, description, name });
+                        // This can be reopened.
+                        channels.delete(name);
+                    });
+                    channels.set(name, channelSubject);
+                    return channelSubject;
+                } });
+            const result = fn(argument, newContext);
+            // If the result is a promise, simply wait for it to complete before reporting the result.
+            if (index_3.isPromise(result)) {
+                result.then(result => {
+                    subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value: result });
+                    subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
+                    subject.complete();
+                }, err => subject.error(err));
+            }
+            else if (rxjs_1.isObservable(result)) {
+                subscription = result.subscribe((value) => subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value }), error => subject.error(error), () => {
+                    subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
+                    subject.complete();
+                });
+                return subscription;
+            }
+            else {
+                // If it's a scalar value, report it synchronously.
+                subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value: result });
+                subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
+                subject.complete();
+            }
+        });
+    };
+    return Object.assign(handler, { jobDescription: options });
+}
+exports.createJobHandler = createJobHandler;
+/**
+ * Lazily create a job using a function.
+ * @param loader A factory function that returns a promise/observable of a JobHandler.
+ * @param options Same options as createJob.
+ */
+function createJobFactory(loader, options) {
+    const handler = (argument, context) => {
+        return rxjs_1.from(loader())
+            .pipe(operators_1.switchMap(fn => fn(argument, context)));
+    };
+    return Object.assign(handler, { jobDescription: options });
+}
+exports.createJobFactory = createJobFactory;
+/**
+ * Creates a job that logs out input/output messages of another Job. The messages are still
+ * propagated to the other job.
+ */
+function createLoggerJob(job, logger) {
+    const handler = (argument, context) => {
+        context.inboundBus.pipe(operators_1.tap(message => logger.info(`Input: ${JSON.stringify(message)}`))).subscribe();
+        return job(argument, context).pipe(operators_1.tap(message => logger.info(`Message: ${JSON.stringify(message)}`), error => logger.warn(`Error: ${JSON.stringify(error)}`), () => logger.info(`Completed`)));
+    };
+    return Object.assign(handler, job);
+}
+exports.createLoggerJob = createLoggerJob;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-job-handler.js","sourceRoot":"./","sources":["packages/angular_devkit/core/src/experimental/jobs/create-job-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n *\n */\nimport { Observable, Observer, Subject, Subscription, from, isObservable } from 'rxjs';\nimport { switchMap, tap } from 'rxjs/operators';\nimport { BaseException } from '../../exception/index';\nimport { JsonValue } from '../../json/index';\nimport { Logger, LoggerApi } from '../../logger/index';\nimport { isPromise } from '../../utils/index';\nimport {\n  JobDescription,\n  JobHandler,\n  JobHandlerContext,\n  JobInboundMessageKind,\n  JobOutboundMessage,\n  JobOutboundMessageKind,\n} from './api';\n\n\nexport class ChannelAlreadyExistException extends BaseException {\n  constructor(name: string) {\n    super(`Channel ${JSON.stringify(name)} already exist.`);\n  }\n}\n\n/**\n * Interface for the JobHandler context that is used when using `createJobHandler()`. It extends\n * the basic `JobHandlerContext` with additional functionality.\n */\nexport interface SimpleJobHandlerContext<\n  A extends JsonValue,\n  I extends JsonValue,\n  O extends JsonValue,\n> extends JobHandlerContext<A, I, O> {\n  logger: LoggerApi;\n  createChannel: (name: string) => Observer<JsonValue>;\n  input: Observable<JsonValue>;\n}\n\n\n/**\n * A simple version of the JobHandler. This simplifies a lot of the interaction with the job\n * scheduler and registry. For example, instead of returning a JobOutboundMessage observable, you\n * can directly return an output.\n */\nexport type SimpleJobHandlerFn<A extends JsonValue, I extends JsonValue, O extends JsonValue> = (\n  input: A,\n  context: SimpleJobHandlerContext<A, I, O>,\n) => O | Promise<O> | Observable<O>;\n\n\n/**\n * Make a simple job handler that sets start and end from a function that's synchronous.\n *\n * @param fn The function to create a handler for.\n * @param options An optional set of properties to set on the handler. Some fields might be\n *   required by registry or schedulers.\n */\nexport function createJobHandler<A extends JsonValue, I extends JsonValue, O extends JsonValue>(\n  fn: SimpleJobHandlerFn<A, I, O>,\n  options: Partial<JobDescription> = {},\n): JobHandler<A, I, O> {\n  const handler = (argument: A, context: JobHandlerContext<A, I, O>) => {\n    const description = context.description;\n    const inboundBus = context.inboundBus;\n    const inputChannel = new Subject<JsonValue>();\n    let subscription: Subscription;\n\n    return new Observable<JobOutboundMessage<O>>(subject => {\n      // Handle input.\n      inboundBus.subscribe(message => {\n        switch (message.kind) {\n          case JobInboundMessageKind.Ping:\n            subject.next({ kind: JobOutboundMessageKind.Pong, description, id: message.id });\n            break;\n\n          case JobInboundMessageKind.Stop:\n            // There's no way to cancel a promise or a synchronous function, but we do cancel\n            // observables where possible.\n            if (subscription) {\n              subscription.unsubscribe();\n            }\n            subject.next({ kind: JobOutboundMessageKind.End, description });\n            subject.complete();\n            // Close all channels.\n            channels.forEach(x => x.complete());\n            break;\n\n          case JobInboundMessageKind.Input:\n            inputChannel.next(message.value);\n            break;\n        }\n      });\n\n      // Configure a logger to pass in as additional context.\n      const logger = new Logger('job');\n      logger.subscribe(entry => {\n        subject.next({\n          kind: JobOutboundMessageKind.Log,\n          description,\n          entry,\n        });\n      });\n\n      // Execute the function with the additional context.\n      subject.next({ kind: JobOutboundMessageKind.Start, description });\n\n      const channels = new Map<string, Subject<JsonValue>>();\n\n      const newContext = {\n        ...context,\n        input: inputChannel.asObservable(),\n        logger,\n        createChannel(name: string) {\n          if (channels.has(name)) {\n            throw new ChannelAlreadyExistException(name);\n          }\n          const channelSubject = new Subject<JsonValue>();\n          channelSubject.subscribe(\n            message => {\n              subject.next({\n                kind: JobOutboundMessageKind.ChannelMessage, description, name, message,\n              });\n            },\n            error => {\n              subject.next({ kind: JobOutboundMessageKind.ChannelError, description, name, error });\n              // This can be reopened.\n              channels.delete(name);\n            },\n            () => {\n              subject.next({ kind: JobOutboundMessageKind.ChannelComplete, description, name });\n              // This can be reopened.\n              channels.delete(name);\n            },\n          );\n\n          channels.set(name, channelSubject);\n\n          return channelSubject;\n        },\n      };\n\n      const result = fn(argument, newContext);\n      // If the result is a promise, simply wait for it to complete before reporting the result.\n      if (isPromise(result)) {\n        result.then(result => {\n          subject.next({ kind: JobOutboundMessageKind.Output, description, value: result });\n          subject.next({ kind: JobOutboundMessageKind.End, description });\n          subject.complete();\n        }, err => subject.error(err));\n      } else if (isObservable(result)) {\n        subscription = (result as Observable<O>).subscribe(\n          (value: O) => subject.next({ kind: JobOutboundMessageKind.Output, description, value }),\n          error => subject.error(error),\n          () => {\n            subject.next({ kind: JobOutboundMessageKind.End, description });\n            subject.complete();\n          },\n        );\n\n        return subscription;\n      } else {\n        // If it's a scalar value, report it synchronously.\n        subject.next({ kind: JobOutboundMessageKind.Output, description, value: result as O });\n        subject.next({ kind: JobOutboundMessageKind.End, description });\n        subject.complete();\n      }\n    });\n  };\n\n  return Object.assign(handler, { jobDescription: options });\n}\n\n\n/**\n * Lazily create a job using a function.\n * @param loader A factory function that returns a promise/observable of a JobHandler.\n * @param options Same options as createJob.\n */\nexport function createJobFactory<A extends JsonValue, I extends JsonValue, O extends JsonValue>(\n  loader: () => Promise<JobHandler<A, I, O>>,\n  options: Partial<JobDescription>,\n): JobHandler<A, I, O> {\n  const handler = (argument: A, context: JobHandlerContext<A, I, O>) => {\n    return from(loader())\n      .pipe(switchMap(fn => fn(argument, context)));\n  };\n\n  return Object.assign(handler, { jobDescription: options });\n}\n\n\n/**\n * Creates a job that logs out input/output messages of another Job. The messages are still\n * propagated to the other job.\n */\nexport function createLoggerJob<A extends JsonValue, I extends JsonValue, O extends JsonValue>(\n  job: JobHandler<A, I, O>,\n  logger: LoggerApi,\n): JobHandler<A, I, O> {\n  const handler = (argument: A, context: JobHandlerContext<A, I, O>) => {\n    context.inboundBus.pipe(\n      tap(message => logger.info(`Input: ${JSON.stringify(message)}`)),\n    ).subscribe();\n\n    return job(argument, context).pipe(\n      tap(\n        message => logger.info(`Message: ${JSON.stringify(message)}`),\n        error => logger.warn(`Error: ${JSON.stringify(error)}`),\n        () => logger.info(`Completed`),\n      ),\n    );\n  };\n\n  return Object.assign(handler, job);\n}\n"]}

package/src/experimental/jobs/dispatcher.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 { JsonValue } from '../../json/index';
+import { Readwrite } from '../../utils/index';
+import { JobDescription, JobHandler, JobName } from './api';
+/**
+ * A JobDispatcher can be used to dispatch between multiple jobs.
+ */
+export interface JobDispatcher<A extends JsonValue, I extends JsonValue, O extends JsonValue> extends JobHandler<A, I, O> {
+    /**
+     * Set the default job if all conditionals failed.
+     * @param name The default name if all conditions are false.
+     */
+    setDefaultJob(name: JobName | null | JobHandler<JsonValue, JsonValue, JsonValue>): void;
+    /**
+     * Add a conditional job that will be selected if the input fits a predicate.
+     * @param predicate
+     * @param name
+     */
+    addConditionalJob(predicate: (args: A) => boolean, name: string): void;
+}
+/**
+ * OnReady a dispatcher that can dispatch to a sub job, depending on conditions.
+ * @param options
+ */
+export declare function createDispatcher<A extends JsonValue, I extends JsonValue, O extends JsonValue>(options?: Partial<Readwrite<JobDescription>>): JobDispatcher<A, I, O>;

package/src/experimental/jobs/dispatcher.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("./api");
+const exception_1 = require("./exception");
+/**
+ * OnReady a dispatcher that can dispatch to a sub job, depending on conditions.
+ * @param options
+ */
+function createDispatcher(options = {}) {
+    let defaultDelegate = null;
+    const conditionalDelegateList = [];
+    const job = Object.assign((argument, context) => {
+        const maybeDelegate = conditionalDelegateList.find(([predicate]) => predicate(argument));
+        let delegate = null;
+        if (maybeDelegate) {
+            delegate = context.scheduler.schedule(maybeDelegate[1], argument);
+        }
+        else if (defaultDelegate) {
+            delegate = context.scheduler.schedule(defaultDelegate, argument);
+        }
+        else {
+            throw new exception_1.JobDoesNotExistException('<null>');
+        }
+        context.inboundBus.subscribe(delegate.inboundBus);
+        return delegate.outboundBus;
+    }, {
+        jobDescription: options,
+    });
+    return Object.assign(job, {
+        setDefaultJob(name) {
+            if (api_1.isJobHandler(name)) {
+                name = name.jobDescription.name === undefined ? null : name.jobDescription.name;
+            }
+            defaultDelegate = name;
+        },
+        addConditionalJob(predicate, name) {
+            conditionalDelegateList.push([predicate, name]);
+        },
+    });
+}
+exports.createDispatcher = createDispatcher;
+//# sourceMappingURL=data:application/json;base64,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

package/src/experimental/jobs/exception.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 { BaseException } from '../../exception/index';
+import { JobName } from './api';
+export declare class JobNameAlreadyRegisteredException extends BaseException {
+    constructor(name: JobName);
+}
+export declare class JobDoesNotExistException extends BaseException {
+    constructor(name: JobName);
+}

package/src/experimental/jobs/exception.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @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
+ */
+const index_1 = require("../../exception/index");
+class JobNameAlreadyRegisteredException extends index_1.BaseException {
+    constructor(name) {
+        super(`Job named ${JSON.stringify(name)} already exists.`);
+    }
+}
+exports.JobNameAlreadyRegisteredException = JobNameAlreadyRegisteredException;
+class JobDoesNotExistException extends index_1.BaseException {
+    constructor(name) {
+        super(`Job name ${JSON.stringify(name)} does not exist.`);
+    }
+}
+exports.JobDoesNotExistException = JobDoesNotExistException;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhjZXB0aW9uLmpzIiwic291cmNlUm9vdCI6Ii4vIiwic291cmNlcyI6WyJwYWNrYWdlcy9hbmd1bGFyX2RldmtpdC9jb3JlL3NyYy9leHBlcmltZW50YWwvam9icy9leGNlcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTs7Ozs7O0dBTUc7QUFDSCxpREFBc0Q7QUFHdEQsTUFBYSxpQ0FBa0MsU0FBUSxxQkFBYTtJQUNsRSxZQUFZLElBQWE7UUFDdkIsS0FBSyxDQUFDLGFBQWEsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUM3RCxDQUFDO0NBQ0Y7QUFKRCw4RUFJQztBQUVELE1BQWEsd0JBQXlCLFNBQVEscUJBQWE7SUFDekQsWUFBWSxJQUFhO1FBQ3ZCLEtBQUssQ0FBQyxZQUFZLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDNUQsQ0FBQztDQUNGO0FBSkQsNERBSUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQgeyBCYXNlRXhjZXB0aW9uIH0gZnJvbSAnLi4vLi4vZXhjZXB0aW9uL2luZGV4JztcbmltcG9ydCB7IEpvYk5hbWUgfSBmcm9tICcuL2FwaSc7XG5cbmV4cG9ydCBjbGFzcyBKb2JOYW1lQWxyZWFkeVJlZ2lzdGVyZWRFeGNlcHRpb24gZXh0ZW5kcyBCYXNlRXhjZXB0aW9uIHtcbiAgY29uc3RydWN0b3IobmFtZTogSm9iTmFtZSkge1xuICAgIHN1cGVyKGBKb2IgbmFtZWQgJHtKU09OLnN0cmluZ2lmeShuYW1lKX0gYWxyZWFkeSBleGlzdHMuYCk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEpvYkRvZXNOb3RFeGlzdEV4Y2VwdGlvbiBleHRlbmRzIEJhc2VFeGNlcHRpb24ge1xuICBjb25zdHJ1Y3RvcihuYW1lOiBKb2JOYW1lKSB7XG4gICAgc3VwZXIoYEpvYiBuYW1lICR7SlNPTi5zdHJpbmdpZnkobmFtZSl9IGRvZXMgbm90IGV4aXN0LmApO1xuICB9XG59XG4iXX0=

package/src/experimental/jobs/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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
+ */
+export * from './api';
+export * from './create-job-handler';
+export * from './exception';
+export * from './dispatcher';
+export * from './simple-registry';
+export * from './simple-scheduler';
+export * from './strategy';

package/src/experimental/jobs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @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
+ */
+__export(require("./api"));
+__export(require("./create-job-handler"));
+__export(require("./exception"));
+__export(require("./dispatcher"));
+__export(require("./simple-registry"));
+__export(require("./simple-scheduler"));
+__export(require("./strategy"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiLi8iLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2NvcmUvc3JjL2V4cGVyaW1lbnRhbC9qb2JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUE7Ozs7OztHQU1HO0FBQ0gsMkJBQXNCO0FBQ3RCLDBDQUFxQztBQUNyQyxpQ0FBNEI7QUFDNUIsa0NBQTZCO0FBQzdCLHVDQUFrQztBQUNsQyx3Q0FBbUM7QUFDbkMsZ0NBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9jcmVhdGUtam9iLWhhbmRsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9leGNlcHRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNwYXRjaGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc2ltcGxlLXJlZ2lzdHJ5JztcbmV4cG9ydCAqIGZyb20gJy4vc2ltcGxlLXNjaGVkdWxlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0cmF0ZWd5JztcbiJdfQ==