queue

Author: muniter

example-queue-project/mongoose-example.ts

@@ -1,5 +1,5 @@
 import mongoose from 'mongoose';
-import { createMongooseQueue, QueueJob } from '../src/adapters/mongoose.ts';
+import { MongooseQueue, QueueJob, createQueueModel } from '../src/drivers/mongoose.ts';
 
 // Define your job types
 interface MyJobs {
@@ -21,7 +21,8 @@ async function main() {
   console.log('Connected to MongoDB');
 
   // Create a queue instance
-  const queue = createMongooseQueue<MyJobs>('my-app');
+  const model = createQueueModel();
+  const queue = new MongooseQueue<MyJobs>({ model, name: 'my-app' });
 
   // Set up job handlers
   queue.setHandlers({
@@ -78,7 +79,7 @@ async function customModelExample(): Promise<void> {
   const JobModel = mongoose.model('CustomJob', QueueJob.schema, 'custom_jobs');
 
   // Create queue with custom model
-  const queue = createMongooseQueue<MyJobs>('custom-app', JobModel);
+  const queue = new MongooseQueue<MyJobs>({ model: JobModel, name: 'custom-app' });
 
   // Set handlers and use as normal
   queue.setHandlers({
@@ -100,7 +101,8 @@ async function customModelExample(): Promise<void> {
 async function continuousProcessingExample(): Promise<void> {
   await mongoose.connect('mongodb://localhost:27017/queue-example');
 
-  const queue = createMongooseQueue<MyJobs>('continuous-queue');
+  const model = createQueueModel();
+  const queue = new MongooseQueue<MyJobs>({ model, name: 'continuous-queue' });
 
   queue.setHandlers({
     'send-email': async (job) => {

example-queue-project/src/general-queue.ts

@@ -1,11 +1,13 @@
-import { createSQLiteQueue } from "adapter-queue/sqlite";
+import { SQLiteQueue } from "adapter-queue/drivers/sqlite";
+import Database from "better-sqlite3";
 
 export interface GeneralJobs {
     'process-image': { url: string; width: number; height: number };
     'generate-report': { type: string; period: string };
 }
 
-export const generalQueue = createSQLiteQueue<GeneralJobs>('general-queue', 'queue.db');
+const db = new Database('queue.db');
+export const generalQueue = new SQLiteQueue<GeneralJobs>({ database: db, name: 'general-queue' });
 
 // Register job handlers for general queue
 generalQueue.setHandlers({

src/drivers/mongoose.ts

@@ -220,14 +220,6 @@ export class MongooseQueue<TJobMap = Record<string, unknown>> extends DbQueue<TJ
   }
 }
 
-// Factory function to create a Mongoose queue
-export function createMongooseQueue<TJobMap = Record<string, unknown>>(
-  name: string,
-  model?: Model<IQueueJob>
-): MongooseQueue<TJobMap> {
-  const queueModel = model || createQueueModel();
-  return new MongooseQueue<TJobMap>({ model: queueModel, name });
-}
 
 // Create a default queue model
 export function createQueueModel(

src/drivers/sqlite.ts

@@ -236,11 +236,6 @@ export class SQLiteQueue<T = Record<string, any>> extends DbQueue<T> {
   }
 }
 
-// Convenience factory for better-sqlite3
-export function createSQLiteQueue<T = Record<string, any>>(name: string, filename: string, options?: Database.Options): SQLiteQueue<T> {
-  const db = new Database(filename, options);
-  return new SQLiteQueue<T>({ database: db, name });
-}
 
 // Re-export for convenience
 export { DbQueue };

tests/all-queues.test.ts

@@ -21,10 +21,11 @@ import {
 } from "@aws-sdk/client-sqs";
 import { InMemoryQueue } from "../src/drivers/memory.js";
 import { FileQueue } from "../src/drivers/file.js";
-import { createSQLiteQueue } from "../src/drivers/sqlite.js";
+import { SQLiteQueue } from "../src/drivers/sqlite.js";
+import Database from "better-sqlite3";
 import { RedisQueue } from "../src/drivers/redis.js";
 import { SqsQueue } from "../src/drivers/sqs.js";
-import { createMongooseQueue } from "../src/drivers/mongoose.js";
+import { MongooseQueue, createQueueModel } from "../src/drivers/mongoose.js";
 import mongoose from "mongoose";
 import type { Queue } from "../src/core/queue.js";
 import type { JobRequestFull } from "../src/interfaces/job.ts";
@@ -110,7 +111,8 @@ const drivers: Array<() => Promise<QueueDriverConfig> | QueueDriverConfig> = [
     },
     createQueue: async () => {
       // Use in-memory SQLite database for tests - much faster and no file cleanup needed
-      return createSQLiteQueue<TestJobs>("test-queue", ":memory:");
+      const db = new Database(":memory:");
+      return new SQLiteQueue<TestJobs>({ database: db, name: "test-queue" });
     },
     cleanup: async (queue) => {
       // Clear all jobs from the in-memory database
@@ -267,7 +269,8 @@ const drivers: Array<() => Promise<QueueDriverConfig> | QueueDriverConfig> = [
         }
       },
       createQueue: async () => {
-        return createMongooseQueue<TestJobs>("test-queue");
+        const model = createQueueModel();
+        return new MongooseQueue<TestJobs>({ model, name: "test-queue" });
       },
       cleanup: async () => {
         // Clean up MongoDB collections between tests

tests/drivers/mongoose.test.ts

@@ -3,7 +3,7 @@ import mongoose from 'mongoose';
 import { GenericContainer } from 'testcontainers';
 import type { StartedTestContainer } from 'testcontainers';
 import { 
-  createMongooseQueue, 
+  MongooseQueue,
   createQueueModel,
   MongooseDatabaseAdapter,
   QueueJobSchema 
@@ -148,23 +148,24 @@ describe('Mongoose Adapter', () => {
     });
   });
 
-  describe('createMongooseQueue', () => {
+  describe('MongooseQueue', () => {
     it('should create a queue with default model', () => {
-      const queue = createMongooseQueue('test-queue');
+      const model = createQueueModel();
+      const queue = new MongooseQueue({ model, name: 'test-queue' });
       expect(queue).toBeDefined();
       expect(queue.name).toBe('test-queue');
     });
 
     it('should create a queue with custom model', () => {
-      const queue = createMongooseQueue('test-queue', testModel);
+      const queue = new MongooseQueue({ model: testModel, name: 'test-queue' });
       expect(queue).toBeDefined();
       expect(queue.name).toBe('test-queue');
     });
 
     it('should push and retrieve jobs', async () => {
-      const queue = createMongooseQueue<{
+      const queue = new MongooseQueue<{
         'test-job': { message: string };
-      }>('test-queue', testModel);
+      }>({ model: testModel, name: 'test-queue' });
 
       let processedMessage = '';
       queue.setHandlers({
@@ -183,9 +184,9 @@ describe('Mongoose Adapter', () => {
     });
 
     it('should handle job priorities', async () => {
-      const queue = createMongooseQueue<{
+      const queue = new MongooseQueue<{
         'priority-job': { priority: number };
-      }>('test-queue', testModel);
+      }>({ model: testModel, name: 'test-queue' });
 
       // Push jobs with different priorities
       await queue.addJob('priority-job', { payload: { priority: 1 }, priority: 1 });
@@ -200,9 +201,9 @@ describe('Mongoose Adapter', () => {
     });
 
     it('should handle delayed jobs', async () => {
-      const queue = createMongooseQueue<{
+      const queue = new MongooseQueue<{
         'delayed-job': { when: string };
-      }>('test-queue', testModel);
+      }>({ model: testModel, name: 'test-queue' });
 
       // Push a delayed job
       await queue.addJob('delayed-job', { payload: { when: 'future' }, delaySeconds: 2 });
@@ -221,10 +222,10 @@ describe('Mongoose Adapter', () => {
 
 
     it('should handle job failures and retries through the queue system', async () => {
-      const queue = createMongooseQueue<{
+      const queue = new MongooseQueue<{
         'failing-job': { attemptNumber: number };
         'success-job': { data: string };
-      }>('test-queue', testModel);
+      }>({ model: testModel, name: 'test-queue' });
 
       let attempts: number[] = [];
       let successfulJobs: string[] = [];
@@ -274,10 +275,10 @@ describe('Mongoose Adapter', () => {
     });
 
     it('should handle TTR timeout and job recovery in real processing', async () => {
-      const queue = createMongooseQueue<{
+      const queue = new MongooseQueue<{
         'long-job': { duration: number };
         'quick-job': { data: string };
-      }>('test-queue', testModel);
+      }>({ model: testModel, name: 'test-queue' });
 
       let jobExecutions: string[] = [];
 
@@ -349,7 +350,7 @@ describe('Mongoose Adapter', () => {
 
   describe('Integration with Mongoose features', () => {
     it('should work with Mongoose queries', async () => {
-      const queue = createMongooseQueue('test-queue', testModel);
+      const queue = new MongooseQueue({ model: testModel, name: 'test-queue' });
 
       await queue.addJob('test-job', { payload: { data: 'test1' } });
       await queue.addJob('test-job', { payload: { data: 'test2' } });
@@ -364,7 +365,7 @@ describe('Mongoose Adapter', () => {
     });
 
     it('should maintain Mongoose document structure', async () => {
-      const queue = createMongooseQueue('test-queue', testModel);
+      const queue = new MongooseQueue({ model: testModel, name: 'test-queue' });
 
       const jobId = await queue.addJob('test-job', { payload: { test: true } });