timequeue 1.2.0 → 2.1.0

package/README.md

@@ -1,9 +1,8 @@
 # timequeue.js
 
-A queue with custom concurrency and time limits. Inspired by [caolan/async#queue](https://github.com/caolan/async#queue), but also with variable number of arguments in the worker, events, and with optional time limits.
+A queue with custom concurrency and time limits. Inspired by [async/queue](https://caolan.github.io/async/v3/docs.html#queue), but also with variable number of arguments in the worker, events, and with optional time limits.
 
-[![Build Status](https://secure.travis-ci.org/fent/timequeue.js.svg)](http://travis-ci.org/fent/timequeue.js)
-[![Dependency Status](https://david-dm.org/fent/timequeue.js.svg)](https://david-dm.org/fent/timequeue.js)
+![Depfu](https://img.shields.io/depfu/fent/timequeue.js)
 [![codecov](https://codecov.io/gh/fent/timequeue.js/branch/master/graph/badge.svg)](https://codecov.io/gh/fent/timequeue.js)
 
 # Usage
@@ -15,17 +14,26 @@ const worker = (arg1, arg2, callback) => {
   someAsyncFunction(calculation(arg1, arg2), callback);
 };
 
+// Worker can be an async function.
+const worker = async (arg1) => {
+  let result1 = await anotherSyncFunction(arg1);
+  return andAnotherOne(result1);
+};
+
 // create a queue with max 5 concurrency every second
 let q = new TimeQueue(worker, { concurrency: 5, every: 1000 });
 
-// push tasks onto the queue
+// Push tasks onto the queue.
 q.push(42, 24);
 q.push(2, 74);
 
-// optional callback when pushing tasks
-q.push(2, 2, (err) => {
+// Optional callback when pushing tasks.
+q.push(2, 2, (err, result) => {
   // task finished
 });
+
+// Can use promise/await syntax instead.
+let result = await q.push(3, 5);
 ```
 
 
@@ -40,44 +48,45 @@ Creates a new instance of a queue. Worker must be a function with a callback for
 
   // How much time in milliseconds to allow no more than
   // the max number of concurrent tasks to run.
-  // If the max amount of concurrent tasks are finished faster than the limit,
-  // they will be queued.
+  // If the max amount of concurrent tasks finish faster than this time limit,
+  // additional tasks will wait until enough time has passed before starting.
 , every: 0
 
   // Maximum number of tasks to keep in the queue.
   // While full, pushed tasks will be ignored.
 , maxQueued: Infinity
 
-  // If set, will emit an `error` event if a tasks takes too much time.
-  // if callback was given to that task,
-  // it will be called with the error instead.
+  // If set, tasks will error if they take too much time.
+  // if callback was given to that task, it will be called with the error,
+  // otherwise, the returned promise should be `caught`.
 , timeout: 0
+
+  // You can pass a custom store to share tasks between several queues.
+  // Default is MemoryStore from `src/mem-store.ts`.
+  // Look at `example/redis-store.js` for an example that saves tasks onto redis.
+, store: MemoryStore
 }
 ```
 
 All of these options can later be edited on the queue instance.
 
 ### TimeQueue#active
-
 How many tasks are currently active.
 
 ### TimeQueue#intransit
-
 If you use the `every` option to queue up tasks, this property will be delayed from being updated until there are free spots open for new tasks to begin. `active` will be updated as soon as a task finishes, even if the next one is just a timeout around the corner.
 
-### TimeQueue#queued
-
-How many tasks are currently in the queue.
-
 ### TimeQueue#finished
-
 How many tasks have finished in total.
 
-### TimeQueue#push(data..., [callback])
+### async TimeQueue#push(data..., [callback])
 Pushes a new task to the queue. Any number of arguments can be given. An optional callback can also be given as the last parameter. The callback will be called when the task is finished or if there was any error running the worker.
 
 If the queue is full, pushed tasks will be ignored.
 
+### async TimeQueue#store.getQueued()
+How many tasks are currently in the queue.
+
 ### TimeQueue#isFull()
 Returns true if queue is full.
 
@@ -86,11 +95,6 @@ Empties queue and clears the timeouts TimeQueue sets to keep track of running ta
 
 # Events
 
-### Event: 'error'
-* `Error`
-
-Emitted when there is an error processing a task and a callback isn't given to the `push` method.
-
 ### Event: 'full'
 
 Queue is full.

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+declare namespace TimeQueue {
+    type Worker = (...args: any[]) => void | Promise<any>;
+    interface Options {
+        concurrency?: number;
+        every?: number;
+        maxQueued?: number;
+        timeout?: number;
+        store?: Store;
+    }
+    interface TaskError extends Error {
+        args: any[];
+    }
+    interface Store {
+        isEmpty: () => Promise<boolean>;
+        getQueued: () => Promise<number>;
+        getNextTask: () => Promise<any[]>;
+        pushTask: (...args: any[]) => void;
+        clear: () => void;
+    }
+}
+declare class TimeQueue extends EventEmitter {
+    worker: TimeQueue.Worker;
+    concurrency: number;
+    every: number;
+    maxQueued: number;
+    timeout: number;
+    private _isWorkerAsync;
+    private _timers;
+    store: TimeQueue.Store;
+    active: number;
+    intransit: number;
+    finished: number;
+    static TaskError: {
+        new (message?: string): {
+            args: any[];
+            name: string;
+            message: string;
+            stack?: string;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
+        stackTraceLimit: number;
+    };
+    /**
+     * @constructor
+     * @extends {EventEmitter}
+     * @param {Function(..., Function(!Error, ...)} worker
+     * @param {Object?} options
+     * @param {number?} options.concurrency
+     * @param {number?} options.every
+     * @param {number?} options.maxQueued
+     * @param {number?} options.timeout
+     */
+    constructor(worker: TimeQueue.Worker, options?: TimeQueue.Options);
+    /**
+     * Pushes a task onto the queue.
+     *
+     * @param {Object} ...args
+     * @param {Function(!Error, ...)} callback
+     * @return {Promise?}
+     */
+    push(...args: any[]): Promise<unknown>;
+    /**
+     * Starts a task
+     *
+     * @param {Array.<Object>} args
+     */
+    _process(args: any[]): Promise<void>;
+    /**
+     * Called when a task finishes. Looks at the queue and processes the next
+     * waiting task.
+     */
+    _next(): Promise<void>;
+    /**
+     * Empties the queue and kills the timers.
+     * Active tasks will still be completed.
+     */
+    die(): void;
+}
+export = TimeQueue;

package/dist/index.js

@@ -0,0 +1,190 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = require("events");
+const mem_store_1 = __importDefault(require("./mem-store"));
+class TimeQueue extends events_1.EventEmitter {
+    /**
+     * @constructor
+     * @extends {EventEmitter}
+     * @param {Function(..., Function(!Error, ...)} worker
+     * @param {Object?} options
+     * @param {number?} options.concurrency
+     * @param {number?} options.every
+     * @param {number?} options.maxQueued
+     * @param {number?} options.timeout
+     */
+    constructor(worker, options = {}) {
+        super();
+        this.worker = worker;
+        this._isWorkerAsync = worker.constructor.name == 'AsyncFunction';
+        this.concurrency = options.concurrency || 1;
+        this.every = options.every || 0;
+        this.maxQueued = options.maxQueued || Infinity;
+        this.timeout = options.timeout || 0;
+        this.store = options.store || new mem_store_1.default({ maxQueued: this.maxQueued });
+        this._timers = [];
+        this.active = 0;
+        this.intransit = 0;
+        this.finished = 0;
+    }
+    /**
+     * Pushes a task onto the queue.
+     *
+     * @param {Object} ...args
+     * @param {Function(!Error, ...)} callback
+     * @return {Promise?}
+     */
+    push(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Returns a promise when no `callback` is given.
+            if (this._isWorkerAsync && args.length === this.worker.length ||
+                !this._isWorkerAsync && args.length < this.worker.length) {
+                return new Promise((resolve, reject) => {
+                    // Add any missing arguments.
+                    if (!this._isWorkerAsync) {
+                        while (args.length < this.worker.length - 1) {
+                            args.push(undefined);
+                        }
+                    }
+                    this.push(...args, (err, results) => {
+                        if (err)
+                            return reject(err);
+                        resolve(results);
+                    });
+                });
+            }
+            if (this.intransit < this.concurrency) {
+                this.intransit++;
+                this.active++;
+                if (this.intransit === this.concurrency) {
+                    this.emit('full');
+                }
+                yield this._process(args);
+            }
+            else {
+                yield this.store.pushTask(args);
+            }
+        });
+    }
+    /**
+     * Starts a task
+     *
+     * @param {Array.<Object>} args
+     */
+    _process(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const callback = args.pop();
+            let finished = false;
+            let every = ~~this.every;
+            let tookLongerThanEvery;
+            if (every) {
+                tookLongerThanEvery = false;
+                this._timers.push(setTimeout(() => {
+                    tookLongerThanEvery = true;
+                    this._timers.shift();
+                    if (finished) {
+                        this._next();
+                    }
+                }, every));
+            }
+            else {
+                tookLongerThanEvery = true;
+            }
+            // If `timeout` option is set, set a timeout to check the task doesn't lag.
+            let taskTimedOut = false;
+            let callbackCalled = false;
+            let timeout = ~~this.timeout;
+            let tid;
+            const taskCallback = (err, result) => {
+                // If this task has timed out, and the callback is called again
+                // from the worker, ignore it.
+                if (!taskTimedOut) {
+                    clearTimeout(tid);
+                }
+                else {
+                    return;
+                }
+                // Check that this callback is only called once.
+                if (callbackCalled && !taskTimedOut) {
+                    throw Error('Callback from worker should only be called once');
+                }
+                callbackCalled = true;
+                this.finished++;
+                this.active--;
+                callback(err, result);
+                finished = true;
+                if (tookLongerThanEvery) {
+                    this._next();
+                }
+            };
+            if (timeout) {
+                tid = setTimeout(() => {
+                    const err = new TimeQueue.TaskError('Task timed out');
+                    err.args = args;
+                    taskCallback(err);
+                    taskTimedOut = true;
+                }, timeout);
+            }
+            // Call the worker.
+            if (this._isWorkerAsync) {
+                try {
+                    taskCallback(null, yield this.worker(...args));
+                }
+                catch (err) {
+                    taskCallback(err);
+                }
+            }
+            else {
+                // Add custom callback to args.
+                const args2 = args.slice();
+                args2.push(taskCallback);
+                this.worker(...args2);
+            }
+        });
+    }
+    /**
+     * Called when a task finishes. Looks at the queue and processes the next
+     * waiting task.
+     */
+    _next() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let task;
+            if (this.intransit <= this.concurrency && (task = yield this.store.getNextTask())) {
+                this.active++;
+                yield this._process(task);
+                if (yield this.store.isEmpty()) {
+                    this.emit('empty');
+                }
+            }
+            else if (--this.intransit === 0) {
+                this.emit('drain');
+            }
+        });
+    }
+    /**
+     * Empties the queue and kills the timers.
+     * Active tasks will still be completed.
+     */
+    die() {
+        this.store.clear();
+        this._timers.forEach(clearTimeout);
+        this._timers = [];
+        this.intransit = 0;
+        this.active = 0;
+    }
+}
+TimeQueue.TaskError = class TaskError extends Error {
+};
+module.exports = TimeQueue;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/mem-store.d.ts

@@ -0,0 +1,13 @@
+export declare class Options {
+    maxQueued?: number;
+}
+export default class MemoryStore {
+    maxQueued: number;
+    private _queue;
+    constructor(options: Options);
+    isEmpty(): Promise<boolean>;
+    getQueued(): Promise<number>;
+    getNextTask(): Promise<any[]>;
+    pushTask(args: any[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/mem-store.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Options = void 0;
+class Options {
+}
+exports.Options = Options;
+class MemoryStore {
+    constructor(options) {
+        this.maxQueued = options.maxQueued;
+        this._queue = [];
+    }
+    isEmpty() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._queue.length === 0;
+        });
+    }
+    getQueued() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._queue.length;
+        });
+    }
+    getNextTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._queue.shift();
+        });
+    }
+    pushTask(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._queue.length < this.maxQueued) {
+                this._queue.push(args);
+            }
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._queue = [];
+        });
+    }
+}
+exports.default = MemoryStore;
+//# sourceMappingURL=mem-store.js.map

package/dist/mem-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem-store.js","sourceRoot":"","sources":["../src/mem-store.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,MAAa,OAAO;CAEnB;AAFD,0BAEC;AACD,MAAqB,WAAW;IAG9B,YAAY,OAAgB;QAC1B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACnB,CAAC;IACK,OAAO;;YACX,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;QAClC,CAAC;KAAA;IACK,SAAS;;YACb,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAC5B,CAAC;KAAA;IACK,WAAW;;YACf,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAC7B,CAAC;KAAA;IACK,QAAQ,CAAC,IAAW;;YACxB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE;gBACvC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACxB;QACH,CAAC;KAAA;IACK,KAAK;;YACT,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACnB,CAAC;KAAA;CACF;AAxBD,8BAwBC"}

package/package.json

@@ -6,29 +6,34 @@
     "flow",
     "time"
   ],
-  "version": "1.2.0",
+  "version": "2.1.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/fent/timequeue.js.git"
   },
-  "author": "fent (https://github.com/fent)",
-  "main": "./lib/index.js",
+  "author": "fent <fentbox@gmail.com> (https://github.com/fent)",
+  "main": "./dist/index.js",
   "files": [
-    "lib"
+    "dist"
   ],
   "scripts": {
-    "test": "istanbul cover node_modules/.bin/_mocha -- test/*-test.js"
-  },
-  "directories": {
-    "lib": "./lib"
+    "prepare": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "nyc --extension .ts --reporter=lcov --reporter=text-summary npm run test:unit",
+    "test:unit": "mocha -- --require ts-node/register test/*-test.ts"
   },
   "devDependencies": {
-    "istanbul": "^0.4.5",
-    "mocha": "^6.0.0",
-    "sinon": "^7.2.3"
+    "@types/mocha": "^7.0.0",
+    "@types/node": "^13.1.6",
+    "@types/sinon": "^9.0.8",
+    "mocha": "^7.0.1",
+    "nyc": "^15.0.0",
+    "sinon": "^9.0.0",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.4"
   },
   "engines": {
-    "node": ">=6"
+    "node": ">=10"
   },
   "license": "MIT"
 }

package/lib/index.js

@@ -1,196 +0,0 @@
-const EventEmitter = require('events').EventEmitter;
-
-
-module.exports = class TimeQueue extends EventEmitter {
-  /**
-   * @constructor
-   * @extends {EventEmitter}
-   * @param {Function(..., Function(!Error, ...)} worker
-   * @param {Object} options
-   * @param   {number} concurrency
-   * @param   {number} time
-   */
-  constructor(worker, options) {
-    super();
-
-    this.worker = worker;
-    options = options || {};
-    this.concurrency = options.concurrency || 1;
-    this.every = options.every || 0;
-    this.maxQueued = options.maxQueued || Infinity;
-    this.timeout = options.timeout || 0;
-    this._queue = [];
-    this._timers = [];
-
-    // How many tasks are currently active.
-    TimeQueue.prototype.active = 0;
-
-    // How many tasks are still being waited on,
-    // in case the `every` option was used.
-    TimeQueue.prototype.intransit = 0;
-
-    // How many tasks are in the queue.
-    TimeQueue.prototype.queued = 0;
-
-    // How many tasks have finished.
-    TimeQueue.prototype.finished = 0;
-  }
-
-
-  /**
-   * Pushes a task onto the queue.
-   *
-   * @param {Object} ...args
-   * @param {Function(!Error, ...)} callback
-   */
-  push(...args) {
-    if (this.isFull()) {
-      return;
-    }
-
-    if (this.intransit < this.concurrency) {
-      this.intransit++;
-      this.active++;
-      if (this.intransit === this.concurrency) {
-        this.emit('full');
-      }
-      this._process(args);
-    } else {
-      this._queue.push(args);
-      this.queued++;
-    }
-  }
-
-
-  /**
-   * Returns true if queue is full.
-   *
-   * @return {boolean}
-   */
-  isFull() {
-    return this.maxQueued === this.queued;
-  }
-
-
-  /**
-   * Starts a task
-   *
-   * @param {Array.<Object>} args
-   */
-  _process(args) {
-    const callback = args.splice(this.worker.length - 1, 1)[0];
-    let finished = false;
-    let every = ~~this.every;
-    let timedOut;
-
-    if (every) {
-      timedOut = false;
-
-      this._timers.push(setTimeout(() => {
-        timedOut = true;
-        this._timers.shift();
-        if (finished) {
-          this._next();
-        }
-      }, every));
-
-    } else {
-      timedOut = true;
-    }
-
-    // If `timeout` option is set, set a timeout to check the task doesn't lag.
-    let taskTimedOut = false;
-    let callbackCalled = false;
-    let timeout = ~~this.timeout;
-    let tid;
-
-    const taskCallback = (err, ...args) => {
-      // If this task has timed out, and the callback is called again
-      // from the worker, ignore it.
-      if (!taskTimedOut) {
-        clearTimeout(tid);
-      } else {
-        return;
-      }
-
-      // Check that this callback is only called once.
-      if (callbackCalled && !taskTimedOut) {
-        throw Error('Callback from worker should only be called once');
-      }
-      callbackCalled = true;
-
-      this.finished++;
-      this.active--;
-
-      if (typeof callback === 'function') {
-        // If a callback was given with the task,
-        // call it when the task is finished.
-        callback(err, ...args);
-
-      } else if (err) {
-        // Otherwise emit an `error` event if there was an error with the task.
-        this.emit('error', err);
-      }
-
-      finished = true;
-      if (timedOut) {
-        this._next();
-      }
-    };
-
-    if (timeout) {
-      tid = setTimeout(() => {
-        const err = new Error('Task timed out');
-        err.args = args;
-        taskCallback(err);
-        taskTimedOut = true;
-      }, timeout);
-    }
-
-    // Add missing arguments.
-    while (args.length < this.worker.length - 1) {
-      args.push(undefined);
-    }
-
-    // Add custom callback to args.
-    const args2 = args.slice();
-    args2.push(taskCallback);
-
-    // Call the worker.
-    this.worker(...args2);
-  }
-
-
-  /**
-   * Called when a task finishes. Looks at the queue and processes the next
-   * waiting task.
-   */
-  _next() {
-    if (this.intransit <= this.concurrency && this._queue.length) {
-      this.queued--;
-      this.active++;
-      this._process(this._queue.shift());
-
-      if (this._queue.length === 0) {
-        this.emit('empty');
-      }
-
-    } else if (--this.intransit === 0) {
-      this.emit('drain');
-    }
-  }
-
-
-  /**
-   * Empties the queue and kills the timers.
-   * Active tasks will still be completed.
-   */
-  die() {
-    this._queue = [];
-    this._timers.forEach(clearTimeout);
-    this._timers = [];
-    this.intransit = 0;
-    this.active = 0;
-    this.queued = 0;
-  }
-};