queue-tool 1.0.0

package/dist/adapters/postgres.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresQueueAdapter = void 0;
+const pg_1 = require("pg");
+const msgpack_1 = require("../utils/msgpack");
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+class PostgresQueueAdapter {
+    pool;
+    options;
+    pruneTimer;
+    constructor(connectionString, options) {
+        this.pool = new pg_1.Pool({ connectionString });
+        this.options = {
+            completedJobTtlMs: options?.completedJobTtlMs ?? 3600000, // 1 hour
+            failedJobTtlMs: options?.failedJobTtlMs ?? 86400000, // 24 hours
+            lockTimeoutMs: options?.lockTimeoutMs ?? 300000, // 5 minutes
+            pruneIntervalMs: options?.pruneIntervalMs ?? 60000, // 1 minute
+        };
+    }
+    async init() {
+        try {
+            await this.pool.query('SELECT 1');
+            logger_1.logger.info('Postgres connection verified successfully');
+        }
+        catch (e) {
+            logger_1.logger.error('Postgres connection health check failed', { error: e.message });
+            throw new Error(`Postgres connection health check failed: ${e.message}`);
+        }
+        const query = `
+      CREATE TABLE IF NOT EXISTS jobs (
+        id VARCHAR(255) PRIMARY KEY,
+        queue VARCHAR(255) NOT NULL,
+        payload BYTEA NOT NULL,
+        status VARCHAR(50) NOT NULL DEFAULT 'pending',
+        priority INT NOT NULL DEFAULT 0,
+        attempts INT NOT NULL DEFAULT 0,
+        max_attempts INT NOT NULL DEFAULT 3,
+        run_at TIMESTAMP WITH TIME ZONE NOT NULL,
+        locked_at TIMESTAMP WITH TIME ZONE,
+        completed_at TIMESTAMP WITH TIME ZONE,
+        failed_at TIMESTAMP WITH TIME ZONE,
+        expires_at TIMESTAMP WITH TIME ZONE,
+        error TEXT,
+        worker_id VARCHAR(255)
+      );
+      CREATE INDEX IF NOT EXISTS idx_jobs_claim ON jobs (queue, status, run_at, priority DESC);
+      CREATE INDEX IF NOT EXISTS idx_jobs_expires ON jobs (expires_at) WHERE expires_at IS NOT NULL;
+    `;
+        await this.pool.query(query);
+        if (this.options.pruneIntervalMs && this.options.pruneIntervalMs > 0) {
+            this.pruneTimer = setInterval(() => {
+                this.pool.query(`DELETE FROM jobs WHERE expires_at <= NOW()`).catch(err => {
+                    logger_1.logger.error('QueueTool Postgres background prune error', { error: err.message });
+                });
+            }, this.options.pruneIntervalMs);
+        }
+    }
+    async enqueue(queueName, payload, options) {
+        const id = options?.id ?? (0, crypto_1.randomUUID)();
+        const serializedPayload = (0, msgpack_1.serialize)(payload);
+        const priority = options?.priority ?? 0;
+        const maxAttempts = options?.maxAttempts ?? 3;
+        if (priority < -1000 || priority > 1000) {
+            logger_1.logger.error('Invalid job priority', { priority, queue: queueName });
+            throw new Error('Priority must be in the range [-1000, 1000]');
+        }
+        let runAt = options?.runAt ?? new Date();
+        if (options?.delayMs) {
+            runAt = new Date(Date.now() + options.delayMs);
+        }
+        // Check if job exists
+        const checkRes = await this.pool.query('SELECT 1 FROM jobs WHERE id = $1', [id]);
+        const existingJob = checkRes.rows.length > 0;
+        const query = `
+      INSERT INTO jobs (id, queue, payload, status, priority, attempts, max_attempts, run_at, locked_at, completed_at, failed_at, expires_at, error, worker_id)
+      VALUES ($1, $2, $3, 'pending', $4, 0, $5, $6, NULL, NULL, NULL, NULL, NULL, NULL)
+      ON CONFLICT (id) DO UPDATE SET
+        queue = EXCLUDED.queue,
+        payload = EXCLUDED.payload,
+        status = 'pending',
+        priority = EXCLUDED.priority,
+        attempts = 0,
+        max_attempts = EXCLUDED.max_attempts,
+        run_at = EXCLUDED.run_at,
+        locked_at = NULL,
+        completed_at = NULL,
+        failed_at = NULL,
+        expires_at = NULL,
+        error = NULL,
+        worker_id = NULL
+      RETURNING *;
+    `;
+        const res = await this.pool.query(query, [
+            id,
+            queueName,
+            serializedPayload,
+            priority,
+            maxAttempts,
+            runAt
+        ]);
+        // Send a notification for instant worker wakeup
+        await this.pool.query(`NOTIFY jobs_update, $1`, [queueName]);
+        logger_1.logger.info(existingJob ? 'Job updated/retried successfully' : 'Job enqueued successfully', { queue: queueName, jobId: id, priority });
+        return this.mapRowToJob(res.rows[0]);
+    }
+    async claimJob(queueName, workerId) {
+        const lockTimeoutMs = this.options.lockTimeoutMs || 300000;
+        // Atomically claim the next eligible job using SKIP LOCKED
+        const query = `
+      UPDATE jobs
+      SET status = 'processing', locked_at = NOW(), worker_id = $1, attempts = attempts + 1
+      WHERE id = (
+        SELECT id FROM jobs
+        WHERE queue = $2 
+          AND (status = 'pending' OR (status = 'processing' AND locked_at <= NOW() - CAST($3 || ' milliseconds' AS INTERVAL)))
+          AND run_at <= NOW()
+        ORDER BY priority DESC, run_at ASC
+        LIMIT 1
+        FOR UPDATE SKIP LOCKED
+      )
+      RETURNING *;
+    `;
+        const res = await this.pool.query(query, [workerId, queueName, lockTimeoutMs]);
+        if (res.rows.length === 0) {
+            return null;
+        }
+        const job = this.mapRowToJob(res.rows[0]);
+        logger_1.logger.info('Job claimed successfully', { queue: queueName, jobId: job.id, workerId });
+        return job;
+    }
+    async completeJob(jobId) {
+        const query = `
+      UPDATE jobs
+      SET status = 'completed', completed_at = NOW(), expires_at = NULL
+      WHERE id = $1
+      RETURNING queue;
+    `;
+        const res = await this.pool.query(query, [jobId]);
+        if (res.rows.length === 0) {
+            logger_1.logger.warn('Tried to complete job that does not exist', { jobId });
+            return;
+        }
+        logger_1.logger.info('Job completed successfully', { queue: res.rows[0].queue, jobId });
+    }
+    async failJob(jobId, error) {
+        // Check if we can retry the job
+        const checkQuery = `
+      SELECT queue, attempts, max_attempts FROM jobs WHERE id = $1;
+    `;
+        const checkRes = await this.pool.query(checkQuery, [jobId]);
+        if (checkRes.rows.length === 0) {
+            logger_1.logger.warn('Tried to fail job that does not exist', { jobId, error });
+            return;
+        }
+        const { queue, attempts, max_attempts } = checkRes.rows[0];
+        if (attempts < max_attempts) {
+            // Retry: Set status back to pending, delay retry by 5 seconds
+            const retryQuery = `
+        UPDATE jobs
+        SET status = 'pending', run_at = NOW() + INTERVAL '5 seconds', error = $2, worker_id = NULL
+        WHERE id = $1;
+      `;
+            await this.pool.query(retryQuery, [jobId, error]);
+            logger_1.logger.warn('Job execution failed, scheduling retry', { queue, jobId, error, attempt: attempts, maxAttempts: max_attempts });
+        }
+        else {
+            // Terminal Failure
+            const expiresAt = new Date(Date.now() + (this.options.failedJobTtlMs || 86400000));
+            const failQuery = `
+        UPDATE jobs
+        SET status = 'failed', failed_at = NOW(), error = $2, expires_at = $3
+        WHERE id = $1;
+      `;
+            await this.pool.query(failQuery, [jobId, error, expiresAt]);
+            logger_1.logger.error('Job failed terminally', { queue, jobId, error, attempts });
+        }
+    }
+    async listenToQueue(queueName, callback) {
+        const client = await this.pool.connect();
+        await client.query('LISTEN jobs_update');
+        const notificationListener = (msg) => {
+            if (msg.payload === queueName) {
+                callback();
+            }
+        };
+        client.on('notification', notificationListener);
+        return async () => {
+            client.off('notification', notificationListener);
+            await client.query('UNLISTEN jobs_update');
+            client.release();
+        };
+    }
+    async close() {
+        if (this.pruneTimer) {
+            clearInterval(this.pruneTimer);
+        }
+        await this.pool.end();
+    }
+    mapRowToJob(row) {
+        return {
+            id: row.id,
+            queue: row.queue,
+            payload: (0, msgpack_1.deserialize)(row.payload),
+            status: row.status,
+            priority: row.priority,
+            attempts: row.attempts,
+            maxAttempts: row.max_attempts,
+            runAt: new Date(row.run_at),
+            lockedAt: row.locked_at ? new Date(row.locked_at) : undefined,
+            completedAt: row.completed_at ? new Date(row.completed_at) : undefined,
+            failedAt: row.failed_at ? new Date(row.failed_at) : undefined,
+            expiresAt: row.expires_at ? new Date(row.expires_at) : undefined,
+            error: row.error || undefined,
+            workerId: row.worker_id || undefined,
+        };
+    }
+}
+exports.PostgresQueueAdapter = PostgresQueueAdapter;

package/dist/adapters/postgres.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/postgres.test.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postgres_1 = require("./postgres");
+const pg_1 = require("pg");
+describe('PostgresQueueAdapter Integration Tests', () => {
+    let adapter;
+    let pool;
+    const queueName = 'test-postgres-integration-queue';
+    const connectionString = 'postgres://postgres:password@localhost:5432/queue_tool';
+    let isAvailable = true;
+    beforeAll(async () => {
+        try {
+            pool = new pg_1.Pool({ connectionString });
+            // Quick probe
+            await pool.query('SELECT 1');
+            adapter = new postgres_1.PostgresQueueAdapter(connectionString);
+            await adapter.init();
+        }
+        catch (err) {
+            isAvailable = false;
+            console.warn('Postgres is not running. Skipping Postgres integration tests.');
+        }
+    });
+    afterAll(async () => {
+        if (!isAvailable)
+            return;
+        await adapter.close();
+        await pool.end();
+    });
+    beforeEach(async () => {
+        if (!isAvailable)
+            return;
+        // Clean test queue jobs
+        await pool.query('DELETE FROM jobs WHERE queue = $1', [queueName]);
+    });
+    test('should enqueue a job successfully', async () => {
+        if (!isAvailable)
+            return;
+        const payload = { task: 'test-postgres-enqueue', value: 100 };
+        const job = await adapter.enqueue(queueName, payload, { priority: 10 });
+        expect(job.id).toBeDefined();
+        expect(job.queue).toBe(queueName);
+        expect(job.payload).toEqual(payload);
+        expect(job.status).toBe('pending');
+        expect(job.priority).toBe(10);
+    });
+    test('should fail validation on invalid priority bounds', async () => {
+        if (!isAvailable)
+            return;
+        const payload = { task: 'test-priority-bounds' };
+        await expect(adapter.enqueue(queueName, payload, { priority: 2000 })).rejects.toThrow('Priority must be in the range [-1000, 1000]');
+    });
+    test('should support deduplication and idempotency with custom job ID', async () => {
+        if (!isAvailable)
+            return;
+        const payload = { task: 'dedup', step: 1 };
+        const customId = 'custom-postgres-job-id';
+        const job1 = await adapter.enqueue(queueName, payload, { id: customId, priority: 5 });
+        expect(job1.id).toBe(customId);
+        expect(job1.status).toBe('pending');
+        // Claim the job so it changes status to processing
+        const claimedJob = await adapter.claimJob(queueName, 'worker-1');
+        expect(claimedJob).not.toBeNull();
+        expect(claimedJob.id).toBe(customId);
+        expect(claimedJob.status).toBe('processing');
+        // Enqueue again with the same custom ID but updated payload
+        const updatedPayload = { task: 'dedup', step: 2 };
+        const job2 = await adapter.enqueue(queueName, updatedPayload, { id: customId, priority: 8 });
+        expect(job2.id).toBe(customId);
+        expect(job2.status).toBe('pending'); // Reset to pending
+        expect(job2.attempts).toBe(0); // Reset attempts
+        expect(job2.priority).toBe(8); // Updated priority
+        expect(job2.payload).toEqual(updatedPayload);
+        // Verify in db
+        const res = await pool.query('SELECT * FROM jobs WHERE id = $1', [customId]);
+        expect(res.rows.length).toBe(1);
+        expect(res.rows[0].status).toBe('pending');
+        expect(res.rows[0].attempts).toBe(0);
+        expect(res.rows[0].priority).toBe(8);
+    });
+    test('should claim and complete a job successfully', async () => {
+        if (!isAvailable)
+            return;
+        const payload = { task: 'test-postgres-claim', value: 200 };
+        const job = await adapter.enqueue(queueName, payload);
+        const claimedJob = await adapter.claimJob(queueName, 'worker-test-pg-1');
+        expect(claimedJob).not.toBeNull();
+        expect(claimedJob.id).toBe(job.id);
+        expect(claimedJob.status).toBe('processing');
+        expect(claimedJob.attempts).toBe(1);
+        await adapter.completeJob(claimedJob.id);
+        const res = await pool.query('SELECT status FROM jobs WHERE id = $1', [job.id]);
+        expect(res.rows.length).toBe(1);
+        expect(res.rows[0].status).toBe('completed');
+    });
+    test('should fail and retry job within maxAttempts limit', async () => {
+        if (!isAvailable)
+            return;
+        const payload = { task: 'test-postgres-retry' };
+        const job = await adapter.enqueue(queueName, payload, { maxAttempts: 2 });
+        const claimedJob = await adapter.claimJob(queueName, 'worker-test-pg-2');
+        expect(claimedJob).not.toBeNull();
+        await adapter.failJob(claimedJob.id, 'First test error pg');
+        const res1 = await pool.query('SELECT status, error FROM jobs WHERE id = $1', [job.id]);
+        expect(res1.rows[0].status).toBe('pending');
+        expect(res1.rows[0].error).toBe('First test error pg');
+        // Wait for the 5-second retry delay (or we can manually update run_at to past)
+        await pool.query('UPDATE jobs SET run_at = NOW() - INTERVAL \'1 minute\' WHERE id = $1', [job.id]);
+        // Claim again (2nd attempt)
+        const claimedJob2 = await adapter.claimJob(queueName, 'worker-test-pg-2');
+        expect(claimedJob2).not.toBeNull();
+        expect(claimedJob2.attempts).toBe(2);
+        // Fail again -> terminal failure
+        await adapter.failJob(claimedJob2.id, 'Second test error pg');
+        const res2 = await pool.query('SELECT status, error FROM jobs WHERE id = $1', [job.id]);
+        expect(res2.rows[0].status).toBe('failed');
+        expect(res2.rows[0].error).toBe('Second test error pg');
+    });
+});

package/dist/adapters/redis.d.ts

@@ -0,0 +1,13 @@
+import { IQueueAdapter, Job, EnqueueOptions, QueueAdapterOptions } from '../types';
+export declare class RedisQueueAdapter implements IQueueAdapter {
+    private redis;
+    private options;
+    constructor(connectionString: string, options?: QueueAdapterOptions);
+    init(): Promise<void>;
+    enqueue<T>(queueName: string, payload: T, options?: EnqueueOptions): Promise<Job<T>>;
+    claimJob(queueName: string, workerId: string): Promise<Job | null>;
+    completeJob(jobId: string): Promise<void>;
+    failJob(jobId: string, error: string): Promise<void>;
+    getJob(jobId: string): Promise<Job | null>;
+    close(): Promise<void>;
+}

package/dist/adapters/redis.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisQueueAdapter = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const msgpack_1 = require("../utils/msgpack");
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+class RedisQueueAdapter {
+    redis;
+    options;
+    constructor(connectionString, options) {
+        this.redis = new ioredis_1.default(connectionString);
+        this.options = {
+            completedJobTtlMs: options?.completedJobTtlMs ?? 3600000, // 1 hour
+            failedJobTtlMs: options?.failedJobTtlMs ?? 86400000, // 24 hours
+            lockTimeoutMs: options?.lockTimeoutMs ?? 300000, // 5 minutes
+        };
+    }
+    async init() {
+        try {
+            await this.redis.ping();
+            logger_1.logger.info('Redis connection verified successfully');
+        }
+        catch (e) {
+            logger_1.logger.error('Redis connection health check failed', { error: e.message });
+            throw new Error(`Redis connection health check failed: ${e.message}`);
+        }
+    }
+    async enqueue(queueName, payload, options) {
+        const priority = options?.priority ?? 0;
+        const maxAttempts = options?.maxAttempts ?? 3;
+        if (priority < -1000 || priority > 1000) {
+            logger_1.logger.error('Invalid job priority', { priority, queue: queueName });
+            throw new Error('Priority must be in the range [-1000, 1000]');
+        }
+        let id = options?.id;
+        let existingJob = null;
+        if (id) {
+            existingJob = await this.getJob(id);
+        }
+        if (!id) {
+            id = (0, crypto_1.randomUUID)();
+        }
+        const serializedPayload = (0, msgpack_1.serialize)(payload);
+        let runAt = options?.runAt ?? new Date();
+        if (options?.delayMs) {
+            runAt = new Date(Date.now() + options.delayMs);
+        }
+        const jobKey = `job:${id}`;
+        const runAtTime = runAt.getTime();
+        // Calculate score. A higher priority should run first.
+        // Base score is the timestamp in ms. We subtract priority * 10,000,000,000 to push prioritized jobs to the front.
+        const score = runAtTime - (priority * 10000000000);
+        // Pipeline the writes to reduce round-trips and improve enqueue performance.
+        const pipeline = this.redis.multi();
+        pipeline.hmset(jobKey, 'id', id, 'queue', queueName, 'payload', serializedPayload, 'status', 'pending', 'priority', priority.toString(), 'attempts', '0', 'max_attempts', maxAttempts.toString(), 'run_at', runAtTime.toString());
+        pipeline.hdel(jobKey, 'worker_id', 'locked_at', 'error', 'completed_at', 'failed_at');
+        pipeline.zrem(`queue:${queueName}:processing`, id);
+        pipeline.zadd(`queue:${queueName}:pending`, score, id);
+        pipeline.publish(`queue:${queueName}:updates`, 'new_job');
+        await pipeline.exec();
+        logger_1.logger.info(existingJob ? 'Job updated/retried successfully' : 'Job enqueued successfully', { queue: queueName, jobId: id, priority });
+        return {
+            id,
+            queue: queueName,
+            payload,
+            status: 'pending',
+            priority,
+            attempts: 0,
+            maxAttempts,
+            runAt
+        };
+    }
+    async claimJob(queueName, workerId) {
+        const pendingKey = `queue:${queueName}:pending`;
+        const processingKey = `queue:${queueName}:processing`;
+        const currentTime = Date.now();
+        const lockTimeoutMs = this.options.lockTimeoutMs || 300000;
+        // Lua script to atomically find and claim a job (pending or timed out)
+        const claimScript = `
+      local pending_key = KEYS[1]
+      local processing_key = KEYS[2]
+      local current_time = tonumber(ARGV[1])
+      local worker_id = ARGV[2]
+      local lock_timeout_ms = tonumber(ARGV[3])
+
+      local job_id = nil
+      local from_processing = false
+
+      -- 1. Try to get the earliest pending job
+      local jobs = redis.call('ZRANGE', pending_key, 0, 0)
+      if #jobs > 0 then
+        local p_job_id = jobs[1]
+        local run_at = tonumber(redis.call('HGET', 'job:' .. p_job_id, 'run_at'))
+        if run_at and run_at <= current_time then
+          job_id = p_job_id
+        end
+      end
+
+      -- 2. If no pending job is available, check for timed-out processing jobs
+      if not job_id then
+        local timed_out_jobs = redis.call('ZRANGEBYSCORE', processing_key, 0, current_time - lock_timeout_ms, 'LIMIT', 0, 1)
+        if #timed_out_jobs > 0 then
+          job_id = timed_out_jobs[1]
+          from_processing = true
+        end
+      end
+
+      if not job_id then
+        return nil
+      end
+
+      -- Move or update processing set score
+      if from_processing then
+        redis.call('ZADD', processing_key, current_time, job_id)
+      else
+        redis.call('ZREM', pending_key, job_id)
+        redis.call('ZADD', processing_key, current_time, job_id)
+      end
+
+      -- Update job hash status and worker info
+      local job_key = 'job:' .. job_id
+      redis.call('HMSET', job_key, 'status', 'processing', 'worker_id', worker_id, 'locked_at', current_time)
+      redis.call('HINCRBY', job_key, 'attempts', 1)
+
+      return job_id
+    `;
+        const jobIdRaw = await this.redis.eval(claimScript, 2, pendingKey, processingKey, currentTime.toString(), workerId, lockTimeoutMs.toString());
+        if (!jobIdRaw) {
+            return null;
+        }
+        const jobId = typeof jobIdRaw === 'string' ? jobIdRaw : jobIdRaw.toString();
+        const job = await this.getJob(jobId);
+        if (job) {
+            logger_1.logger.info('Job claimed successfully', { queue: queueName, jobId: job.id, workerId });
+        }
+        return job;
+    }
+    async completeJob(jobId) {
+        const jobKey = `job:${jobId}`;
+        const queue = await this.redis.hget(jobKey, 'queue');
+        if (!queue) {
+            logger_1.logger.warn('Tried to complete job that does not exist or missing queue', { jobId });
+            return;
+        }
+        const processingKey = `queue:${queue}:processing`;
+        const currentTime = Date.now();
+        await this.redis.hmset(jobKey, {
+            status: 'completed',
+            completed_at: currentTime.toString(),
+        });
+        await this.redis.zrem(processingKey, jobId);
+        logger_1.logger.info('Job completed successfully', { queue, jobId });
+        if (this.options.completedJobTtlMs && this.options.completedJobTtlMs > 0) {
+            const ttlSecs = Math.max(1, Math.floor(this.options.completedJobTtlMs / 1000));
+            await this.redis.expire(jobKey, ttlSecs);
+        }
+    }
+    async failJob(jobId, error) {
+        const jobKey = `job:${jobId}`;
+        const jobData = await this.redis.hgetall(jobKey);
+        if (!jobData || !jobData.queue) {
+            logger_1.logger.warn('Tried to fail job that does not exist or missing queue', { jobId, error });
+            return;
+        }
+        const queue = jobData.queue;
+        const attempts = Number.isNaN(parseInt(jobData.attempts || '0', 10)) ? 0 : parseInt(jobData.attempts || '0', 10);
+        const maxAttempts = Number.isNaN(parseInt(jobData.max_attempts || '3', 10)) ? 0 : parseInt(jobData.max_attempts || '3', 10);
+        const currentTime = Date.now();
+        if (attempts < maxAttempts) {
+            // Retry: Set status back to pending, delay retry by 5 seconds
+            const runAtTime = currentTime + 5000;
+            const priority = Number.isNaN(parseInt(jobData.priority || '0', 10)) ? 0 : parseInt(jobData.priority || '0', 10);
+            const score = runAtTime - (priority * 10000000000);
+            await this.redis.hmset(jobKey, {
+                status: 'pending',
+                run_at: runAtTime.toString(),
+                error,
+            });
+            await this.redis.hdel(jobKey, 'worker_id', 'locked_at');
+            await this.redis.zrem(`queue:${queue}:processing`, jobId);
+            await this.redis.zadd(`queue:${queue}:pending`, score, jobId);
+            logger_1.logger.warn('Job execution failed, scheduling retry', { queue, jobId, error, attempt: attempts, maxAttempts });
+        }
+        else {
+            // Terminal Failure
+            await this.redis.hmset(jobKey, {
+                status: 'failed',
+                failed_at: currentTime.toString(),
+                error,
+            });
+            await this.redis.zrem(`queue:${queue}:processing`, jobId);
+            logger_1.logger.error('Job failed terminally', { queue, jobId, error, attempts });
+            if (this.options.failedJobTtlMs && this.options.failedJobTtlMs > 0) {
+                const ttlSecs = Math.max(1, Math.floor(this.options.failedJobTtlMs / 1000));
+                await this.redis.expire(jobKey, ttlSecs);
+            }
+        }
+    }
+    async getJob(jobId) {
+        const jobKey = `job:${jobId}`;
+        const data = await this.redis.hgetall(jobKey);
+        if (!data || Object.keys(data).length === 0)
+            return null;
+        // Fast payload fetching using buffer to preserve binary signature of MessagePack
+        const bufferPayload = await this.redis.hgetBuffer(jobKey, 'payload');
+        let payload = null;
+        if (bufferPayload) {
+            try {
+                payload = (0, msgpack_1.deserialize)(bufferPayload);
+            }
+            catch (e) {
+                payload = null;
+            }
+        }
+        const safeInt = (v, fallback = 0) => {
+            const n = parseInt(v ?? String(fallback), 10);
+            return Number.isNaN(n) ? fallback : n;
+        };
+        return {
+            id: data.id,
+            queue: data.queue,
+            payload,
+            status: data.status || 'pending',
+            priority: safeInt(data.priority, 0),
+            attempts: safeInt(data.attempts, 0),
+            maxAttempts: safeInt(data.max_attempts, 3),
+            runAt: new Date(safeInt(data.run_at, Date.now())),
+            lockedAt: data.locked_at ? new Date(safeInt(data.locked_at, 0)) : undefined,
+            completedAt: data.completed_at ? new Date(safeInt(data.completed_at, 0)) : undefined,
+            failedAt: data.failed_at ? new Date(safeInt(data.failed_at, 0)) : undefined,
+            error: data.error || undefined,
+            workerId: data.worker_id || undefined,
+        };
+    }
+    async close() {
+        await this.redis.quit();
+    }
+}
+exports.RedisQueueAdapter = RedisQueueAdapter;

package/dist/adapters/redis.test.d.ts

@@ -0,0 +1 @@
+export {};