make queue name required

Author: muniter

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

@@ -8,15 +8,15 @@ interface EmailJobs {
 
 // File-based queue (for local development)
 export const emailQueueFile = new FileQueue<EmailJobs>({
+  name: "email-queue",
   path: "./email-queue",
 });
 
 // SQS-based queue (for production) - simple API
 export const emailQueueSqs = createSQSQueue<EmailJobs>(
+  "email-queue",
   "https://sqs.us-east-1.amazonaws.com/428011609647/test-queue",
-  {
-    profile: "javier",
-  }
+  "delete"
 );
 
 export const emailQueue = emailQueueSqs;

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

@@ -5,7 +5,7 @@ export interface GeneralJobs {
     'generate-report': { type: string; period: string };
 }
 
-export const generalQueue = createSQLiteQueue<GeneralJobs>('queue.db');
+export const generalQueue = createSQLiteQueue<GeneralJobs>('general-queue', 'queue.db');
 
 // Register job handlers for general queue
 generalQueue.setHandlers({

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

@@ -6,7 +6,7 @@ interface EmailJobs {
 }
 
 // Create Redis queue with simple API
-export const emailQueue = createRedisQueue<EmailJobs>('redis://localhost:6379');
+export const emailQueue = createRedisQueue<EmailJobs>('redis-email-queue', 'redis://localhost:6379');
 
 // Register job handlers
 emailQueue.setHandlers({

src/adapters/mongodb.ts

@@ -185,33 +185,35 @@ export class MongoDatabaseAdapter implements DatabaseAdapter {
 // Main export - constructor pattern
 export class MongoQueue<T = Record<string, any>> extends DbQueue<T> {
   mongoAdapter: MongoDatabaseAdapter;
-  constructor(config: { collection: MongoCollection }) {
+  constructor(config: { collection: MongoCollection; name: string }) {
     const adapter = new MongoDatabaseAdapter(config.collection);
-    super(adapter);
+    super(adapter, { name: config.name });
     this.mongoAdapter = adapter;
   }
 }
 
 // Convenience factory for MongoDB driver
 export function createMongoQueue<T = Record<string, any>>(
+  name: string,
   client: MongoClient,
   database: string,
   collection: string = 'jobs'
 ): MongoQueue<T> {
   const db = client.db(database);
   const col = db.collection(collection);
-  return new MongoQueue<T>({ collection: col });
+  return new MongoQueue<T>({ collection: col, name });
 }
 
 // Convenience factory with connection string
 export async function createMongoQueueFromUrl<T = Record<string, any>>(
+  name: string,
   url: string,
   database: string,
   collection: string = 'jobs'
 ): Promise<MongoQueue<T>> {
   const client = new MongoClient(url);
   await client.connect();
-  return createMongoQueue<T>(client, database, collection);
+  return createMongoQueue<T>(name, client, database, collection);
 }
 
 // Re-export for convenience

src/adapters/redis.ts

@@ -309,16 +309,16 @@ export class RedisDatabaseAdapter implements DatabaseAdapter {
 
 // Main export - constructor pattern for database-backed Redis queue
 export class RedisQueue<T = Record<string, any>> extends DbQueue<T> {
-  constructor(config: { client: RedisClient; keyPrefix?: string }) {
+  constructor(config: { client: RedisClient; keyPrefix?: string; name: string }) {
     const adapter = new RedisDatabaseAdapter(config.client, config.keyPrefix);
-    super(adapter);
+    super(adapter, { name: config.name });
   }
 }
 
 // Convenience factory for node-redis
-export function createRedisQueue<T = Record<string, any>>(url?: string): RedisQueue<T> {
+export function createRedisQueue<T = Record<string, any>>(name: string, url?: string): RedisQueue<T> {
   const client = createClient(url ? { url } : {}) as any;
-  return new RedisQueue<T>({ client });
+  return new RedisQueue<T>({ client, name });
 }
 
 // Re-export for convenience

src/adapters/sqlite.ts

@@ -227,16 +227,16 @@ export class SQLiteDatabaseAdapter implements DatabaseAdapter {
 
 // Main export - constructor pattern
 export class SQLiteQueue<T = Record<string, any>> extends DbQueue<T> {
-  constructor(config: { database: SQLiteDatabase }) {
+  constructor(config: { database: SQLiteDatabase; name: string }) {
     const adapter = new SQLiteDatabaseAdapter(config.database);
-    super(adapter);
+    super(adapter, { name: config.name });
   }
 }
 
 // Convenience factory for better-sqlite3
-export function createSQLiteQueue<T = Record<string, any>>(filename: string, options?: Database.Options): SQLiteQueue<T> {
+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 });
+  return new SQLiteQueue<T>({ database: db, name });
 }
 
 // Re-export for convenience

src/adapters/sqs.ts

@@ -7,19 +7,24 @@ export interface SQSConfig extends SQSClientConfig {
 
 // Main export - constructor pattern
 export class SQSQueue<T = Record<string, any>> extends SqsQueue<T> {
-  constructor(config: { client: SQSClient; queueUrl: string }) {
-    super(config.client, config.queueUrl);
+  constructor(config: { client: SQSClient; queueUrl: string; name: string; onFailure: "delete" | "leaveInQueue" }) {
+    super(config.client, config.queueUrl, { name: config.name, onFailure: config.onFailure });
   }
 }
 
 // Convenience factory for AWS SDK v3
-export function createSQSQueue<T = Record<string, any>>(queueUrl: string, sqsConfig?: SQSConfig): SQSQueue<T> {
+export function createSQSQueue<T = Record<string, any>>(
+  name: string, 
+  queueUrl: string, 
+  onFailure: "delete" | "leaveInQueue",
+  sqsConfig?: SQSConfig
+): SQSQueue<T> {
   const client = new SQSClient({
     region: sqsConfig?.region || process.env.AWS_REGION || 'us-east-1',
     ...sqsConfig
   });
 
-  return new SQSQueue<T>({ client, queueUrl });
+  return new SQSQueue<T>({ client, queueUrl, name, onFailure });
 }
 
 // Re-export for convenience

src/cli/worker.ts

@@ -84,15 +84,15 @@ async function main(): Promise<void> {
       process.exit(1);
     }
 
-    queue = new SqsQueue(config.sqsClient, config.queueUrl);
+    queue = new SqsQueue(config.sqsClient, config.queueUrl, { name: 'cli-queue', onFailure: 'delete' });
   } else {
     if (!config.dbAdapter) {
       console.error('Error: Database adapter must be provided when using DB driver');
       console.error('This CLI is a template. You need to provide your own database adapter instance.');
       process.exit(1);
     }
 
-    queue = new DbQueue(config.dbAdapter);
+    queue = new DbQueue(config.dbAdapter, { name: 'cli-queue' });
   }
 
   const worker = new Worker(queue, {

src/core/queue.ts

@@ -39,7 +39,7 @@ export abstract class Queue<TJobMap = Record<string, any>, TJobRequest extends B
   protected ttrDefault = 300;
   protected plugins: QueuePlugin[];
   protected pluginDisposers: Array<() => Promise<void>> = [];
-  public readonly name?: string;
+  public readonly name: string;
 
   /**
    * Registry of job handlers mapping job names to their handler functions.
@@ -62,14 +62,14 @@ export abstract class Queue<TJobMap = Record<string, any>, TJobRequest extends B
    * Creates a new Queue instance.
    * 
    * @param options - Configuration options
+   * @param options.name - Required name for the queue
    * @param options.ttrDefault - Default time-to-run for jobs in seconds (default: 300)
-   * @param options.name - Optional name for the queue
    * @param options.plugins - Array of plugins to use with this queue
    */
-  constructor(options: QueueOptions = {}) {
+  constructor(options: QueueOptions) {
     super();
-    if (options.ttrDefault) this.ttrDefault = options.ttrDefault;
     this.name = options.name;
+    if (options.ttrDefault) this.ttrDefault = options.ttrDefault;
     this.plugins = options.plugins || [];
   }
 
@@ -235,7 +235,7 @@ export abstract class Queue<TJobMap = Record<string, any>, TJobRequest extends B
     if (this.pluginDisposers.length === 0) {
       for (const plugin of this.plugins) {
         if (plugin.init) {
-          const dispose = await plugin.init({ queue: this as any, queueName: this.name });
+          const dispose = await plugin.init({ queue: this as any });
           if (dispose) {
             this.pluginDisposers.push(dispose);
             disposers.push(dispose);

src/drivers/db.ts

@@ -6,7 +6,7 @@ import type { QueueOptions } from '../interfaces/plugin.ts';
 export class DbQueue<TJobMap = Record<string, any>> extends Queue<TJobMap, DbJobRequest<any>> {
   constructor(
     private db: DatabaseAdapter,
-    options: QueueOptions = {}
+    options: QueueOptions
   ) {
     super(options);
   }