updates

Author: muniter

package.json

@@ -15,8 +15,6 @@
     "lint": "tsc --noEmit",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build && npm test",
-    "queue:worker": "node dist/cli/worker.js",
-    "queue:worker:isolate": "node dist/cli/worker.js --isolate",
     "release": "node scripts/release.ts"
   },
   "keywords": [
@@ -47,10 +45,8 @@
   "devDependencies": {
     "@aws-sdk/client-sqs": "^3.831.0",
     "@types/better-sqlite3": "7.6.13",
-    "@types/mongodb": "^4.0.7",
     "@types/node": "^20.0.0",
     "better-sqlite3": "^12.0.0",
-    "mongodb": "^6.17.0",
     "mongoose": "^8.0.0",
     "redis": "^5.5.6",
     "testcontainers": "^11.0.3",
@@ -74,10 +70,6 @@
       "import": "./dist/src/adapters/sqs.js",
       "types": "./dist/src/adapters/sqs.d.ts"
     },
-    "./mongodb": {
-      "import": "./dist/src/adapters/mongodb.js",
-      "types": "./dist/src/adapters/mongodb.d.ts"
-    },
     "./plugins/ecs-protection-manager": {
       "import": "./dist/src/plugins/ecs-protection-manager.js",
       "types": "./dist/src/plugins/ecs-protection-manager.d.ts"
@@ -89,12 +81,15 @@
     "./mongoose": {
       "import": "./dist/src/adapters/mongoose.js",
       "types": "./dist/src/adapters/mongoose.d.ts"
+    },
+    "./worker": {
+      "import": "./dist/src/worker/worker.js",
+      "types": "./dist/src/worker/worker.d.ts"
     }
   },
   "peerDependencies": {
     "@aws-sdk/client-sqs": "^3.0.0",
     "better-sqlite3": "^9.0.0",
-    "mongodb": "^6.0.0",
     "mongoose": "^7.0.0 || ^8.0.0",
     "redis": "^4.0.0"
   },

pnpm-lock.yaml

@@ -1,17 +1,4 @@
 export { Queue } from './core/queue.ts';
-export { DbQueue } from './drivers/db.ts';
-export { FileQueue } from './drivers/file.ts';
-export { InMemoryQueue } from './drivers/memory.ts';
-export { Worker, runWorker } from './worker/worker.ts';
-export { 
-  MongooseQueue,
-  createMongooseQueue,
-  createQueueModel,
-  QueueJob,
-  MongooseDatabaseAdapter,
-  QueueJobSchema
-} from './adapters/mongoose.ts';
-export type { IQueueJob } from './adapters/mongoose.ts';
 
 export type { 
   JobStatus, 

src/index.ts

@@ -218,6 +218,110 @@ describe('Mongoose Adapter', () => {
       const job2 = await queue.mongooseAdapter.reserveJob(60);
       expect(job2).toBeDefined();
     });
+
+
+    it('should handle job failures and retries through the queue system', async () => {
+      const queue = createMongooseQueue<{
+        'failing-job': { attemptNumber: number };
+        'success-job': { data: string };
+      }>('test-queue', testModel);
+
+      let attempts: number[] = [];
+      let successfulJobs: string[] = [];
+
+      queue.setHandlers({
+        'failing-job': async (job) => {
+          attempts.push(job.payload.attemptNumber);
+          
+          if (job.payload.attemptNumber <= 2) {
+            throw new Error(`Intentional failure on attempt ${job.payload.attemptNumber}`);
+          }
+          
+          // Success on attempt 3
+        },
+        'success-job': async (job) => {
+          successfulJobs.push(job.payload.data);
+        }
+      });
+
+      // Add jobs
+      const failingJob1 = await queue.addJob('failing-job', { payload: { attemptNumber: 1 } });
+      const failingJob2 = await queue.addJob('failing-job', { payload: { attemptNumber: 2 } });
+      const failingJob3 = await queue.addJob('failing-job', { payload: { attemptNumber: 3 } });
+      const successJob = await queue.addJob('success-job', { payload: { data: 'test-data' } });
+
+      // Process all jobs
+      await queue.run();
+
+      // Check results
+      expect(attempts).toEqual([1, 2, 3]);
+      expect(successfulJobs).toEqual(['test-data']);
+
+      // Check final job statuses
+      const job1Doc = await testModel.findById(failingJob1);
+      const job2Doc = await testModel.findById(failingJob2);
+      const job3Doc = await testModel.findById(failingJob3);
+      const successDoc = await testModel.findById(successJob);
+
+      expect(job1Doc?.status).toBe('failed');
+      expect(job2Doc?.status).toBe('failed');
+      expect(job3Doc?.status).toBe('done');
+      expect(successDoc?.status).toBe('done');
+
+      // Check error messages
+      expect(job1Doc?.errorMessage).toContain('Intentional failure on attempt 1');
+      expect(job2Doc?.errorMessage).toContain('Intentional failure on attempt 2');
+    });
+
+    it('should handle TTR timeout and job recovery in real processing', async () => {
+      const queue = createMongooseQueue<{
+        'long-job': { duration: number };
+        'quick-job': { data: string };
+      }>('test-queue', testModel);
+
+      let jobExecutions: string[] = [];
+
+      queue.setHandlers({
+        'long-job': async (job) => {
+          jobExecutions.push(`long-job-start-${job.payload.duration}`);
+          // Simulate a job that takes longer than its TTR
+          await new Promise(resolve => setTimeout(resolve, job.payload.duration));
+          jobExecutions.push(`long-job-end-${job.payload.duration}`);
+        },
+        'quick-job': async (job) => {
+          jobExecutions.push(`quick-job-${job.payload.data}`);
+        }
+      });
+
+      // Add a job with very short TTR that will timeout
+      const longJobId = await queue.addJob('long-job', { 
+        payload: { duration: 2000 }, // 2 seconds
+        ttr: 1 // 1 second TTR - will timeout
+      });
+
+      // Add a quick job
+      const quickJobId = await queue.addJob('quick-job', { 
+        payload: { data: 'test' }
+      });
+
+      // Process queue - long job will timeout, quick job should complete
+      await queue.run();
+
+      // Verify states after first run
+      let longJobDoc = await testModel.findById(longJobId);
+      let quickJobDoc = await testModel.findById(quickJobId);
+
+      // Quick job should be done, long job should be in some intermediate state
+      expect(quickJobDoc?.status).toBe('done');
+      
+      // Check what actually got executed
+      expect(jobExecutions).toContain('quick-job-test');
+      expect(jobExecutions).toContain('long-job-start-2000');
+      
+      // The long job may or may not have finished depending on timing
+      // but it should have been processed at least once
+      expect(longJobDoc).toBeDefined();
+    }, 10000); // Longer timeout for this test
   });
 
   describe('createQueueModel', () => {