add indication if the task started running

Author: regevbr

.travis.yml

@@ -4,6 +4,8 @@ node_js:
   - "8"
   - "10"
   - "12"
+  - "14"
+  - "15"
 install:
   - npm install
 script:

CHANGELOG.md

@@ -5,6 +5,10 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ## Development
 - nothing yet
 
+## v0.1.0
+
+Expose if the enqueued task already started running
+
 ## v0.0.2
 
 Use new version of linked-list

README.md

@@ -211,6 +211,12 @@ Type: `Promise<T>`
 
 A promise that will be resolved with the result of `fn`.
 
+###### started
+
+Type: `boolean`
+
+Indicates if the task has already started to run
+
 ##### fn
 
 Type: `Function`

package.json

@@ -1,6 +1,6 @@
 {
   "name": "promise-blocking-queue",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Memory optimized promise blocking queue with concurrency control",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -54,23 +54,23 @@
   },
   "homepage": "https://github.com/PruvoNet/promise-blocking-queue#readme",
   "devDependencies": {
-    "@types/chai": "^4.1.7",
-    "@types/chai-as-promised": "^7.1.0",
-    "@types/mocha": "^5.2.7",
-    "@types/node": "^12.6.3",
+    "@types/chai": "^4.2.15",
+    "@types/chai-as-promised": "^7.1.3",
+    "@types/mocha": "^8.2.1",
+    "@types/node": "^14.14.31",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "coveralls": "^3.0.5",
-    "delay": "^4.3.0",
+    "coveralls": "^3.1.0",
+    "delay": "^5.0.0",
     "dirty-chai": "^2.0.1",
     "istanbul": "^0.4.5",
-    "mocha": "^6.1.4",
-    "sinon": "^7.3.2",
-    "sinon-chai": "^3.3.0",
-    "sleep-promise": "^8.0.1",
-    "ts-node": "^8.3.0",
-    "tslint": "^5.18.0",
-    "typescript": "^3.5.3"
+    "mocha": "^6.2.3",
+    "sinon": "^9.2.4",
+    "sinon-chai": "^3.5.0",
+    "sleep-promise": "^9.1.0",
+    "ts-node": "^9.1.1",
+    "tslint": "^6.1.3",
+    "typescript": "^4.1.5"
   },
   "dependencies": {
     "linked-list": "^2.1.0"

src/BlockingQueue.ts

@@ -13,7 +13,7 @@ interface IBlockingQueueEvents {
 
 type MessageEmitter = StrictEventEmitter<EventEmitter, IBlockingQueueEvents>;
 
-type PromiseResolve<T> = (value?: T | PromiseLike<T>) => void;
+type PromiseResolve<T> = (value: T | PromiseLike<T>) => void;
 
 interface IPromiseParts<T> {
     promise: Promise<T>;
@@ -67,12 +67,15 @@ export class BlockingQueue extends (EventEmitter as new() => MessageEmitter) {
             fnResolve: fnPromiseParts.resolve,
             enqueueResolve: enqueuePromiseParts.resolve,
         };
+        let started = false;
         if (this.activeCount < this._options.concurrency) {
+            started = true;
             this._run(item);
         } else {
             this._queue.append(new Node(item));
         }
         return {
+            started,
             enqueuePromise: enqueuePromiseParts.promise,
             fnPromise: fnPromiseParts.promise,
         };

src/types.ts

@@ -9,4 +9,5 @@ export type QueueFn<T, P extends any[]> = ((...args: P) => Promise<T> | T);
 export interface IEnqueueResult<T> {
     enqueuePromise: Promise<void>;
     fnPromise: Promise<T>;
+    started: boolean;
 }

test/src/index.spec.ts

@@ -79,6 +79,7 @@ describe('promise blocking queue', () => {
                 const item = queue.enqueue((x: number, y: number): string => {
                     return `${x + y}`;
                 }, 5, 6);
+                expect(item.started).to.eql(true);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(0);
                 return item.enqueuePromise
@@ -97,6 +98,7 @@ describe('promise blocking queue', () => {
                 const item = queue.enqueue((x: number, y: number): Promise<string> => {
                     return Promise.resolve(`${x + y}`);
                 }, 5, 6);
+                expect(item.started).to.eql(true);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(0);
                 return item.enqueuePromise
@@ -115,6 +117,7 @@ describe('promise blocking queue', () => {
                 const item = queue.enqueue((): string => {
                     return `11`;
                 });
+                expect(item.started).to.eql(true);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(0);
                 return item.enqueuePromise
@@ -133,6 +136,7 @@ describe('promise blocking queue', () => {
                 const item = queue.enqueue((): Promise<string> => {
                     return Promise.resolve(`11`);
                 });
+                expect(item.started).to.eql(true);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(0);
                 return item.enqueuePromise
@@ -163,9 +167,11 @@ describe('promise blocking queue', () => {
                 const events: IEvent[] = [];
                 const queue = new BlockingQueue({concurrency: 1});
                 const resultOne = queue.enqueue(constructRunFn(100), 'one', events);
+                expect(resultOne.started).to.eql(true);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(0);
                 const resultTwo = queue.enqueue(constructRunFn(100), 'two', events);
+                expect(resultTwo.started).to.eql(false);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(1);
                 return resultOne.enqueuePromise
@@ -196,12 +202,15 @@ describe('promise blocking queue', () => {
                 const events: IEvent[] = [];
                 const queue = new BlockingQueue({concurrency: 2});
                 const resultOne = queue.enqueue(constructRunFn(100), 'one', events);
+                expect(resultOne.started).to.eql(true);
                 expect(queue.activeCount).to.eql(1);
                 expect(queue.pendingCount).to.eql(0);
                 const resultTwo = queue.enqueue(constructRunFn(100), 'two', events);
+                expect(resultTwo.started).to.eql(true);
                 expect(queue.activeCount).to.eql(2);
                 expect(queue.pendingCount).to.eql(0);
                 const resultThree = queue.enqueue(constructRunFn(100), 'three', events);
+                expect(resultThree.started).to.eql(false);
                 expect(queue.activeCount).to.eql(2);
                 expect(queue.pendingCount).to.eql(1);
                 return Promise.all([resultOne.enqueuePromise, resultTwo.enqueuePromise])
@@ -237,6 +246,7 @@ describe('promise blocking queue', () => {
                 queue.enqueue(constructRunFn(200), 'one', events);
                 queue.enqueue(constructRunFn(200), 'two', events);
                 const resultThree = queue.enqueue(constructRunFn(0), 'three', events);
+                expect(resultThree.started).to.eql(false);
                 return resultThree.enqueuePromise
                     .then(() => {
                         return resultThree.fnPromise;
@@ -264,7 +274,9 @@ describe('promise blocking queue', () => {
                 });
                 queue.enqueue(constructRunFn(100), 'one', events);
                 const resultTwo = queue.enqueue(constructRunFn(200), 'two', events);
+                expect(resultTwo.started).to.eql(true);
                 const resultThree = queue.enqueue(constructRunFn(200), 'three', events);
+                expect(resultThree.started).to.eql(false);
                 return resultTwo.fnPromise
                     .then(() => {
                         expect(isEmpty).to.eql(true);