@orbit/core
Version:
Core library for Orbit - a flexible data access and synchronization layer.
328 lines • 35.3 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
import { Orbit } from './main';
import { TaskProcessor } from './task-processor';
import { evented, settleInSeries } from './evented';
const { assert } = Orbit;
/**
* `TaskQueue` is a FIFO queue of asynchronous tasks that should be
* performed sequentially.
*
* Tasks are added to the queue with `push`. Each task will be processed by
* calling its `process` method.
*
* By default, task queues will be processed automatically, as soon as tasks
* are pushed to them. This can be overridden by setting the `autoProcess`
* setting to `false` and calling `process` when you'd like to start
* processing.
*/
let TaskQueue = class TaskQueue {
/**
* Creates an instance of `TaskQueue`.
*/
constructor(target, settings = {}) {
this._tasks = [];
this._processors = [];
this._performer = target;
this._name = settings.name;
this._bucket = settings.bucket;
this.autoProcess =
settings.autoProcess === undefined ? true : settings.autoProcess;
if (this._bucket) {
assert('TaskQueue requires a name if it has a bucket', !!this._name);
}
const autoActivate = settings.autoActivate === undefined || settings.autoActivate;
if (autoActivate) {
this.activate();
}
else {
this._reify();
}
}
async activate() {
await this._reify();
if (this.length > 0 && this.autoProcess) {
this.process();
}
}
/**
* Name used for tracking / debugging this queue.
*/
get name() {
return this._name;
}
/**
* The object which will `perform` the tasks in this queue.
*/
get performer() {
return this._performer;
}
/**
* A bucket used to persist the state of this queue.
*/
get bucket() {
return this._bucket;
}
/**
* The number of tasks in the queue.
*/
get length() {
return this._tasks.length;
}
/**
* The tasks in the queue.
*/
get entries() {
return this._tasks;
}
/**
* The current task being processed (if actively processing), or the next
* task to be processed (if not actively processing).
*/
get current() {
return this._tasks[0];
}
/**
* The processor wrapper that is processing the current task (or next task,
* if none are being processed).
*/
get currentProcessor() {
return this._processors[0];
}
/**
* If an error occurs while processing a task, processing will be halted, the
* `fail` event will be emitted, and this property will reflect the error
* encountered.
*/
get error() {
return this._error;
}
/**
* Is the queue empty?
*/
get empty() {
return this.length === 0;
}
/**
* Is the queue actively processing a task?
*/
get processing() {
const processor = this.currentProcessor;
return processor !== undefined && processor.started && !processor.settled;
}
/**
* Resolves when the queue has been fully reified from its associated bucket,
* if applicable.
*/
get reified() {
return this._reified;
}
/**
* Push a new task onto the end of the queue.
*
* If `autoProcess` is enabled, this will automatically trigger processing of
* the queue.
*
* Returns the result of processing the pushed task.
*/
async push(task) {
await this._reified;
const processor = new TaskProcessor(this._performer, task);
this._tasks.push(task);
this._processors.push(processor);
await this._persist();
if (this.autoProcess)
this._settle();
return processor.settle();
}
/**
* Cancels and re-tries processing the current task.
*
* Returns the result of the retried task.
*/
async retry() {
await this._reified;
this._cancel();
let processor = this.currentProcessor;
processor.reset();
await this._persist();
this._settle();
return processor.settle();
}
/**
* Cancels and discards the current task.
*
* If `autoProcess` is enabled, this will automatically trigger processing of
* the queue.
*/
async skip(e) {
await this._reified;
this._cancel();
this._tasks.shift();
let processor = this._processors.shift();
if (processor !== undefined && !processor.settled) {
processor.reject(e || new Error('Processing cancelled via `TaskQueue#skip`'));
}
await this._persist();
if (this.autoProcess)
this._settle();
}
/**
* Cancels the current task and completely clears the queue.
*/
async clear(e) {
await this._reified;
this._cancel();
this._tasks = [];
for (let processor of this._processors) {
if (!processor.settled) {
processor.reject(e || new Error('Processing cancelled via `TaskQueue#clear`'));
}
}
this._processors = [];
await this._persist();
await this._settle();
}
/**
* Cancels the current task and removes it, but does not continue processing.
*
* Returns the canceled and removed task.
*/
async shift(e) {
await this._reified;
let task = this._tasks.shift();
if (task) {
this._cancel();
let processor = this._processors.shift();
if (processor !== undefined && !processor.settled) {
processor.reject(e || new Error('Processing cancelled via `TaskQueue#shift`'));
}
await this._persist();
}
return task;
}
/**
* Cancels processing the current task and inserts a new task at the beginning
* of the queue. This new task will be processed next.
*
* Returns the result of processing the new task.
*/
async unshift(task) {
await this._reified;
let processor = new TaskProcessor(this._performer, task);
this._cancel();
this._tasks.unshift(task);
this._processors.unshift(processor);
await this._persist();
if (this.autoProcess)
this._settle();
return processor.settle();
}
/**
* Processes all the tasks in the queue. Resolves when the queue is empty.
*/
async process() {
await this._reified;
let resolution = this._resolution;
if (!resolution) {
if (this._tasks.length === 0) {
resolution = this._complete();
}
else {
this._error = undefined;
this._resolution = resolution = new Promise((resolve, reject) => {
this._resolve = resolve;
this._reject = reject;
});
await this._settleEach(resolution);
}
}
return resolution;
}
async _settle() {
try {
await this.process();
}
catch (e) { }
}
async _complete() {
if (this._resolve) {
this._resolve();
}
this._resolve = undefined;
this._reject = undefined;
this._error = undefined;
this._resolution = undefined;
await settleInSeries(this, 'complete');
}
async _fail(task, e) {
if (this._reject) {
this._reject(e);
}
this._resolve = undefined;
this._reject = undefined;
this._error = e;
this._resolution = undefined;
await settleInSeries(this, 'fail', task, e);
}
_cancel() {
this._error = undefined;
this._resolution = undefined;
}
async _settleEach(resolution) {
if (this._tasks.length === 0) {
return this._complete();
}
else {
const task = this._tasks[0];
const processor = this._processors[0];
try {
await settleInSeries(this, 'beforeTask', task);
await processor.process();
if (resolution === this._resolution) {
this._tasks.shift();
this._processors.shift();
await this._persist();
await settleInSeries(this, 'task', task);
await this._settleEach(resolution);
}
}
catch (e) {
if (resolution === this._resolution) {
return this._fail(task, e);
}
}
}
}
_reify() {
this._tasks = [];
this._processors = [];
this._reified = this._loadTasksFromBucket().then((tasks) => {
if (tasks) {
this._tasks = tasks;
this._processors = tasks.map((task) => new TaskProcessor(this._performer, task));
}
});
return this._reified;
}
async _loadTasksFromBucket() {
if (this._bucket && this._name) {
return this._bucket.getItem(this._name);
}
}
async _persist() {
this.emit('change');
if (this._bucket && this._name) {
await this._bucket.setItem(this._name, this._tasks);
}
}
};
TaskQueue = __decorate([
evented
], TaskQueue);
export { TaskQueue };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-queue.js","sourceRoot":"","sources":["../../src/task-queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { Orbit } from './main';\nimport { Task, Performer } from './task';\nimport { TaskProcessor } from './task-processor';\nimport { Bucket } from './bucket';\nimport { evented, Evented, settleInSeries } from './evented';\n\nconst { assert } = Orbit;\n\n/**\n * Settings for a `TaskQueue`.\n */\nexport interface TaskQueueSettings<\n  Type = string,\n  Data = unknown,\n  Options = unknown\n> {\n  /**\n   * Name used for tracking and debugging a task queue.\n   */\n  name?: string;\n\n  /**\n   * A bucket in which to persist queue state.\n   */\n  bucket?: Bucket<Task<Type, Data, Options>[]>;\n\n  /**\n   * A flag indicating whether tasks should be processed as soon as they are\n   * pushed into a queue. Set to `false` to override the default `true`\n   * behavior.\n   */\n  autoProcess?: boolean;\n\n  /**\n   * A flag indicating whether activation should happen as part of\n   * instantiation. Set to `false` to override the default `true` behavior. When\n   * `autoActivate === false`, no tasks reified from the queue's bucket will be\n   * automatically processed as part of queue instantiation, regardless of the\n   * `autoProcess` setting. Invoke `queue.activate()` as a separate step to\n   * finish activation and start processing tasks.\n   */\n  autoActivate?: boolean;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface TaskQueue extends Evented {}\n\n/**\n * `TaskQueue` is a FIFO queue of asynchronous tasks that should be\n * performed sequentially.\n *\n * Tasks are added to the queue with `push`. Each task will be processed by\n * calling its `process` method.\n *\n * By default, task queues will be processed automatically, as soon as tasks\n * are pushed to them. This can be overridden by setting the `autoProcess`\n * setting to `false` and calling `process` when you'd like to start\n * processing.\n */\n@evented\nexport class TaskQueue<\n  Type = string,\n  Data = unknown,\n  Options = unknown,\n  Result = unknown\n> {\n  public autoProcess: boolean;\n\n  private _performer: Performer<Type, Data, Options, Result>;\n  private _name?: string;\n  private _bucket?: Bucket<Task<Type, Data, Options>[]>;\n  private _tasks: Task<Type, Data, Options>[] = [];\n  private _processors: TaskProcessor<Type, Data, Options, Result>[] = [];\n  private _error?: Error;\n  private _resolution?: Promise<void>;\n  private _resolve?: () => void;\n  private _reject?: (e: Error) => void;\n  private _reified!: Promise<void>;\n\n  /**\n   * Creates an instance of `TaskQueue`.\n   */\n  constructor(\n    target: Performer<Type, Data, Options, Result>,\n    settings: TaskQueueSettings<Type, Data, Options> = {}\n  ) {\n    this._performer = target;\n    this._name = settings.name;\n    this._bucket = settings.bucket;\n    this.autoProcess =\n      settings.autoProcess === undefined ? true : settings.autoProcess;\n\n    if (this._bucket) {\n      assert('TaskQueue requires a name if it has a bucket', !!this._name);\n    }\n\n    const autoActivate =\n      settings.autoActivate === undefined || settings.autoActivate;\n\n    if (autoActivate) {\n      this.activate();\n    } else {\n      this._reify();\n    }\n  }\n\n  async activate(): Promise<void> {\n    await this._reify();\n\n    if (this.length > 0 && this.autoProcess) {\n      this.process();\n    }\n  }\n\n  /**\n   * Name used for tracking / debugging this queue.\n   */\n  get name(): string | undefined {\n    return this._name;\n  }\n\n  /**\n   * The object which will `perform` the tasks in this queue.\n   */\n  get performer(): Performer<Type, Data, Options, Result> {\n    return this._performer;\n  }\n\n  /**\n   * A bucket used to persist the state of this queue.\n   */\n  get bucket(): Bucket<Task<Type, Data>[]> | undefined {\n    return this._bucket;\n  }\n\n  /**\n   * The number of tasks in the queue.\n   */\n  get length(): number {\n    return this._tasks.length;\n  }\n\n  /**\n   * The tasks in the queue.\n   */\n  get entries(): Task<Type, Data>[] {\n    return this._tasks;\n  }\n\n  /**\n   * The current task being processed (if actively processing), or the next\n   * task to be processed (if not actively processing).\n   */\n  get current(): Task<Type, Data> {\n    return this._tasks[0];\n  }\n\n  /**\n   * The processor wrapper that is processing the current task (or next task,\n   * if none are being processed).\n   */\n  get currentProcessor(): TaskProcessor<Type, Data, Options, Result> {\n    return this._processors[0];\n  }\n\n  /**\n   * If an error occurs while processing a task, processing will be halted, the\n   * `fail` event will be emitted, and this property will reflect the error\n   * encountered.\n   */\n  get error(): Error | undefined {\n    return this._error;\n  }\n\n  /**\n   * Is the queue empty?\n   */\n  get empty(): boolean {\n    return this.length === 0;\n  }\n\n  /**\n   * Is the queue actively processing a task?\n   */\n  get processing(): boolean {\n    const processor = this.currentProcessor;\n\n    return processor !== undefined && processor.started && !processor.settled;\n  }\n\n  /**\n   * Resolves when the queue has been fully reified from its associated bucket,\n   * if applicable.\n   */\n  get reified(): Promise<void> {\n    return this._reified;\n  }\n\n  /**\n   * Push a new task onto the end of the queue.\n   *\n   * If `autoProcess` is enabled, this will automatically trigger processing of\n   * the queue.\n   *\n   * Returns the result of processing the pushed task.\n   */\n  async push(task: Task<Type, Data, Options>): Promise<Result> {\n    await this._reified;\n\n    const processor = new TaskProcessor(this._performer, task);\n    this._tasks.push(task);\n    this._processors.push(processor);\n    await this._persist();\n    if (this.autoProcess) this._settle();\n    return processor.settle();\n  }\n\n  /**\n   * Cancels and re-tries processing the current task.\n   *\n   * Returns the result of the retried task.\n   */\n  async retry(): Promise<Result> {\n    await this._reified;\n\n    this._cancel();\n    let processor = this.currentProcessor;\n    processor.reset();\n    await this._persist();\n    this._settle();\n    return processor.settle();\n  }\n\n  /**\n   * Cancels and discards the current task.\n   *\n   * If `autoProcess` is enabled, this will automatically trigger processing of\n   * the queue.\n   */\n  async skip(e?: Error): Promise<void> {\n    await this._reified;\n\n    this._cancel();\n    this._tasks.shift();\n    let processor = this._processors.shift();\n    if (processor !== undefined && !processor.settled) {\n      processor.reject(\n        e || new Error('Processing cancelled via `TaskQueue#skip`')\n      );\n    }\n    await this._persist();\n    if (this.autoProcess) this._settle();\n  }\n\n  /**\n   * Cancels the current task and completely clears the queue.\n   */\n  async clear(e?: Error): Promise<void> {\n    await this._reified;\n\n    this._cancel();\n    this._tasks = [];\n    for (let processor of this._processors) {\n      if (!processor.settled) {\n        processor.reject(\n          e || new Error('Processing cancelled via `TaskQueue#clear`')\n        );\n      }\n    }\n    this._processors = [];\n    await this._persist();\n    await this._settle();\n  }\n\n  /**\n   * Cancels the current task and removes it, but does not continue processing.\n   *\n   * Returns the canceled and removed task.\n   */\n  async shift(e?: Error): Promise<Task<Type, Data> | undefined> {\n    await this._reified;\n\n    let task = this._tasks.shift();\n    if (task) {\n      this._cancel();\n      let processor = this._processors.shift();\n      if (processor !== undefined && !processor.settled) {\n        processor.reject(\n          e || new Error('Processing cancelled via `TaskQueue#shift`')\n        );\n      }\n      await this._persist();\n    }\n    return task;\n  }\n\n  /**\n   * Cancels processing the current task and inserts a new task at the beginning\n   * of the queue. This new task will be processed next.\n   *\n   * Returns the result of processing the new task.\n   */\n  async unshift(task: Task<Type, Data, Options>): Promise<Result> {\n    await this._reified;\n\n    let processor = new TaskProcessor<Type, Data, Options, Result>(\n      this._performer,\n      task\n    );\n    this._cancel();\n    this._tasks.unshift(task);\n    this._processors.unshift(processor);\n    await this._persist();\n    if (this.autoProcess) this._settle();\n    return processor.settle();\n  }\n\n  /**\n   * Processes all the tasks in the queue. Resolves when the queue is empty.\n   */\n  async process(): Promise<void> {\n    await this._reified;\n\n    let resolution = this._resolution;\n    if (!resolution) {\n      if (this._tasks.length === 0) {\n        resolution = this._complete();\n      } else {\n        this._error = undefined;\n        this._resolution = resolution = new Promise((resolve, reject) => {\n          this._resolve = resolve;\n          this._reject = reject;\n        });\n        await this._settleEach(resolution);\n      }\n    }\n    return resolution;\n  }\n\n  private async _settle(): Promise<void> {\n    try {\n      await this.process();\n    } catch (e) {}\n  }\n\n  private async _complete(): Promise<void> {\n    if (this._resolve) {\n      this._resolve();\n    }\n    this._resolve = undefined;\n    this._reject = undefined;\n    this._error = undefined;\n    this._resolution = undefined;\n    await settleInSeries(this, 'complete');\n  }\n\n  private async _fail(task: Task<Type, Data>, e: Error): Promise<void> {\n    if (this._reject) {\n      this._reject(e);\n    }\n    this._resolve = undefined;\n    this._reject = undefined;\n    this._error = e;\n    this._resolution = undefined;\n    await settleInSeries(this, 'fail', task, e);\n  }\n\n  private _cancel(): void {\n    this._error = undefined;\n    this._resolution = undefined;\n  }\n\n  private async _settleEach(resolution: any): Promise<void> {\n    if (this._tasks.length === 0) {\n      return this._complete();\n    } else {\n      const task = this._tasks[0];\n      const processor = this._processors[0];\n\n      try {\n        await settleInSeries(this, 'beforeTask', task);\n        await processor.process();\n        if (resolution === this._resolution) {\n          this._tasks.shift();\n          this._processors.shift();\n\n          await this._persist();\n          await settleInSeries(this, 'task', task);\n          await this._settleEach(resolution);\n        }\n      } catch (e) {\n        if (resolution === this._resolution) {\n          return this._fail(task, e as Error);\n        }\n      }\n    }\n  }\n\n  private _reify(): Promise<void> {\n    this._tasks = [];\n    this._processors = [];\n\n    this._reified = this._loadTasksFromBucket().then(\n      (tasks: Task<Type, Data, Options>[] | undefined) => {\n        if (tasks) {\n          this._tasks = tasks;\n          this._processors = tasks.map(\n            (task) => new TaskProcessor(this._performer, task)\n          );\n        }\n      }\n    );\n\n    return this._reified;\n  }\n\n  private async _loadTasksFromBucket(): Promise<\n    Task<Type, Data, Options>[] | undefined\n  > {\n    if (this._bucket && this._name) {\n      return this._bucket.getItem(this._name);\n    }\n  }\n\n  private async _persist(): Promise<void> {\n    this.emit('change');\n    if (this._bucket && this._name) {\n      await this._bucket.setItem(this._name, this._tasks);\n    }\n  }\n}\n"]}