@nicnocquee/dataqueue 1.24.0 → 1.25.0

package/src/db-util.ts

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { JobQueueConfig } from './types.js';
+import { PostgresJobQueueConfig } from './types.js';
 import { parse } from 'pg-connection-string';
 import fs from 'fs';
 
@@ -26,7 +26,9 @@ function loadPemOrFile(value?: string): string | undefined {
  *     rejectUnauthorized: true
  *   }
  */
-export const createPool = (config: JobQueueConfig['databaseConfig']): Pool => {
+export const createPool = (
+  config: PostgresJobQueueConfig['databaseConfig'],
+): Pool => {
   let searchPath: string | undefined;
   let ssl: any = undefined;
   let customCA: string | undefined;

package/src/index.test.ts

@@ -81,7 +81,11 @@ describe('index integration', () => {
     await new Promise((r) => setTimeout(r, 300));
     processor.stop();
     const job = await jobQueue.getJob(jobId);
-    expect(handler).toHaveBeenCalledWith({ foo: 'bar' }, expect.any(Object));
+    expect(handler).toHaveBeenCalledWith(
+      { foo: 'bar' },
+      expect.any(Object),
+      expect.any(Object),
+    );
     expect(job?.status).toBe('completed');
   });
 
@@ -434,6 +438,7 @@ describe('index integration', () => {
     expect(handler).toHaveBeenCalledWith(
       { foo: 'updated@example.com' },
       expect.any(Object),
+      expect.any(Object),
     );
     const job = await jobQueue.getJob(jobId);
     expect(job?.status).toBe('completed');

package/src/index.ts

@@ -1,18 +1,8 @@
 import {
-  addJob,
-  getJob,
-  getJobsByStatus,
-  retryJob,
-  cleanupOldJobs,
-  cancelJob,
-  cancelAllUpcomingJobs,
-  getAllJobs,
-  reclaimStuckJobs,
-  getJobEvents,
-  getJobsByTags,
-  getJobs,
-  editJob,
-  editAllPendingJobs,
+  createWaitpoint,
+  completeWaitpoint,
+  getWaitpoint,
+  expireTimedOutWaitpoints,
 } from './queue.js';
 import { createProcessor } from './processor.js';
 import {
@@ -22,42 +12,70 @@ import {
   ProcessorOptions,
   JobHandlers,
   JobType,
+  PostgresJobQueueConfig,
+  RedisJobQueueConfig,
 } from './types.js';
+import { QueueBackend } from './backend.js';
 import { setLogContext } from './log-context.js';
 import { createPool } from './db-util.js';
+import { PostgresBackend } from './backends/postgres.js';
+import { RedisBackend } from './backends/redis.js';
 
 /**
- * Initialize the job queue system
+ * Initialize the job queue system.
+ *
+ * Defaults to PostgreSQL when `backend` is omitted.
  */
 export const initJobQueue = <PayloadMap = any>(
   config: JobQueueConfig,
 ): JobQueue<PayloadMap> => {
-  const { databaseConfig } = config;
+  const backendType = config.backend ?? 'postgres';
+  setLogContext(config.verbose ?? false);
 
-  // Create database pool
-  const pool = createPool(databaseConfig);
+  let backend: QueueBackend;
+  let pool: import('pg').Pool | undefined;
 
-  setLogContext(config.verbose ?? false);
+  if (backendType === 'postgres') {
+    const pgConfig = config as PostgresJobQueueConfig;
+    pool = createPool(pgConfig.databaseConfig);
+    backend = new PostgresBackend(pool);
+  } else if (backendType === 'redis') {
+    const redisConfig = (config as RedisJobQueueConfig).redisConfig;
+    // RedisBackend constructor will throw if ioredis is not installed
+    backend = new RedisBackend(redisConfig);
+  } else {
+    throw new Error(`Unknown backend: ${backendType}`);
+  }
+
+  const requirePool = () => {
+    if (!pool) {
+      throw new Error(
+        'Wait/Token features require the PostgreSQL backend. Configure with backend: "postgres" to use these features.',
+      );
+    }
+    return pool;
+  };
 
   // Return the job queue API
   return {
     // Job queue operations
     addJob: withLogContext(
-      (job: JobOptions<PayloadMap, any>) => addJob<PayloadMap, any>(pool, job),
+      (job: JobOptions<PayloadMap, any>) =>
+        backend.addJob<PayloadMap, any>(job),
       config.verbose ?? false,
     ),
     getJob: withLogContext(
-      (id: number) => getJob<PayloadMap, any>(pool, id),
+      (id: number) => backend.getJob<PayloadMap, any>(id),
       config.verbose ?? false,
     ),
     getJobsByStatus: withLogContext(
       (status: string, limit?: number, offset?: number) =>
-        getJobsByStatus<PayloadMap, any>(pool, status, limit, offset),
+        backend.getJobsByStatus<PayloadMap, any>(status, limit, offset),
       config.verbose ?? false,
     ),
     getAllJobs: withLogContext(
       (limit?: number, offset?: number) =>
-        getAllJobs<PayloadMap, any>(pool, limit, offset),
+        backend.getAllJobs<PayloadMap, any>(limit, offset),
       config.verbose ?? false,
     ),
     getJobs: withLogContext(
@@ -72,20 +90,22 @@ export const initJobQueue = <PayloadMap = any>(
         },
         limit?: number,
         offset?: number,
-      ) => getJobs<PayloadMap, any>(pool, filters, limit, offset),
+      ) => backend.getJobs<PayloadMap, any>(filters, limit, offset),
       config.verbose ?? false,
     ),
-    retryJob: (jobId: number) => retryJob(pool, jobId),
-    cleanupOldJobs: (daysToKeep?: number) => cleanupOldJobs(pool, daysToKeep),
+    retryJob: (jobId: number) => backend.retryJob(jobId),
+    cleanupOldJobs: (daysToKeep?: number) => backend.cleanupOldJobs(daysToKeep),
+    cleanupOldJobEvents: (daysToKeep?: number) =>
+      backend.cleanupOldJobEvents(daysToKeep),
     cancelJob: withLogContext(
-      (jobId: number) => cancelJob(pool, jobId),
+      (jobId: number) => backend.cancelJob(jobId),
       config.verbose ?? false,
     ),
     editJob: withLogContext(
       <T extends JobType<PayloadMap>>(
         jobId: number,
         updates: import('./types.js').EditJobOptions<PayloadMap, T>,
-      ) => editJob<PayloadMap, T>(pool, jobId, updates as any),
+      ) => backend.editJob(jobId, updates as import('./backend.js').JobUpdates),
       config.verbose ?? false,
     ),
     editAllPendingJobs: withLogContext(
@@ -104,7 +124,11 @@ export const initJobQueue = <PayloadMap = any>(
             }
           | undefined,
         updates: import('./types.js').EditJobOptions<PayloadMap, T>,
-      ) => editAllPendingJobs<PayloadMap, T>(pool, filters, updates as any),
+      ) =>
+        backend.editAllPendingJobs(
+          filters,
+          updates as import('./backend.js').JobUpdates,
+        ),
       config.verbose ?? false,
     ),
     cancelAllUpcomingJobs: withLogContext(
@@ -115,17 +139,17 @@ export const initJobQueue = <PayloadMap = any>(
           | Date
           | { gt?: Date; gte?: Date; lt?: Date; lte?: Date; eq?: Date };
         tags?: { values: string[]; mode?: import('./types.js').TagQueryMode };
-      }) => cancelAllUpcomingJobs(pool, filters),
+      }) => backend.cancelAllUpcomingJobs(filters),
       config.verbose ?? false,
     ),
     reclaimStuckJobs: withLogContext(
       (maxProcessingTimeMinutes?: number) =>
-        reclaimStuckJobs(pool, maxProcessingTimeMinutes),
+        backend.reclaimStuckJobs(maxProcessingTimeMinutes),
       config.verbose ?? false,
     ),
     getJobsByTags: withLogContext(
       (tags: string[], mode = 'all', limit?: number, offset?: number) =>
-        getJobsByTags<PayloadMap, any>(pool, tags, mode, limit, offset),
+        backend.getJobsByTags<PayloadMap, any>(tags, mode, limit, offset),
       config.verbose ?? false,
     ),
 
@@ -133,14 +157,51 @@ export const initJobQueue = <PayloadMap = any>(
     createProcessor: (
       handlers: JobHandlers<PayloadMap>,
       options?: ProcessorOptions,
-    ) => createProcessor<PayloadMap>(pool, handlers, options),
-    // Advanced access (for custom operations)
-    getPool: () => pool,
+    ) => createProcessor<PayloadMap>(backend, handlers, options),
+
     // Job events
     getJobEvents: withLogContext(
-      (jobId: number) => getJobEvents(pool, jobId),
+      (jobId: number) => backend.getJobEvents(jobId),
+      config.verbose ?? false,
+    ),
+
+    // Wait / Token support (PostgreSQL-only for now)
+    createToken: withLogContext(
+      (options?: import('./types.js').CreateTokenOptions) =>
+        createWaitpoint(requirePool(), null, options),
       config.verbose ?? false,
     ),
+    completeToken: withLogContext(
+      (tokenId: string, data?: any) =>
+        completeWaitpoint(requirePool(), tokenId, data),
+      config.verbose ?? false,
+    ),
+    getToken: withLogContext(
+      (tokenId: string) => getWaitpoint(requirePool(), tokenId),
+      config.verbose ?? false,
+    ),
+    expireTimedOutTokens: withLogContext(
+      () => expireTimedOutWaitpoints(requirePool()),
+      config.verbose ?? false,
+    ),
+
+    // Advanced access
+    getPool: () => {
+      if (backendType !== 'postgres') {
+        throw new Error(
+          'getPool() is only available with the PostgreSQL backend.',
+        );
+      }
+      return (backend as PostgresBackend).getPool();
+    },
+    getRedisClient: () => {
+      if (backendType !== 'redis') {
+        throw new Error(
+          'getRedisClient() is only available with the Redis backend.',
+        );
+      }
+      return (backend as RedisBackend).getClient();
+    },
   };
 };
 
@@ -152,6 +213,8 @@ const withLogContext =
   };
 
 export * from './types.js';
+export { QueueBackend } from './backend.js';
+export { PostgresBackend } from './backends/postgres.js';
 export {
   validateHandlerSerializable,
   testHandlerSerialization,