perf(retry): delete props in retryJob lua script

src/classes/job.ts

@@ -842,25 +842,18 @@ export class Job<
   }
 
   /**
-   * Attempts to retry the job. Only a job that has failed can be retried.
+   * Attempts to retry the job. Only a job that has failed or completed can be retried.
    *
+   * @param state - completed / failed
    * @returns If resolved and return code is 1, then the queue emits a waiting event
    * otherwise the operation was not a success and throw the corresponding error. If the promise
    * rejects, it indicates that the script failed to execute
    */
   async retry(state: 'completed' | 'failed' = 'failed'): Promise<void> {
-    const client = await this.queue.client;
-
     this.failedReason = null;
     this.finishedOn = null;
     this.processedOn = null;
-
-    await client.hdel(
-      this.queue.toKey(this.id),
-      'finishedOn',
-      'processedOn',
-      'failedReason',
-    );
+    this.returnvalue = null;
 
     return Scripts.reprocessJob(this.queue, this, state);
   }

src/classes/scripts.ts

@@ -611,7 +611,7 @@ export class Scripts {
   static retryJobArgs<T = any, R = any, N extends string = string>(
     queue: MinimalQueue,
     job: Job<T, R, N>,
-  ) {
+  ): string[] {
     const jobId = job.id;
 
     const keys = ['active', 'wait', jobId].map(function (name) {
@@ -653,7 +653,11 @@ export class Scripts {
       queue.toKey('wait'),
     ];
 
-    const args = [job.id, (job.opts.lifo ? 'R' : 'L') + 'PUSH'];
+    const args = [
+      job.id,
+      (job.opts.lifo ? 'R' : 'L') + 'PUSH',
+      state === 'failed' ? 'failedReason' : 'returnvalue',
+    ];
 
     const result = await (<any>client).reprocessJob(keys.concat(args));
 

src/commands/reprocessJob-4.lua

@@ -7,8 +7,9 @@
     KEYS[3] job state
     KEYS[4] wait key
 
-    ARGV[1] job.id,
+    ARGV[1] job.id
     ARGV[2] (job.opts.lifo ? 'R' : 'L') + 'PUSH'
+    ARGV[3] propVal - failedReason/returnvalue
 
   Output:
     1  means the operation was a success
@@ -20,6 +21,7 @@ if (rcall("EXISTS", KEYS[1]) == 1) then
   local jobId = ARGV[1]
   if (rcall("ZREM", KEYS[3], jobId) == 1) then
     rcall(ARGV[2], KEYS[4], jobId)
+    rcall("HDEL", KEYS[1], "finishedOn", "processedOn", ARGV[3])
 
     -- Emit waiting event
     rcall("XADD", KEYS[2], "*", "event", "waiting", "jobId", jobId);

tests/test_worker.ts

@@ -1050,7 +1050,7 @@ describe('workers', function () {
   it('process a job that returns data with a circular dependency', async () => {
     const worker = new Worker(
       queueName,
-      async job => {
+      async () => {
         const circular = { x: {} };
         circular.x = circular;
         return circular;
@@ -1113,7 +1113,7 @@ describe('workers', function () {
 
     const worker = new Worker(
       queueName,
-      async job => {
+      async () => {
         if (!failedOnce) {
           throw notEvenErr;
         }
@@ -1158,14 +1158,55 @@ describe('workers', function () {
     await worker.close();
   });
 
+  it('retry a job that completes', async () => {
+    let completedOnce = false;
+
+    const worker = new Worker(
+      queueName,
+      async () => {
+        if (!completedOnce) {
+          return 1;
+        }
+        return 2;
+      },
+      { connection },
+    );
+    await worker.waitUntilReady();
+
+    let count = 1;
+    const completing = new Promise<void>((resolve, reject) => {
+      worker.once('completed', async (job, result) => {
+        try {
+          expect(job).to.be.ok;
+          expect(job.data.foo).to.be.eql('bar');
+          expect(result).to.be.eql(count++);
+          completedOnce = true;
+        } catch (err) {
+          reject(err);
+        }
+        resolve();
+      });
+    });
+
+    const job = await queue.add('test', { foo: 'bar' });
+    expect(job.id).to.be.ok;
+    expect(job.data.foo).to.be.eql('bar');
+
+    await completing;
+    await job.retry('completed');
+    await completing;
+
+    await worker.close();
+  });
+
   it('retry a job that fails using job retry method', async () => {
     let called = 0;
     let failedOnce = false;
     const notEvenErr = new Error('Not even!');
 
     const worker = new Worker(
       queueName,
-      async job => {
+      async () => {
         called++;
         if (called % 2 !== 0) {
           throw notEvenErr;
@@ -1192,11 +1233,13 @@ describe('workers', function () {
       expect(job.failedReason).to.be.null;
       expect(job.processedOn).to.be.null;
       expect(job.finishedOn).to.be.null;
+      expect(job.returnvalue).to.be.null;
 
       const updatedJob = await queue.getJob(job.id);
       expect(updatedJob.failedReason).to.be.undefined;
       expect(updatedJob.processedOn).to.be.undefined;
       expect(updatedJob.finishedOn).to.be.undefined;
+      expect(updatedJob.returnvalue).to.be.null;
 
       await worker.resume();
     });
@@ -1216,7 +1259,7 @@ describe('workers', function () {
 
     const worker = new Worker(
       queueName,
-      async job => {
+      async () => {
         return delay(2000);
       },
       {