From dcf51def633b73123eb2022430fe0c0c3e1e885e Mon Sep 17 00:00:00 2001
From: myckhel <myckhel1@hotmail.com>
Date: Fri, 15 Jan 2021 14:29:14 +0100
Subject: [PATCH 1/6] implemented queue cancelJob

 This is the commit message #2:

added cancel job example

fixed ts errors
---
 example/App.tsx | 23 +++++++++++++++---
 src/Queue.ts    | 32 +++++++++++++++++++++++--
 src/Worker.ts   | 64 +++++++++++++++++++++++++++++++++++--------------
 tsconfig.json   |  1 +
 4 files changed, 97 insertions(+), 23 deletions(-)

diff --git a/example/App.tsx b/example/App.tsx
index 0c1cdf2..ec66261 100644
--- a/example/App.tsx
+++ b/example/App.tsx
@@ -2,7 +2,7 @@ import * as React from 'react';
 import { Button, View } from 'react-native';
 
 import queue from '../src/Queue';
-import { Worker } from '../src/Worker';
+import { Worker, CANCEL } from '../src/Worker';
 
 export interface IAppProps {}
 
@@ -21,12 +21,21 @@ export default class App extends React.Component<IAppProps, IAppState> {
         });
         queue.addWorker(
             new Worker('testWorker', async (payload) => {
-                return new Promise((resolve) => {
-                    setTimeout(() => {
+              let cancel
+                const promise = new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
                         console.log(payload);
                         resolve();
                     }, 5000);
+
+                    cancel = () => {
+                      clearTimeout(timeout)
+                      reject({message: 'canceled'})
+                    }
                 });
+
+                promise[CANCEL] = cancel
+                return promise
             })
         );
     }
@@ -39,6 +48,14 @@ export default class App extends React.Component<IAppProps, IAppState> {
                         queue.addJob('testWorker', { id: counter++ }, undefined, false);
                     }}
                 />
+                <Button
+                    title='cancel Job'
+                    onPress={() => {
+                        // get first running job id
+                        const runningPromiseKey = Object.keys(queue.runningJobPromises)[0]
+                        queue.cancelJob(runningPromiseKey, {message: 'Canceled'})
+                    }}
+                />
                 <Button
                     title='start Queue'
                     onPress={() => {
diff --git a/src/Queue.ts b/src/Queue.ts
index 33b243a..c99fd6d 100644
--- a/src/Queue.ts
+++ b/src/Queue.ts
@@ -3,7 +3,7 @@ import { NativeModules } from 'react-native';
 import { FALSE, Job, RawJob } from './models/Job';
 import { JobStore } from './models/JobStore';
 import { Uuid } from './utils/Uuid';
-import { Worker } from './Worker';
+import { Worker, CANCEL } from './Worker';
 
 /**
  * Options to configure the queue
@@ -75,10 +75,12 @@ export class Queue {
     private onQueueFinish: (executedJobs: Array<Job<any>>) => void;
 
     private queuedJobExecuter: any[] = [];
+    private runningJobPromises: {[key: string]: any};
 
     private constructor() {
         this.jobStore = NativeModules.JobQueue;
         this.workers = {};
+        this.runningJobPromises = {};
         this.isActive = false;
 
         this.timeoutId = 0;
@@ -182,6 +184,18 @@ export class Queue {
     stop() {
         this.isActive = false;
     }
+
+    /**
+     * cancel running job
+     */
+    cancelJob(jobId: string, exception: Error) {
+      const promise = this.runningJobPromises[jobId]
+      if (promise && typeof promise[CANCEL] === 'function') {
+        promise[CANCEL](exception || new Error(`canceled`))
+      } else {
+        throw new Error(`Job with id ${jobId} not currently running`);
+      }
+    }
     private resetActiveJob = async (job: RawJob) => {
         this.jobStore.updateJob({ ...job, ...{ active: FALSE } });
     };
@@ -277,14 +291,25 @@ export class Queue {
     }
 
     private excuteJob = async (rawJob: RawJob) => {
+        const worker = this.workers[rawJob.workerName];
+        const payload = JSON.parse(rawJob.payload);
+        const job = { ...rawJob, ...{ payload } };
+
         try {
             this.activeJobCount++;
             if (!this.workers[rawJob.workerName]) {
                 throw new Error(`Missing worker with name ${rawJob.workerName}`);
             }
-            await this.workers[rawJob.workerName].execute(rawJob);
+            const promise = worker.execute(rawJob);
+
+            this.runningJobPromises[rawJob.id] = promise
+            await promise
+
+            worker.makeSuccess(job)
+
             this.jobStore.removeJob(rawJob);
         } catch (error) {
+            worker.makeFailure(job, error);
             const { attempts } = rawJob;
             // tslint:disable-next-line: prefer-const
             let { errors, failedAttempts } = JSON.parse(rawJob.metaData);
@@ -296,6 +321,9 @@ export class Queue {
             const metaData = JSON.stringify({ errors: [...errors, error], failedAttempts });
             this.jobStore.updateJob({ ...rawJob, ...{ active: FALSE, metaData, failed } });
         } finally {
+            delete this.runningJobPromises[job.id]
+            worker.decreaseExecutionCount();
+            worker.makeCompletion(job);
             this.executedJobs.push(rawJob);
             this.activeJobCount--;
         }
diff --git a/src/Worker.ts b/src/Worker.ts
index 05f0950..02125bd 100644
--- a/src/Worker.ts
+++ b/src/Worker.ts
@@ -1,5 +1,7 @@
 import { Job, RawJob } from './models/Job';
 
+export const CANCEL = 'rn_job_queue_cancel'
+
 export interface WorkerOptions<P extends object> {
     onStart?: (job: Job<P>) => void;
     onSuccess?: (job: Job<P>) => void;
@@ -7,6 +9,10 @@ export interface WorkerOptions<P extends object> {
     onCompletion?: (job: Job<P>) => void;
     concurrency?: number;
 }
+
+export interface CancellablePromise<T> extends Promise<T> {
+  rn_job_queue_cancel?: () => void
+}
 /**
  * @typeparam P specifies the Type of the Job-Payload.
  */
@@ -15,7 +21,7 @@ export class Worker<P extends object> {
     public readonly concurrency: number;
 
     private executionCount: number;
-    private executer: (payload: P) => Promise<any>;
+    private executer: (payload: P) => CancellablePromise<any>;
 
     private onStart: (job: Job<P>) => void;
     private onSuccess: (job: Job<P>) => void;
@@ -66,33 +72,55 @@ export class Worker<P extends object> {
      * This method should not be invoked manually and is used by the queue to execute jobs
      * @param job to be executed
      */
-    async execute(rawJob: RawJob) {
+    execute(rawJob: RawJob) {
         const { timeout } = rawJob;
         const payload: P = JSON.parse(rawJob.payload);
         const job = { ...rawJob, ...{ payload } };
         this.executionCount++;
-        try {
-            this.onStart(job);
-            if (timeout > 0) {
-                await this.executeWithTimeout(job, timeout);
-            } else {
-                await this.executer(payload);
-            }
-            this.onSuccess(job);
-        } catch (error) {
-            this.onFailure(job, error);
-            throw error;
-        } finally {
-            this.executionCount--;
-            this.onCompletion(job);
+        this.onStart(job);
+        if (timeout > 0) {
+            return this.executeWithTimeout(job, timeout);
+        } else {
+            return this.executer(payload);
         }
     }
-    private async executeWithTimeout(job: Job<P>, timeout: number) {
+    private executeWithTimeout(job: Job<P>, timeout: number) {
+      let cancel
+      const promise: CancellablePromise<any> = new Promise(async (resolve, reject) => {
         const timeoutPromise = new Promise((resolve, reject) => {
             setTimeout(() => {
                 reject(new Error(`Job ${job.id} timed out`));
             }, timeout);
         });
-        await Promise.race([timeoutPromise, this.executer(job.payload)]);
+        const executerPromise = this.executer(job.payload)
+        if (executerPromise) {
+          cancel = executerPromise[CANCEL]
+          try {
+            await Promise.race([timeoutPromise, executerPromise]);
+            resolve()
+          } catch (error) {
+            // cancel task if has cancel method
+            if (executerPromise[CANCEL] && typeof executerPromise[CANCEL] === 'function') {
+              executerPromise[CANCEL]!()
+            }
+            reject(error);
+          }
+        }
+      })
+      promise[CANCEL] = cancel
+      return promise
+    }
+
+    makeSuccess(job: Job<P>) {
+      this.onSuccess(job)
+    }
+    makeFailure(job: Job<P>, error: Error) {
+      this.onFailure(job, error)
+    }
+    makeCompletion(job: Job<P>) {
+      this.onCompletion(job)
+    }
+    decreaseExecutionCount() {
+      this.executionCount--;
     }
 }
diff --git a/tsconfig.json b/tsconfig.json
index 9b032a0..4eaa91b 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "skipLibCheck": true,
     "resolveJsonModule": true,
     "target": "es2017",
     "module": "commonjs",

From d1ca34b494e630777b8b3fe57ce85d9066d0724a Mon Sep 17 00:00:00 2001
From: Myckhel <myckhel1@hotmail.com>
Date: Sat, 6 Feb 2021 12:20:53 +0100
Subject: [PATCH 2/6] added `cancel` method to docs - updated example - change
 make methods name to trigger - added timeout note to addJob doc section

---
 docs/classes/queue.md | 59 ++++++++++++++++++++++++++++++++++++++++++-
 example/App.tsx       | 17 +++++++++----
 src/Queue.ts          |  8 +++---
 src/Worker.ts         |  6 ++---
 4 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/docs/classes/queue.md b/docs/classes/queue.md
index aa110c5..119fcbb 100644
--- a/docs/classes/queue.md
+++ b/docs/classes/queue.md
@@ -39,6 +39,7 @@ queue.addJob("testWorker",{text:"Job example palyoad content text",delay:5000})
 ### Methods
 
 * [addJob](queue.md#addjob)
+* [cancelJob](queue.md#canceljob)
 * [addWorker](queue.md#addworker)
 * [configure](queue.md#configure)
 * [getJobs](queue.md#getjobs)
@@ -112,12 +113,68 @@ Name | Type | Default |
 `priority` | number | 0 |
 `timeout` | number | 0 |
 
+***note*** if a job timeout and it has `react-native-job-queue` `CANCEL` method then the cancel method will be invoked
+
 ▪`Default value`  **startQueue**: *boolean*= true
 
 **Returns:** *void*
 
 ___
 
+###  canceljob
+▸ **cancelJob**(`jobId`: string, `exception`: Error): *void*
+
+*Defined in [Queue.ts:191](https://github.com/SimonErm/react-native-job-queue/blob/acf0a20/src/Queue.ts#L191)*
+
+cancel running job by id
+
+**Parameters:**
+
+Name | Type | Description |
+------ | ------ | ------ |
+`jobId` | *string* | currently running job id  |
+`exception?` | Error<*any*> | Error object |
+
+**Returns:** *void*
+
+***note*** before you cancel a job, you must have implemented a cancel method for the returned promise of the [Worker](worker.md).
+see example below
+
+**Example:**
+```jsx
+import queue, {Worker, CANCEL} from 'react-native-job-queue';
+
+queue.addWorker(
+  new Worker('testWorker', (payload) => {
+    let cancel
+    const promise = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        console.log(payload);
+        resolve();
+      }, 5000);
+
+      cancel = () => {
+        clearTimeout(timeout)
+        reject({message: 'canceled'})
+      }
+    });
+
+    promise[CANCEL] = cancel
+    return promise
+  },{
+    onStart: ({id}) => {
+      /* cancel the job after 2sec */
+      setTimeout(() => {
+        queue.cancelJob(id, {message: 'Canceled'})
+      }, 2000)
+    },
+  })
+);
+
+
+```
+___
+
 ###  addWorker
 
 ▸ **addWorker**(`worker`: [Worker](worker.md)‹*any*›): *void*
@@ -203,4 +260,4 @@ ___
 
 stop the queue from executing queued jobs
 
-**Returns:** *void*
\ No newline at end of file
+**Returns:** *void*
diff --git a/example/App.tsx b/example/App.tsx
index ec66261..5eab5d2 100644
--- a/example/App.tsx
+++ b/example/App.tsx
@@ -11,7 +11,9 @@ let counter = 0;
 export default class App extends React.Component<IAppProps, IAppState> {
     constructor(props: IAppProps) {
         super(props);
-        this.state = {};
+        this.state = {
+          jobId: null,
+        };
     }
     componentDidMount() {
         queue.configure({
@@ -20,7 +22,7 @@ export default class App extends React.Component<IAppProps, IAppState> {
             }
         });
         queue.addWorker(
-            new Worker('testWorker', async (payload) => {
+            new Worker('testWorker', (payload) => {
               let cancel
                 const promise = new Promise((resolve, reject) => {
                     const timeout = setTimeout(() => {
@@ -36,6 +38,9 @@ export default class App extends React.Component<IAppProps, IAppState> {
 
                 promise[CANCEL] = cancel
                 return promise
+            },{
+              onStart: ({id}) => this.setState({jobId: id}),
+              onCompletion: () => this.setState({jobId: null}),
             })
         );
     }
@@ -51,9 +56,11 @@ export default class App extends React.Component<IAppProps, IAppState> {
                 <Button
                     title='cancel Job'
                     onPress={() => {
-                        // get first running job id
-                        const runningPromiseKey = Object.keys(queue.runningJobPromises)[0]
-                        queue.cancelJob(runningPromiseKey, {message: 'Canceled'})
+                      if(this.state.jobId){
+                        queue.cancelJob(this.state.jobId, {message: 'Canceled'})
+                      } else {
+                        console.log("no job running");
+                      }
                     }}
                 />
                 <Button
diff --git a/src/Queue.ts b/src/Queue.ts
index c99fd6d..25e8210 100644
--- a/src/Queue.ts
+++ b/src/Queue.ts
@@ -188,7 +188,7 @@ export class Queue {
     /**
      * cancel running job
      */
-    cancelJob(jobId: string, exception: Error) {
+    cancelJob(jobId: string, exception?: Error) {
       const promise = this.runningJobPromises[jobId]
       if (promise && typeof promise[CANCEL] === 'function') {
         promise[CANCEL](exception || new Error(`canceled`))
@@ -305,11 +305,11 @@ export class Queue {
             this.runningJobPromises[rawJob.id] = promise
             await promise
 
-            worker.makeSuccess(job)
+            worker.triggerSuccess(job)
 
             this.jobStore.removeJob(rawJob);
         } catch (error) {
-            worker.makeFailure(job, error);
+            worker.triggerFailure(job, error);
             const { attempts } = rawJob;
             // tslint:disable-next-line: prefer-const
             let { errors, failedAttempts } = JSON.parse(rawJob.metaData);
@@ -323,7 +323,7 @@ export class Queue {
         } finally {
             delete this.runningJobPromises[job.id]
             worker.decreaseExecutionCount();
-            worker.makeCompletion(job);
+            worker.triggerCompletion(job);
             this.executedJobs.push(rawJob);
             this.activeJobCount--;
         }
diff --git a/src/Worker.ts b/src/Worker.ts
index 02125bd..1f1cbfa 100644
--- a/src/Worker.ts
+++ b/src/Worker.ts
@@ -111,13 +111,13 @@ export class Worker<P extends object> {
       return promise
     }
 
-    makeSuccess(job: Job<P>) {
+    triggerSuccess(job: Job<P>) {
       this.onSuccess(job)
     }
-    makeFailure(job: Job<P>, error: Error) {
+    triggerFailure(job: Job<P>, error: Error) {
       this.onFailure(job, error)
     }
-    makeCompletion(job: Job<P>) {
+    triggerCompletion(job: Job<P>) {
       this.onCompletion(job)
     }
     decreaseExecutionCount() {

From 659c8946f86071b5e195a791598baec39882daf7 Mon Sep 17 00:00:00 2001
From: Myckhel <myckhel1@hotmail.com>
Date: Sat, 6 Feb 2021 12:32:46 +0100
Subject: [PATCH 3/6] proper cancelJob error message

---
 src/Queue.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Queue.ts b/src/Queue.ts
index 25e8210..f82ee35 100644
--- a/src/Queue.ts
+++ b/src/Queue.ts
@@ -192,6 +192,8 @@ export class Queue {
       const promise = this.runningJobPromises[jobId]
       if (promise && typeof promise[CANCEL] === 'function') {
         promise[CANCEL](exception || new Error(`canceled`))
+      } else if(!promise[CANCEL]){
+        console.warn("Worker does not have a cancel method implemented")
       } else {
         throw new Error(`Job with id ${jobId} not currently running`);
       }

From 05cd5cce59d2b00481618fb457b912dd7cecac17 Mon Sep 17 00:00:00 2001
From: myckhel <myckhel1@hotmail.com>
Date: Wed, 10 Feb 2021 09:35:37 +0100
Subject: [PATCH 4/6] added jobCancel test case

---
 src/__tests__/Queue.test.ts | 48 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/__tests__/Queue.test.ts b/src/__tests__/Queue.test.ts
index 6a33423..32b6a78 100644
--- a/src/__tests__/Queue.test.ts
+++ b/src/__tests__/Queue.test.ts
@@ -1,6 +1,6 @@
 import { Job } from '../models/Job';
 import queue from '../Queue';
-import { Worker } from '../Worker';
+import { Worker, CANCEL } from '../Worker';
 
 export interface Payload {
     test: string;
@@ -67,6 +67,52 @@ describe('Queue Basics', () => {
         queue.addJob('testWorker', { test: 'priority_id' }, { priority: 100, attempts: 0, timeout: 0 }, false);
         queue.start();
     });
+    it('handle job canceling', (done) => {
+      const calledOrder: string[] = [];
+      const expectedCallOrder = ['failed', 'completed'];
+
+      queue.addWorker(
+        new Worker<Payload>(
+          'testWorker',
+          (payload) => {
+            let cancel
+            const promise = new Promise((resolve, reject) => {
+              const timeout = setTimeout(() => {
+                resolve();
+              }, 3000);
+
+              cancel = () => {
+                clearTimeout(timeout)
+                reject({message: 'canceled'})
+              }
+            });
+
+            promise[CANCEL] = cancel
+            return promise
+          },
+          {
+            onStart: ({id}) => {
+              /* cancel the job after 1sec */
+              setTimeout(() => {
+                queue.cancelJob(id, {message: 'canceled'})
+              }, 1000)
+            },
+            onFailure: (_, error) => {
+              calledOrder.push('failed')
+              expect(error).toHaveProperty('message', 'canceled');
+              done();
+            },
+            onCompletion: () => {
+              calledOrder.push('completed')
+              expect(calledOrder).toEqual(expectedCallOrder);
+              done();
+            },
+          }
+        )
+      )
+      queue.addJob('testWorker', { test: '1' }, { attempts: 0, priority: 0 });
+      queue.start();
+    });
     it('handle attempts correctly', (done) => {
         const onQueueFinish = () => {
             expect(executer).toBeCalledTimes(6);

From 3be743f9f2191cef1594dbc11b03fcc24980cc7a Mon Sep 17 00:00:00 2001
From: myckhel <myckhel1@hotmail.com>
Date: Fri, 12 Feb 2021 17:37:22 +0100
Subject: [PATCH 5/6] fixed ts errors

---
 example/App.tsx             | 6 +++---
 src/__tests__/Queue.test.ts | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/example/App.tsx b/example/App.tsx
index 5eab5d2..bf7f335 100644
--- a/example/App.tsx
+++ b/example/App.tsx
@@ -2,7 +2,7 @@ import * as React from 'react';
 import { Button, View } from 'react-native';
 
 import queue from '../src/Queue';
-import { Worker, CANCEL } from '../src/Worker';
+import { Worker, CANCEL, CancellablePromise } from '../src/Worker';
 
 export interface IAppProps {}
 
@@ -24,7 +24,7 @@ export default class App extends React.Component<IAppProps, IAppState> {
         queue.addWorker(
             new Worker('testWorker', (payload) => {
               let cancel
-                const promise = new Promise((resolve, reject) => {
+                const promise: CancellablePromise<any> = new Promise((resolve, reject) => {
                     const timeout = setTimeout(() => {
                         console.log(payload);
                         resolve();
@@ -32,7 +32,7 @@ export default class App extends React.Component<IAppProps, IAppState> {
 
                     cancel = () => {
                       clearTimeout(timeout)
-                      reject({message: 'canceled'})
+                      reject(new Error('canceled'))
                     }
                 });
 
diff --git a/src/__tests__/Queue.test.ts b/src/__tests__/Queue.test.ts
index e5b382f..93745fc 100644
--- a/src/__tests__/Queue.test.ts
+++ b/src/__tests__/Queue.test.ts
@@ -1,6 +1,6 @@
 import { Job } from '../models/Job';
 import queue from '../Queue';
-import { Worker, CANCEL } from '../Worker';
+import { Worker, CANCEL, CancellablePromise } from '../Worker';
 
 export interface Payload {
     test: string;
@@ -76,7 +76,7 @@ describe('Queue Basics', () => {
           'testWorker',
           (payload) => {
             let cancel
-            const promise = new Promise((resolve, reject) => {
+            const promise: CancellablePromise<any> = new Promise((resolve, reject) => {
               const timeout = setTimeout(() => {
                 resolve();
               }, 3000);
@@ -94,7 +94,7 @@ describe('Queue Basics', () => {
             onStart: ({id}) => {
               /* cancel the job after 1sec */
               setTimeout(() => {
-                queue.cancelJob(id, {message: 'canceled'})
+                queue.cancelJob(id, new Error('canceled'))
               }, 1000)
             },
             onFailure: (_, error) => {
@@ -110,7 +110,7 @@ describe('Queue Basics', () => {
           }
         )
       )
-      queue.addJob('testWorker', { test: '1' }, { attempts: 0, priority: 0 });
+      queue.addJob('testWorker', { test: '1' }, { attempts: 0, timeout: 0, priority: 0 });
       queue.start();
     });
     it('handle attempts correctly', (done) => {

From 3453fdecfc18452b6866a7444abb67cbc553f480 Mon Sep 17 00:00:00 2001
From: myckhel <myckhel1@hotmail.com>
Date: Tue, 23 Feb 2021 22:44:43 +0100
Subject: [PATCH 6/6] addJob returns jobId

---
 docs/classes/queue.md       | 2 +-
 example/App.tsx             | 2 +-
 src/Queue.ts                | 6 +++++-
 src/__tests__/Queue.test.ts | 4 ++--
 4 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/docs/classes/queue.md b/docs/classes/queue.md
index 119fcbb..3232d67 100644
--- a/docs/classes/queue.md
+++ b/docs/classes/queue.md
@@ -117,7 +117,7 @@ Name | Type | Default |
 
 ▪`Default value`  **startQueue**: *boolean*= true
 
-**Returns:** *void*
+**Returns:** *string*
 
 ___
 
diff --git a/example/App.tsx b/example/App.tsx
index bf7f335..8be3135 100644
--- a/example/App.tsx
+++ b/example/App.tsx
@@ -6,7 +6,7 @@ import { Worker, CANCEL, CancellablePromise } from '../src/Worker';
 
 export interface IAppProps {}
 
-export interface IAppState {}
+export interface IAppState {jobId?: string|null}
 let counter = 0;
 export default class App extends React.Component<IAppProps, IAppState> {
     constructor(props: IAppProps) {
diff --git a/src/Queue.ts b/src/Queue.ts
index f82ee35..7f592fa 100644
--- a/src/Queue.ts
+++ b/src/Queue.ts
@@ -138,6 +138,7 @@ export class Queue {
      * @param [payload={}] payload which is passed as parameter to the executer
      * @param [options={ attempts: 0, timeout: 0, priority: 0 }] options to set max attempts, a timeout and a priority
      * @param [startQueue=true] if set to false the queue won't start automaticly when adding a job
+     * @returns job id
      */
     addJob<P extends object>(
         workerName: string,
@@ -146,8 +147,9 @@ export class Queue {
         startQueue: boolean = true
     ) {
         const { attempts = 0, timeout = 0, priority = 0 } = options;
+        const id: string = Uuid.v4();
         const job: RawJob = {
-            id: Uuid.v4(),
+            id,
             payload: JSON.stringify(payload || {}),
             metaData: JSON.stringify({ failedAttempts: 0, errors: [] }),
             active: FALSE,
@@ -166,6 +168,8 @@ export class Queue {
         if (startQueue && !this.isActive) {
             this.start();
         }
+
+        return id;
     }
     /**
      * starts the queue to execute queued jobs
diff --git a/src/__tests__/Queue.test.ts b/src/__tests__/Queue.test.ts
index 93745fc..b1c83d4 100644
--- a/src/__tests__/Queue.test.ts
+++ b/src/__tests__/Queue.test.ts
@@ -79,7 +79,7 @@ describe('Queue Basics', () => {
             const promise: CancellablePromise<any> = new Promise((resolve, reject) => {
               const timeout = setTimeout(() => {
                 resolve();
-              }, 3000);
+              }, 100);
 
               cancel = () => {
                 clearTimeout(timeout)
@@ -95,7 +95,7 @@ describe('Queue Basics', () => {
               /* cancel the job after 1sec */
               setTimeout(() => {
                 queue.cancelJob(id, new Error('canceled'))
-              }, 1000)
+              }, 50)
             },
             onFailure: (_, error) => {
               calledOrder.push('failed')