@nicnocquee/dataqueue 1.16.0 → 1.17.0

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();
   });
 });

package/src/queue.ts

@@ -37,27 +37,27 @@ export const recordJobEvent = async (
 export const addJob = async <PayloadMap, T extends keyof PayloadMap & string>(
   pool: Pool,
   {
-    job_type,
+    jobType,
     payload,
-    max_attempts = 3,
+    maxAttempts = 3,
     priority = 0,
-    run_at = null,
+    runAt = null,
     timeoutMs = undefined,
   }: JobOptions<PayloadMap, T>,
 ): Promise<number> => {
   const client = await pool.connect();
   try {
     let result;
-    if (run_at) {
+    if (runAt) {
       result = await client.query(
         `INSERT INTO job_queue 
           (job_type, payload, max_attempts, priority, run_at, timeout_ms) 
          VALUES ($1, $2, $3, $4, $5, $6) 
          RETURNING id`,
-        [job_type, payload, max_attempts, priority, run_at, timeoutMs ?? null],
+        [jobType, payload, maxAttempts, priority, runAt, timeoutMs ?? null],
       );
       log(
-        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, run_at ${run_at.toISOString()}, priority ${priority}, max_attempts ${max_attempts} job_type ${job_type}`,
+        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, runAt ${runAt.toISOString()}, priority ${priority}, maxAttempts ${maxAttempts} jobType ${jobType}`,
       );
     } else {
       result = await client.query(
@@ -65,14 +65,14 @@ export const addJob = async <PayloadMap, T extends keyof PayloadMap & string>(
           (job_type, payload, max_attempts, priority, timeout_ms) 
          VALUES ($1, $2, $3, $4, $5) 
          RETURNING id`,
-        [job_type, payload, max_attempts, priority, timeoutMs ?? null],
+        [jobType, payload, maxAttempts, priority, timeoutMs ?? null],
       );
       log(
-        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, priority ${priority}, max_attempts ${max_attempts} job_type ${job_type}`,
+        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, priority ${priority}, maxAttempts ${maxAttempts} jobType ${jobType}`,
       );
     }
     await recordJobEvent(pool, result.rows[0].id, JobEventType.Added, {
-      job_type,
+      jobType,
       payload,
     });
     return result.rows[0].id;
@@ -93,9 +93,10 @@ export const getJob = async <PayloadMap, T extends keyof PayloadMap & string>(
 ): Promise<JobRecord<PayloadMap, T> | null> => {
   const client = await pool.connect();
   try {
-    const result = await client.query('SELECT * FROM job_queue WHERE id = $1', [
-      id,
-    ]);
+    const result = await client.query(
+      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue WHERE id = $1`,
+      [id],
+    );
 
     if (result.rows.length === 0) {
       log(`Job ${id} not found`);
@@ -104,11 +105,13 @@ export const getJob = async <PayloadMap, T extends keyof PayloadMap & string>(
 
     log(`Found job ${id}`);
 
+    const job = result.rows[0] as JobRecord<PayloadMap, T>;
+
     return {
-      ...result.rows[0],
-      payload: result.rows[0].payload,
-      timeout_ms: result.rows[0].timeout_ms,
-      failure_reason: result.rows[0].failure_reason,
+      ...job,
+      payload: job.payload,
+      timeoutMs: job.timeoutMs,
+      failureReason: job.failureReason,
     };
   } catch (error) {
     log(`Error getting job ${id}: ${error}`);
@@ -133,17 +136,17 @@ export const getJobsByStatus = async <
   const client = await pool.connect();
   try {
     const result = await client.query(
-      'SELECT * FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3',
+      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3`,
       [status, limit, offset],
     );
 
     log(`Found ${result.rows.length} jobs by status ${status}`);
 
-    return result.rows.map((row) => ({
-      ...row,
-      payload: row.payload,
-      timeout_ms: row.timeout_ms,
-      failure_reason: row.failure_reason,
+    return result.rows.map((job) => ({
+      ...job,
+      payload: job.payload,
+      timeoutMs: job.timeoutMs,
+      failureReason: job.failureReason,
     }));
   } catch (error) {
     log(`Error getting jobs by status ${status}: ${error}`);
@@ -209,7 +212,7 @@ export const getNextBatch = async <
         LIMIT $2
         FOR UPDATE SKIP LOCKED
       )
-      RETURNING *
+      RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason"
     `,
       params,
     );
@@ -224,10 +227,10 @@ export const getNextBatch = async <
       await recordJobEvent(pool, row.id, JobEventType.Processing);
     }
 
-    return result.rows.map((row) => ({
-      ...row,
-      payload: row.payload,
-      timeout_ms: row.timeout_ms,
+    return result.rows.map((job) => ({
+      ...job,
+      payload: job.payload,
+      timeoutMs: job.timeoutMs,
     }));
   } catch (error) {
     log(`Error getting next batch: ${error}`);
@@ -397,7 +400,7 @@ export const cancelJob = async (pool: Pool, jobId: number): Promise<void> => {
  */
 export const cancelAllUpcomingJobs = async (
   pool: Pool,
-  filters?: { job_type?: string; priority?: number; run_at?: Date },
+  filters?: { jobType?: string; priority?: number; runAt?: Date },
 ): Promise<number> => {
   const client = await pool.connect();
   try {
@@ -408,17 +411,17 @@ export const cancelAllUpcomingJobs = async (
     const params: any[] = [];
     let paramIdx = 1;
     if (filters) {
-      if (filters.job_type) {
+      if (filters.jobType) {
         query += ` AND job_type = $${paramIdx++}`;
-        params.push(filters.job_type);
+        params.push(filters.jobType);
       }
       if (filters.priority !== undefined) {
         query += ` AND priority = $${paramIdx++}`;
         params.push(filters.priority);
       }
-      if (filters.run_at) {
+      if (filters.runAt) {
         query += ` AND run_at = $${paramIdx++}`;
-        params.push(filters.run_at);
+        params.push(filters.runAt);
       }
     }
     query += '\nRETURNING id';
@@ -447,14 +450,14 @@ export const getAllJobs = async <
   const client = await pool.connect();
   try {
     const result = await client.query(
-      'SELECT * FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2',
+      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
       [limit, offset],
     );
     log(`Found ${result.rows.length} jobs (all)`);
-    return result.rows.map((row) => ({
-      ...row,
-      payload: row.payload,
-      timeout_ms: row.timeout_ms,
+    return result.rows.map((job) => ({
+      ...job,
+      payload: job.payload,
+      timeoutMs: job.timeoutMs,
     }));
   } catch (error) {
     log(`Error getting all jobs: ${error}`);
@@ -528,7 +531,7 @@ export const reclaimStuckJobs = async (
 };
 
 /**
- * Get all events for a job, ordered by created_at ascending
+ * Get all events for a job, ordered by createdAt ascending
  */
 export const getJobEvents = async (
   pool: Pool,
@@ -537,10 +540,10 @@ export const getJobEvents = async (
   const client = await pool.connect();
   try {
     const res = await client.query(
-      'SELECT * FROM job_events WHERE job_id = $1 ORDER BY created_at ASC',
+      `SELECT id, job_id AS "jobId", event_type AS "eventType", metadata, created_at AS "createdAt" FROM job_events WHERE job_id = $1 ORDER BY created_at ASC`,
       [jobId],
     );
-    return res.rows;
+    return res.rows as JobEvent[];
   } finally {
     client.release();
   }