queuex-sdk/dist/lib.js

A TypeScript-based queue management SDK with Redis support

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JobState = exports.QueueX = void 0;
const events_1 = require("events");
const queue_manager_1 = require("./services/queue-manager");
const worker_1 = require("./services/worker");
const redis_1 = require("./storage/redis");
const job_1 = require("./models/job");
Object.defineProperty(exports, "JobState", { enumerable: true, get: function () { return job_1.JobState; } });
/**
 * Main entry point for QueueX SDK, managing queues and workers.
 */
class QueueX {
    constructor(config) {
        this.workers = [];
        try {
            this.storage = new redis_1.RedisStorage(config.redisConnection);
            this.queueManager = new queue_manager_1.QueueManager(config.redisConnection, this.emitEvent.bind(this));
            this.eventEmitter = new events_1.EventEmitter();
        }
        catch (err) {
            throw new Error(`Failed to initialize QueueX: ${err instanceof Error ? err.message : String(err)}`);
        }
    }
    async createQueue(name, options = {}) {
        await this.queueManager.createQueue(name, options);
        const queue = {
            name,
            options: {
                maxConcurrency: 1,
                ...options,
            },
        };
        return queue;
    }
    async enqueue(queueName, data, options = {}) {
        return this.queueManager.enqueue(queueName, data, options);
    }
    async unscheduleJob(jobId) {
        return this.queueManager.unscheduleJob(jobId);
    }
    async updateJobDelay(jobId, newDelay) {
        return this.queueManager.updateJobDelay(jobId, newDelay);
    }
    startWorker(queueName, processor, concurrency) {
        const worker = new worker_1.Worker(this.queueManager, this.storage, concurrency || 1, this.emitEvent.bind(this));
        this.workers.push(worker);
        worker.start(queueName, processor).catch((err) => console.error(`Worker error for ${queueName}:`, err));
        return worker;
    }
    async shutdown() {
        try {
            for (const worker of this.workers) {
                worker.stop();
            }
            this.queueManager.stopScheduler();
            await this.storage.disconnect();
        }
        catch (err) {
            throw new Error(`Failed to shutdown QueueX: ${err instanceof Error ? err.message : String(err)}`);
        }
    }
    on(event, listener) {
        this.eventEmitter.on(event, listener);
    }
    emitEvent(event, job) {
        this.eventEmitter.emit(event, job);
        this.storage
            .logEvent(event, job)
            .catch((err) => console.error(`Failed to log event for ${job.id}:`, err));
    }
    async getEvents(jobId) {
        return this.storage.getEvents(jobId);
    }
}
exports.QueueX = QueueX;