@nicnocquee/dataqueue 1.16.0 → 1.17.0

package/src/index.test.ts

@@ -38,23 +38,23 @@ describe('index integration', () => {
 
   it('should add a job and retrieve it', async () => {
     const jobId = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'test@example.com' },
     });
     expect(typeof jobId).toBe('number');
     const job = await jobQueue.getJob(jobId);
     expect(job).not.toBeNull();
-    expect(job?.job_type).toBe('email');
+    expect(job?.jobType).toBe('email');
     expect(job?.payload).toEqual({ to: 'test@example.com' });
   });
 
   it('should get jobs by status', async () => {
     const jobId1 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'a@example.com' },
     });
     const jobId2 = await jobQueue.addJob({
-      job_type: 'sms',
+      jobType: 'sms',
       payload: { to: 'b@example.com' },
     });
     const jobs = await jobQueue.getJobsByStatus('pending');
@@ -66,7 +66,7 @@ describe('index integration', () => {
   it('should process a job with a registered handler', async () => {
     const handler = vi.fn(async (_payload, _signal) => {});
     const jobId = await jobQueue.addJob({
-      job_type: 'test',
+      jobType: 'test',
       payload: { foo: 'bar' },
     });
     const processor = jobQueue.createProcessor(
@@ -87,7 +87,7 @@ describe('index integration', () => {
 
   it('should retry a failed job', async () => {
     const jobId = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'fail@example.com' },
     });
     // Manually mark as failed
@@ -103,7 +103,7 @@ describe('index integration', () => {
 
   it('should cleanup old completed jobs', async () => {
     const jobId = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cleanup@example.com' },
     });
     // Mark as completed
@@ -123,7 +123,7 @@ describe('index integration', () => {
 
   it('should cancel a scheduled job', async () => {
     const jobId = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cancelme@example.com' },
     });
     // Cancel the job
@@ -133,7 +133,7 @@ describe('index integration', () => {
 
     // Try to cancel a completed job (should not change status)
     const jobId2 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'done@example.com' },
     });
     await pool.query(
@@ -148,20 +148,20 @@ describe('index integration', () => {
   it('should cancel all upcoming jobs via JobQueue API', async () => {
     // Add three pending jobs
     const jobId1 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cancelall1@example.com' },
     });
     const jobId2 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cancelall2@example.com' },
     });
     const jobId3 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cancelall3@example.com' },
     });
     // Add a completed job
     const jobId4 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'done@example.com' },
     });
     await pool.query(
@@ -186,18 +186,18 @@ describe('index integration', () => {
     expect(completedJob?.status).toBe('completed');
   });
 
-  it('should cancel all upcoming jobs by job_type', async () => {
+  it('should cancel all upcoming jobs by jobType', async () => {
     const jobId1 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'a@example.com' },
     });
     const jobId2 = await jobQueue.addJob({
-      job_type: 'sms',
+      jobType: 'sms',
       payload: { to: 'b@example.com' },
     });
     // Cancel only email jobs
     const cancelledCount = await jobQueue.cancelAllUpcomingJobs({
-      job_type: 'email',
+      jobType: 'email',
     });
     expect(cancelledCount).toBeGreaterThanOrEqual(1);
     const job1 = await jobQueue.getJob(jobId1);
@@ -208,12 +208,12 @@ describe('index integration', () => {
 
   it('should cancel all upcoming jobs by priority', async () => {
     const jobId1 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'a@example.com' },
       priority: 1,
     });
     const jobId2 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'b@example.com' },
       priority: 2,
     });
@@ -228,20 +228,20 @@ describe('index integration', () => {
     expect(job2?.status).toBe('cancelled');
   });
 
-  it('should cancel all upcoming jobs by run_at', async () => {
+  it('should cancel all upcoming jobs by runAt', async () => {
     const runAt = new Date(Date.now() + 60 * 60 * 1000); // 1 hour in future
     const jobId1 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'a@example.com' },
-      run_at: runAt,
+      runAt: runAt,
     });
     const jobId2 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'b@example.com' },
     });
-    // Cancel only jobs with run_at = runAt
+    // Cancel only jobs with runAt = runAt
     const cancelledCount = await jobQueue.cancelAllUpcomingJobs({
-      run_at: runAt,
+      runAt: runAt,
     });
     expect(cancelledCount).toBeGreaterThanOrEqual(1);
     const job1 = await jobQueue.getJob(jobId1);
@@ -250,25 +250,25 @@ describe('index integration', () => {
     expect(job2?.status).toBe('pending');
   });
 
-  it('should cancel all upcoming jobs by job_type and priority', async () => {
+  it('should cancel all upcoming jobs by jobType and priority', async () => {
     const jobId1 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'a@example.com' },
       priority: 1,
     });
     const jobId2 = await jobQueue.addJob({
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'b@example.com' },
       priority: 2,
     });
     const jobId3 = await jobQueue.addJob({
-      job_type: 'sms',
+      jobType: 'sms',
       payload: { to: 'c@example.com' },
       priority: 2,
     });
     // Cancel only email jobs with priority 2
     const cancelledCount = await jobQueue.cancelAllUpcomingJobs({
-      job_type: 'email',
+      jobType: 'email',
       priority: 2,
     });
     expect(cancelledCount).toBeGreaterThanOrEqual(1);

package/src/index.ts

@@ -62,7 +62,7 @@ export const initJobQueue = async <PayloadMap = any>(
       config.verbose ?? false,
     ),
     cancelAllUpcomingJobs: withLogContext(
-      (filters?: { job_type?: string; priority?: number; run_at?: Date }) =>
+      (filters?: { jobType?: string; priority?: number; runAt?: Date }) =>
         cancelAllUpcomingJobs(pool, filters),
       config.verbose ?? false,
     ),

package/src/processor.test.ts

@@ -51,7 +51,7 @@ describe('processor integration', () => {
       typeC: vi.fn(async () => {}),
     };
     const jobId = await queue.addJob<TestPayloadMap, 'test'>(pool, {
-      job_type: 'test',
+      jobType: 'test',
       payload: { foo: 'bar' },
     });
     const job = await queue.getJob<TestPayloadMap, 'test'>(pool, jobId);
@@ -80,7 +80,7 @@ describe('processor integration', () => {
       typeC: vi.fn(async () => {}),
     };
     const jobId = await queue.addJob<TestPayloadMap, 'fail'>(pool, {
-      job_type: 'fail',
+      jobType: 'fail',
       payload: {},
     });
     const job = await queue.getJob<TestPayloadMap, 'fail'>(pool, jobId);
@@ -88,8 +88,8 @@ describe('processor integration', () => {
     await processJobWithHandlers(pool, job!, handlers);
     const failed = await queue.getJob(pool, jobId);
     expect(failed?.status).toBe('failed');
-    expect(failed?.error_history?.[0]?.message).toBe('fail!');
-    expect(failed?.failure_reason).toBe('handler_error');
+    expect(failed?.errorHistory?.[0]?.message).toBe('fail!');
+    expect(failed?.failureReason).toBe('handler_error');
   });
 
   it('should mark job as failed if no handler registered', async () => {
@@ -106,7 +106,7 @@ describe('processor integration', () => {
       typeC: vi.fn(async () => {}),
     };
     const jobId = await queue.addJob<TestPayloadMap, 'missing'>(pool, {
-      job_type: 'missing',
+      jobType: 'missing',
       payload: {},
     });
     const job = await queue.getJob<TestPayloadMap, 'missing'>(pool, jobId);
@@ -115,10 +115,10 @@ describe('processor integration', () => {
     await processJobWithHandlers(pool, job!, handlers);
     const failed = await queue.getJob(pool, jobId);
     expect(failed?.status).toBe('failed');
-    expect(failed?.error_history?.[0]?.message).toContain(
+    expect(failed?.errorHistory?.[0]?.message).toContain(
       'No handler registered',
     );
-    expect(failed?.failure_reason).toBe('no_handler');
+    expect(failed?.failureReason).toBe('no_handler');
   });
 
   it('should process a batch of jobs', async () => {
@@ -135,11 +135,11 @@ describe('processor integration', () => {
     };
     const ids = await Promise.all([
       queue.addJob<TestPayloadMap, 'batch'>(pool, {
-        job_type: 'batch',
+        jobType: 'batch',
         payload: { i: 1 },
       }),
       queue.addJob<TestPayloadMap, 'batch'>(pool, {
-        job_type: 'batch',
+        jobType: 'batch',
         payload: { i: 2 },
       }),
     ]);
@@ -172,7 +172,7 @@ describe('processor integration', () => {
       typeC: vi.fn(async () => {}),
     };
     await queue.addJob<TestPayloadMap, 'proc'>(pool, {
-      job_type: 'proc',
+      jobType: 'proc',
       payload: { x: 1 },
     });
     const processor = createProcessor(pool, handlers, { pollInterval: 200 });
@@ -182,7 +182,7 @@ describe('processor integration', () => {
     processor.stop();
     expect(processor.isRunning()).toBe(false);
     const jobs = await queue.getJobsByStatus(pool, 'completed');
-    expect(jobs.some((j) => j.job_type === 'proc')).toBe(true);
+    expect(jobs.some((j) => j.jobType === 'proc')).toBe(true);
   });
 
   it('should process only jobs of a specific job type with processBatch', async () => {
@@ -199,15 +199,15 @@ describe('processor integration', () => {
       typeC: vi.fn(async () => {}),
     };
     const idA1 = await queue.addJob<TestPayloadMap, 'typeA'>(pool, {
-      job_type: 'typeA',
+      jobType: 'typeA',
       payload: { n: 1 },
     });
     const idA2 = await queue.addJob<TestPayloadMap, 'typeA'>(pool, {
-      job_type: 'typeA',
+      jobType: 'typeA',
       payload: { n: 2 },
     });
     const idB1 = await queue.addJob<TestPayloadMap, 'typeB'>(pool, {
-      job_type: 'typeB',
+      jobType: 'typeB',
       payload: { n: 3 },
     });
     // Only process typeA
@@ -246,15 +246,15 @@ describe('processor integration', () => {
       typeC: handlerC,
     };
     const idA = await queue.addJob<TestPayloadMap, 'typeA'>(pool, {
-      job_type: 'typeA',
+      jobType: 'typeA',
       payload: { n: 1 },
     });
     const idB = await queue.addJob<TestPayloadMap, 'typeB'>(pool, {
-      job_type: 'typeB',
+      jobType: 'typeB',
       payload: { n: 2 },
     });
     const idC = await queue.addJob<TestPayloadMap, 'typeC'>(pool, {
-      job_type: 'typeC',
+      jobType: 'typeC',
       payload: { n: 3 },
     });
     // Only process typeA and typeC
@@ -293,11 +293,11 @@ describe('processor integration', () => {
       typeC: vi.fn(async () => {}),
     };
     const idA = await queue.addJob<TestPayloadMap, 'typeA'>(pool, {
-      job_type: 'typeA',
+      jobType: 'typeA',
       payload: { n: 1 },
     });
     const idB = await queue.addJob<TestPayloadMap, 'typeB'>(pool, {
-      job_type: 'typeB',
+      jobType: 'typeB',
       payload: { n: 2 },
     });
     const processor = createProcessor(pool, handlers, {
@@ -335,7 +335,7 @@ describe('concurrency option', () => {
   async function addJobs(n: number) {
     for (let i = 0; i < n; i++) {
       await queue.addJob<{ test: {} }, 'test'>(pool, {
-        job_type: 'test',
+        jobType: 'test',
         payload: {},
       });
     }
@@ -444,7 +444,7 @@ describe('per-job timeout', () => {
       test: handler,
     };
     const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
-      job_type: 'test',
+      jobType: 'test',
       payload: {},
       timeoutMs: 50, // 50ms
     });
@@ -453,8 +453,8 @@ describe('per-job timeout', () => {
     await processJobWithHandlers(pool, job!, handlers);
     const failed = await queue.getJob(pool, jobId);
     expect(failed?.status).toBe('failed');
-    expect(failed?.error_history?.[0]?.message).toContain('timed out');
-    expect(failed?.failure_reason).toBe(FailureReason.Timeout);
+    expect(failed?.errorHistory?.[0]?.message).toContain('timed out');
+    expect(failed?.failureReason).toBe(FailureReason.Timeout);
   });
 
   it('should complete the job if handler finishes before timeoutMs', async () => {
@@ -465,7 +465,7 @@ describe('per-job timeout', () => {
       test: handler,
     };
     const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
-      job_type: 'test',
+      jobType: 'test',
       payload: {},
       timeoutMs: 200, // 200ms
     });

package/src/processor.ts

@@ -27,25 +27,25 @@ export async function processJobWithHandlers<
   job: JobRecord<PayloadMap, T>,
   jobHandlers: JobHandlers<PayloadMap>,
 ): Promise<void> {
-  const handler = jobHandlers[job.job_type];
+  const handler = jobHandlers[job.jobType];
 
   if (!handler) {
     await setPendingReasonForUnpickedJobs(
       pool,
-      `No handler registered for job type: ${job.job_type}`,
-      job.job_type,
+      `No handler registered for job type: ${job.jobType}`,
+      job.jobType,
     );
     await failJob(
       pool,
       job.id,
-      new Error(`No handler registered for job type: ${job.job_type}`),
+      new Error(`No handler registered for job type: ${job.jobType}`),
       FailureReason.NoHandler,
     );
     return;
   }
 
   // Per-job timeout logic
-  const timeoutMs = job.timeout_ms ?? undefined;
+  const timeoutMs = job.timeoutMs ?? undefined;
   let timeoutId: NodeJS.Timeout | undefined;
   const controller = new AbortController();
   try {