@nicnocquee/dataqueue 1.16.0 → 1.18.0

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 {

package/src/queue.test.ts

@@ -2,7 +2,8 @@ import { Pool } from 'pg';
 import { describe, expect, it, beforeEach, afterEach } from 'vitest';
 import * as queue from './queue.js';
 import { createTestDbAndPool, destroyTestDb } from './test-util.js';
-import { JobEventType } from './types.js';
+import { JobEvent, JobEventType } from './types.js';
+import { objectKeysToCamelCase } from './utils.js';
 
 // Example integration test setup
 
@@ -23,13 +24,13 @@ describe('queue integration', () => {
 
   it('should add a job and retrieve it', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'test@example.com' },
     });
     expect(typeof jobId).toBe('number');
     const job = await queue.getJob(pool, jobId);
     expect(job).not.toBeNull();
-    expect(job?.job_type).toBe('email');
+    expect(job?.jobType).toBe('email');
     expect(job?.payload).toEqual({ to: 'test@example.com' });
   });
 
@@ -38,12 +39,12 @@ describe('queue integration', () => {
     const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'a@example.com' },
       },
     );
     const jobId2 = await queue.addJob<{ sms: { to: string } }, 'sms'>(pool, {
-      job_type: 'sms',
+      jobType: 'sms',
       payload: { to: 'b@example.com' },
     });
     // All jobs should be 'pending' by default
@@ -55,7 +56,7 @@ describe('queue integration', () => {
 
   it('should retry a failed job', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'fail@example.com' },
     });
     // Mark as failed
@@ -70,7 +71,7 @@ describe('queue integration', () => {
 
   it('should mark a job as completed', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'done@example.com' },
     });
     await queue.completeJob(pool, jobId);
@@ -79,18 +80,18 @@ describe('queue integration', () => {
   });
 
   it('should get the next batch of jobs to process', async () => {
-    // Add jobs (do not set run_at, use DB default)
+    // Add jobs (do not set runAt, use DB default)
     const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'batch1@example.com' },
       },
     );
     const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'batch2@example.com' },
       },
     );
@@ -107,9 +108,9 @@ describe('queue integration', () => {
     // Add a job scheduled 1 day in the future
     const futureDate = new Date(Date.now() + 24 * 60 * 60 * 1000);
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'future@example.com' },
-      run_at: futureDate,
+      runAt: futureDate,
     });
     const jobs = await queue.getNextBatch(pool, 'worker-2', 1);
     const ids = jobs.map((j) => j.id);
@@ -122,7 +123,7 @@ describe('queue integration', () => {
   it('should cleanup old completed jobs', async () => {
     // Add and complete a job
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cleanup@example.com' },
     });
     await queue.completeJob(pool, jobId);
@@ -140,7 +141,7 @@ describe('queue integration', () => {
 
   it('should cancel a scheduled job', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'cancelme@example.com' },
     });
     await queue.cancelJob(pool, jobId);
@@ -151,7 +152,7 @@ describe('queue integration', () => {
     const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'done@example.com' },
       },
     );
@@ -166,21 +167,21 @@ describe('queue integration', () => {
     const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'cancelall1@example.com' },
       },
     );
     const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'cancelall2@example.com' },
       },
     );
     const jobId3 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'cancelall3@example.com' },
       },
     );
@@ -188,7 +189,7 @@ describe('queue integration', () => {
     const jobId4 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'done@example.com' },
       },
     );
@@ -211,17 +212,17 @@ describe('queue integration', () => {
     expect(completedJob?.status).toBe('completed');
   });
 
-  it('should store and retrieve run_at in UTC without timezone shift', async () => {
+  it('should store and retrieve runAt in UTC without timezone shift', async () => {
     const utcDate = new Date(Date.UTC(2030, 0, 1, 12, 0, 0, 0)); // 2030-01-01T12:00:00.000Z
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'utc@example.com' },
-      run_at: utcDate,
+      runAt: utcDate,
     });
     const job = await queue.getJob(pool, jobId);
     expect(job).not.toBeNull();
-    // The run_at value should match exactly (toISOString) what we inserted
-    expect(job?.run_at.toISOString()).toBe(utcDate.toISOString());
+    // The runAt value should match exactly (toISOString) what we inserted
+    expect(job?.runAt.toISOString()).toBe(utcDate.toISOString());
   });
 
   it('should get all jobs', async () => {
@@ -229,16 +230,16 @@ describe('queue integration', () => {
     const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
       pool,
       {
-        job_type: 'email',
+        jobType: 'email',
         payload: { to: 'all1@example.com' },
       },
     );
     const jobId2 = await queue.addJob<{ sms: { to: string } }, 'sms'>(pool, {
-      job_type: 'sms',
+      jobType: 'sms',
       payload: { to: 'all2@example.com' },
     });
     const jobId3 = await queue.addJob<{ push: { to: string } }, 'push'>(pool, {
-      job_type: 'push',
+      jobType: 'push',
       payload: { to: 'all3@example.com' },
     });
     // Get all jobs
@@ -249,26 +250,26 @@ describe('queue integration', () => {
     expect(ids).toContain(jobId3);
     // Should return correct job data
     const job1 = jobs.find((j) => j.id === jobId1);
-    expect(job1?.job_type).toBe('email');
+    expect(job1?.jobType).toBe('email');
     expect(job1?.payload).toEqual({ to: 'all1@example.com' });
   });
 
   it('should support pagination in getAllJobs', async () => {
     // Add four jobs
     await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
-      job_type: 'a',
+      jobType: 'a',
       payload: { n: 1 },
     });
     await queue.addJob<{ b: { n: number } }, 'b'>(pool, {
-      job_type: 'b',
+      jobType: 'b',
       payload: { n: 2 },
     });
     await queue.addJob<{ c: { n: number } }, 'c'>(pool, {
-      job_type: 'c',
+      jobType: 'c',
       payload: { n: 3 },
     });
     await queue.addJob<{ d: { n: number } }, 'd'>(pool, {
-      job_type: 'd',
+      jobType: 'd',
       payload: { n: 4 },
     });
     // Get first two jobs
@@ -285,7 +286,7 @@ describe('queue integration', () => {
 
   it('should track error history for failed jobs', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'failhistory@example.com' },
     });
     // Fail the job twice with different errors
@@ -293,18 +294,18 @@ describe('queue integration', () => {
     await queue.failJob(pool, jobId, new Error('second error'));
     const job = await queue.getJob(pool, jobId);
     expect(job?.status).toBe('failed');
-    expect(Array.isArray(job?.error_history)).toBe(true);
-    expect(job?.error_history?.length).toBeGreaterThanOrEqual(2);
-    expect(job?.error_history?.[0].message).toBe('first error');
-    expect(job?.error_history?.[1].message).toBe('second error');
-    expect(typeof job?.error_history?.[0].timestamp).toBe('string');
-    expect(typeof job?.error_history?.[1].timestamp).toBe('string');
+    expect(Array.isArray(job?.errorHistory)).toBe(true);
+    expect(job?.errorHistory?.length).toBeGreaterThanOrEqual(2);
+    expect(job?.errorHistory?.[0].message).toBe('first error');
+    expect(job?.errorHistory?.[1].message).toBe('second error');
+    expect(typeof job?.errorHistory?.[0].timestamp).toBe('string');
+    expect(typeof job?.errorHistory?.[1].timestamp).toBe('string');
   });
 
   it('should reclaim stuck processing jobs', async () => {
     // Add a job and set it to processing with an old locked_at
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'stuck@example.com' },
     });
     await pool.query(
@@ -319,8 +320,8 @@ describe('queue integration', () => {
     expect(reclaimed).toBeGreaterThanOrEqual(1);
     job = await queue.getJob(pool, jobId);
     expect(job?.status).toBe('pending');
-    expect(job?.locked_at).toBeNull();
-    expect(job?.locked_by).toBeNull();
+    expect(job?.lockedAt).toBeNull();
+    expect(job?.lockedBy).toBeNull();
   });
 });
 
@@ -344,18 +345,18 @@ describe('job event tracking', () => {
       'SELECT * FROM job_events WHERE job_id = $1 ORDER BY created_at ASC',
       [jobId],
     );
-    return res.rows;
+    return res.rows.map((row) => objectKeysToCamelCase(row) as JobEvent);
   }
 
   it('records added and processing events', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'event1@example.com' },
     });
     // Pick up for processing
     await queue.getNextBatch(pool, 'worker-evt', 1);
     const events = await getEvents(jobId);
-    expect(events.map((e) => e.event_type)).toEqual([
+    expect(events.map((e) => e.eventType)).toEqual([
       JobEventType.Added,
       JobEventType.Processing,
     ]);
@@ -363,39 +364,39 @@ describe('job event tracking', () => {
 
   it('records completed event', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'event2@example.com' },
     });
     await queue.getNextBatch(pool, 'worker-evt', 1);
     await queue.completeJob(pool, jobId);
     const events = await getEvents(jobId);
-    expect(events.map((e) => e.event_type)).toContain(JobEventType.Completed);
+    expect(events.map((e) => e.eventType)).toContain(JobEventType.Completed);
   });
 
   it('records failed and retried events', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'event3@example.com' },
     });
     await queue.getNextBatch(pool, 'worker-evt', 1);
     await queue.failJob(pool, jobId, new Error('fail for event'));
     await queue.retryJob(pool, jobId);
     const events = await getEvents(jobId);
-    expect(events.map((e) => e.event_type)).toEqual(
+    expect(events.map((e) => e.eventType)).toEqual(
       expect.arrayContaining([JobEventType.Failed, JobEventType.Retried]),
     );
-    const failEvent = events.find((e) => e.event_type === JobEventType.Failed);
-    expect(failEvent.metadata).toMatchObject({ message: 'fail for event' });
+    const failEvent = events.find((e) => e.eventType === JobEventType.Failed);
+    expect(failEvent?.metadata).toMatchObject({ message: 'fail for event' });
   });
 
   it('records cancelled event', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'event4@example.com' },
     });
     await queue.cancelJob(pool, jobId);
     const events = await getEvents(jobId);
-    expect(events.map((e) => e.event_type)).toContain(JobEventType.Cancelled);
+    expect(events.map((e) => e.eventType)).toContain(JobEventType.Cancelled);
   });
 });
 
@@ -421,41 +422,41 @@ describe('job lifecycle timestamp columns', () => {
     return res.rows[0];
   }
 
-  it('sets started_at when job is picked up for processing', async () => {
+  it('sets startedAt when job is picked up for processing', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'ts1@example.com' },
     });
     await queue.getNextBatch(pool, 'worker-ts', 1);
     const job = await getJobRow(jobId);
-    expect(job.started_at).not.toBeNull();
+    expect(job.startedAt).not.toBeNull();
   });
 
-  it('sets completed_at when job is completed', async () => {
+  it('sets completedAt when job is completed', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'ts2@example.com' },
     });
     await queue.getNextBatch(pool, 'worker-ts', 1);
     await queue.completeJob(pool, jobId);
     const job = await getJobRow(jobId);
-    expect(job.completed_at).not.toBeNull();
+    expect(job.completedAt).not.toBeNull();
   });
 
-  it('sets last_failed_at when job fails', async () => {
+  it('sets lastFailedAt when job fails', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'ts3@example.com' },
     });
     await queue.getNextBatch(pool, 'worker-ts', 1);
     await queue.failJob(pool, jobId, new Error('fail for ts'));
     const job = await getJobRow(jobId);
-    expect(job.last_failed_at).not.toBeNull();
+    expect(job.lastFailedAt).not.toBeNull();
   });
 
-  it('sets last_retried_at when job is retried', async () => {
+  it('sets lastRetriedAt when job is retried', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'ts4@example.com' },
     });
     await queue.getNextBatch(pool, 'worker-ts', 1);
@@ -465,25 +466,25 @@ describe('job lifecycle timestamp columns', () => {
       'UPDATE job_queue SET next_attempt_at = NOW() WHERE id = $1',
       [jobId],
     );
-    // Pick up for processing again (should increment attempts and set last_retried_at)
+    // Pick up for processing again (should increment attempts and set lastRetriedAt)
     await queue.getNextBatch(pool, 'worker-ts', 1);
     const job = await getJobRow(jobId);
-    expect(job.last_retried_at).not.toBeNull();
+    expect(job.lastRetriedAt).not.toBeNull();
   });
 
-  it('sets last_cancelled_at when job is cancelled', async () => {
+  it('sets lastCancelledAt when job is cancelled', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'ts5@example.com' },
     });
     await queue.cancelJob(pool, jobId);
     const job = await getJobRow(jobId);
-    expect(job.last_cancelled_at).not.toBeNull();
+    expect(job.lastCancelledAt).not.toBeNull();
   });
 
-  it('sets last_retried_at when job is picked up for processing again (attempts > 0)', async () => {
+  it('sets lastRetriedAt when job is picked up for processing again (attempts > 0)', async () => {
     const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
-      job_type: 'email',
+      jobType: 'email',
       payload: { to: 'ts6@example.com' },
     });
     // First pick up and fail the job
@@ -494,9 +495,9 @@ describe('job lifecycle timestamp columns', () => {
       'UPDATE job_queue SET next_attempt_at = NOW() WHERE id = $1',
       [jobId],
     );
-    // Pick up for processing again (should increment attempts and set last_retried_at)
+    // Pick up for processing again (should increment attempts and set lastRetriedAt)
     await queue.getNextBatch(pool, 'worker-ts', 1);
     const job = await getJobRow(jobId);
-    expect(job.last_retried_at).not.toBeNull();
+    expect(job.lastRetriedAt).not.toBeNull();
   });
 });