@nicnocquee/dataqueue 1.35.0-beta.20260224112317 → 1.35.0-beta.20260224120854

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nicnocquee/dataqueue",
-  "version": "1.35.0-beta.20260224112317",
+  "version": "1.35.0-beta.20260224120854",
   "description": "PostgreSQL or Redis-backed job queue for Node.js applications with support for serverless environments",
   "type": "module",
   "main": "dist/index.js",
@@ -23,6 +23,7 @@
     "ci": "npm run build && npm run check-format && npm run check-exports && npm run lint && npm run test",
     "lint": "tsc",
     "test": "vitest run --reporter=verbose",
+    "test:coverage": "vitest run --reporter=verbose --coverage",
     "format": "prettier --write .",
     "check-format": "prettier --check .",
     "check-exports": "attw --pack .",
@@ -56,6 +57,7 @@
     "@arethetypeswrong/cli": "^0.18.2",
     "@types/node": "^24.0.4",
     "@types/pg": "^8.15.4",
+    "@vitest/coverage-v8": "^3.2.4",
     "ioredis": "^5.9.3",
     "node-pg-migrate": "^8.0.3",
     "pnpm": "^9.0.0",

package/src/backends/redis.test.ts

@@ -544,6 +544,71 @@ describe('Redis backend integration', () => {
     expect(job?.status).toBe('pending');
   });
 
+  it('reclaims an in-flight job via supervisor and allows reprocessing', async () => {
+    let firstAttempt = true;
+    const handler = vi.fn(async () => {
+      if (firstAttempt) {
+        firstAttempt = false;
+        await new Promise<void>(() => {});
+      }
+    });
+
+    const jobId = await jobQueue.addJob({
+      jobType: 'test',
+      payload: { foo: 'redis-reclaim-live-loop' },
+    });
+
+    const firstProcessor = jobQueue.createProcessor(
+      {
+        email: vi.fn(async () => {}),
+        sms: vi.fn(async () => {}),
+        test: handler,
+      },
+      { pollInterval: 25, batchSize: 1, concurrency: 1 },
+    );
+    firstProcessor.startInBackground();
+
+    let processingJob = await jobQueue.getJob(jobId);
+    for (let i = 0; i < 50; i++) {
+      if (processingJob?.status === 'processing') {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      processingJob = await jobQueue.getJob(jobId);
+    }
+    expect(processingJob?.status).toBe('processing');
+
+    await firstProcessor.stopAndDrain(25);
+
+    const supervisor = jobQueue.createSupervisor({
+      stuckJobsTimeoutMinutes: 0,
+      cleanupJobsDaysToKeep: 0,
+      cleanupEventsDaysToKeep: 0,
+      expireTimedOutTokens: false,
+    });
+    const maintenance = await supervisor.start();
+    expect(maintenance.reclaimedJobs).toBe(1);
+
+    const reclaimedJob = await jobQueue.getJob(jobId);
+    expect(reclaimedJob?.status).toBe('pending');
+    expect(reclaimedJob?.lockedAt).toBeNull();
+    expect(reclaimedJob?.lockedBy).toBeNull();
+
+    const secondProcessor = jobQueue.createProcessor(
+      {
+        email: vi.fn(async () => {}),
+        sms: vi.fn(async () => {}),
+        test: handler,
+      },
+      { batchSize: 1, concurrency: 1 },
+    );
+    await secondProcessor.start();
+
+    const completedJob = await jobQueue.getJob(jobId);
+    expect(completedJob?.status).toBe('completed');
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
   it('getPool should throw for Redis backend', () => {
     expect(() => jobQueue.getPool()).toThrow(
       'getPool() is only available with the PostgreSQL backend',

package/src/index.test.ts

@@ -120,6 +120,71 @@ describe('index integration', () => {
     expect(job).toBeNull();
   });
 
+  it('reclaims an in-flight job via supervisor and allows reprocessing', async () => {
+    let firstAttempt = true;
+    const handler = vi.fn(async () => {
+      if (firstAttempt) {
+        firstAttempt = false;
+        await new Promise<void>(() => {});
+      }
+    });
+
+    const jobId = await jobQueue.addJob({
+      jobType: 'test',
+      payload: { foo: 'reclaim-live-loop' },
+    });
+
+    const firstProcessor = jobQueue.createProcessor(
+      {
+        email: vi.fn(async () => {}),
+        sms: vi.fn(async () => {}),
+        test: handler,
+      },
+      { pollInterval: 25, batchSize: 1, concurrency: 1 },
+    );
+    firstProcessor.startInBackground();
+
+    let processingJob = await jobQueue.getJob(jobId);
+    for (let i = 0; i < 50; i++) {
+      if (processingJob?.status === 'processing') {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      processingJob = await jobQueue.getJob(jobId);
+    }
+    expect(processingJob?.status).toBe('processing');
+
+    await firstProcessor.stopAndDrain(25);
+
+    const supervisor = jobQueue.createSupervisor({
+      stuckJobsTimeoutMinutes: 0,
+      cleanupJobsDaysToKeep: 0,
+      cleanupEventsDaysToKeep: 0,
+      expireTimedOutTokens: false,
+    });
+    const maintenance = await supervisor.start();
+    expect(maintenance.reclaimedJobs).toBe(1);
+
+    const reclaimedJob = await jobQueue.getJob(jobId);
+    expect(reclaimedJob?.status).toBe('pending');
+    expect(reclaimedJob?.lockedAt).toBeNull();
+    expect(reclaimedJob?.lockedBy).toBeNull();
+
+    const secondProcessor = jobQueue.createProcessor(
+      {
+        email: vi.fn(async () => {}),
+        sms: vi.fn(async () => {}),
+        test: handler,
+      },
+      { batchSize: 1, concurrency: 1 },
+    );
+    await secondProcessor.start();
+
+    const completedJob = await jobQueue.getJob(jobId);
+    expect(completedJob?.status).toBe('completed');
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
   it('getPool should return the underlying pool', () => {
     expect(jobQueue.getPool()).toBeInstanceOf(Pool);
   });