redis-smq/dist/cjs/src/lib/queue/queue.js

A simple high-performance Redis message queue for Node.js.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Queue = void 0;
const redis_smq_common_1 = require("redis-smq-common");
const index_js_1 = require("../../common/index.js");
const redis_client_js_1 = require("../../common/redis-client/redis-client.js");
const scripts_js_1 = require("../../common/redis-client/scripts/scripts.js");
const redis_keys_js_1 = require("../../common/redis-keys/redis-keys.js");
const index_js_2 = require("../../config/index.js");
const _delete_queue_js_1 = require("./_/_delete-queue.js");
const _get_queue_consumer_ids_js_1 = require("./_/_get-queue-consumer-ids.js");
const _get_queue_consumers_js_1 = require("./_/_get-queue-consumers.js");
const _get_queue_properties_js_1 = require("./_/_get-queue-properties.js");
const _get_queues_js_1 = require("./_/_get-queues.js");
const _parse_queue_params_js_1 = require("./_/_parse-queue-params.js");
const _queue_exists_js_1 = require("./_/_queue-exists.js");
const index_js_3 = require("./errors/index.js");
const index_js_4 = require("./types/index.js");
class Queue {
    constructor() {
        this.shutdown = (cb) => {
            this.logger.info('Shutting down Queue instance');
            redis_smq_common_1.async.series([
                (next) => {
                    this.logger.debug('Shutting down Redis client');
                    this.redisClient.shutdown((err) => {
                        if (err) {
                            this.logger.error(`Error shutting down Redis client: ${err.message}`, err);
                        }
                        else {
                            this.logger.debug('Redis client shutdown successful');
                        }
                        next(err);
                    });
                },
                (next) => {
                    this.logger.debug('Shutting down EventBus');
                    this.eventBus.shutdown((err) => {
                        if (err) {
                            this.logger.error(`Error shutting down EventBus: ${err.message}`, err);
                        }
                        else {
                            this.logger.debug('EventBus shutdown successful');
                        }
                        next(err);
                    });
                },
            ], (err) => {
                if (err) {
                    this.logger.error(`Error during Queue shutdown: ${err.message}`, err);
                }
                else {
                    this.logger.info('Queue instance shutdown completed successfully');
                }
                cb(err);
            });
        };
        this.logger = redis_smq_common_1.logger.getLogger(index_js_2.Configuration.getSetConfig().logger, this.constructor.name.toLowerCase());
        this.logger.debug('Initializing Queue instance');
        this.eventBus = new index_js_1.EventBus();
        this.eventBus.on('error', (err) => {
            this.logger.error(`EventBus error: ${err.message}`, err);
        });
        this.logger.debug('EventBus initialized');
        this.redisClient = new redis_client_js_1.RedisClient();
        this.redisClient.on('error', (err) => {
            this.logger.error(`Redis client error: ${err.message}`, err);
        });
        this.logger.debug('Redis client initialized');
        this.logger.info('Queue instance initialized successfully');
    }
    save(queue, queueType, deliveryModel, cb) {
        const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
        this.logger.debug(`Saving queue: ${queueDesc}, type: ${index_js_4.EQueueType[queueType]}, delivery model: ${index_js_4.EQueueDeliveryModel[deliveryModel]}`);
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error) {
            this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
            return cb(queueParams);
        }
        const queueName = `${queueParams.name}@${queueParams.ns}`;
        this.logger.debug(`Parsed queue parameters: ${queueName}`);
        (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => {
            redis_smq_common_1.async.withCallback((cb) => {
                const { keyQueueProperties } = redis_keys_js_1.redisKeys.getQueueKeys(queueParams, null);
                const { keyNamespaces, keyQueues } = redis_keys_js_1.redisKeys.getMainKeys();
                const { keyNamespaceQueues } = redis_keys_js_1.redisKeys.getNamespaceKeys(queueParams.ns);
                const queueParamsStr = JSON.stringify(queueParams);
                this.logger.debug(`Executing CREATE_QUEUE script for ${queueName} with keys: [${keyNamespaces}, ${keyNamespaceQueues}, ${keyQueues}, ${keyQueueProperties}]`);
                client.runScript(scripts_js_1.ELuaScriptName.CREATE_QUEUE, [
                    keyNamespaces,
                    keyNamespaceQueues,
                    keyQueues,
                    keyQueueProperties,
                ], [
                    queueParams.ns,
                    queueParamsStr,
                    index_js_4.EQueueProperty.QUEUE_TYPE,
                    queueType,
                    index_js_4.EQueueProperty.DELIVERY_MODEL,
                    deliveryModel,
                ], cb);
            }, (reply, cb) => {
                if (reply !== 'OK') {
                    const error = new index_js_3.QueueQueueExistsError();
                    this.logger.error(`Queue ${queueName} already exists`, error);
                    return cb(error);
                }
                this.logger.debug(`Queue ${queueName} created successfully, retrieving properties`);
                redis_smq_common_1.async.withCallback((cb) => this.getProperties(queueParams, cb), (properties, cb) => {
                    this.logger.debug(`Retrieved properties for queue ${queueName}, emitting queue.queueCreated event`);
                    (0, redis_smq_common_1.withEventBus)(this.eventBus, (eventBus, cb) => {
                        this.logger.debug(`Emitting queue.queueCreated event for ${queueName}`);
                        eventBus.emit('queue.queueCreated', queueParams, properties);
                        this.logger.info(`Queue ${queueName} successfully created with type=${index_js_4.EQueueType[queueType]}, deliveryModel=${index_js_4.EQueueDeliveryModel[deliveryModel]}`);
                        cb(null, { queue: queueParams, properties });
                    }, cb);
                }, cb);
            }, cb);
        }, cb);
    }
    exists(queue, cb) {
        const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
        this.logger.debug(`Checking if queue exists: ${queueDesc}`);
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error) {
            this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
            cb(queueParams);
        }
        else {
            const queueName = `${queueParams.name}@${queueParams.ns}`;
            this.logger.debug(`Parsed queue parameters: ${queueName}`);
            (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => {
                this.logger.debug(`Checking if queue ${queueName} exists in Redis`);
                (0, _queue_exists_js_1._queueExists)(client, queueParams, (err, exists) => {
                    if (err) {
                        this.logger.error(`Error checking if queue ${queueName} exists: ${err.message}`, err);
                        cb(err);
                    }
                    else {
                        this.logger.debug(`Queue ${queueName} exists: ${exists}`);
                        cb(null, exists);
                    }
                });
            }, cb);
        }
    }
    delete(queue, cb) {
        const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
        this.logger.debug(`Deleting queue: ${queueDesc}`);
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error) {
            this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
            return cb(queueParams);
        }
        const queueName = `${queueParams.name}@${queueParams.ns}`;
        this.logger.debug(`Parsed queue parameters: ${queueName}`);
        (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => {
            this.logger.debug(`Executing delete queue operation for ${queueName}`);
            (0, _delete_queue_js_1._deleteQueue)(client, queueParams, undefined, (err, multi) => {
                if (err) {
                    this.logger.error(`Error preparing delete operation for queue ${queueName}: ${err.message}`, err);
                    return cb(err);
                }
                if (!multi) {
                    const error = new redis_smq_common_1.CallbackEmptyReplyError();
                    this.logger.error(`Multi command is empty for deleting queue ${queueName}`, error);
                    return cb(error);
                }
                this.logger.debug(`Executing multi command to delete queue ${queueName}`);
                multi.exec((err) => {
                    if (err) {
                        this.logger.error(`Error executing multi command for deleting queue ${queueName}: ${err.message}`, err);
                        return cb(err);
                    }
                    this.logger.debug(`Queue ${queueName} deleted from Redis, emitting queue.queueDeleted event`);
                    (0, redis_smq_common_1.withEventBus)(this.eventBus, (eventBus, cb) => {
                        this.logger.debug(`Emitting queue.queueDeleted event for ${queueName}`);
                        eventBus.emit('queue.queueDeleted', queueParams);
                        this.logger.info(`Queue ${queueName} successfully deleted`);
                        cb();
                    }, cb);
                });
            });
        }, cb);
    }
    getProperties(queue, cb) {
        const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
        this.logger.debug(`Getting properties for queue: ${queueDesc}`);
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error) {
            this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
            cb(queueParams);
        }
        else {
            const queueName = `${queueParams.name}@${queueParams.ns}`;
            this.logger.debug(`Parsed queue parameters: ${queueName}`);
            (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => {
                this.logger.debug(`Retrieving properties for queue ${queueName}`);
                (0, _get_queue_properties_js_1._getQueueProperties)(client, queueParams, (err, properties) => {
                    if (err) {
                        this.logger.error(`Error getting properties for queue ${queueName}: ${err.message}`, err);
                        cb(err);
                    }
                    else {
                        if (properties) {
                            this.logger.debug(`Retrieved properties for queue ${queueName}: type=${index_js_4.EQueueType[properties.queueType]}, deliveryModel=${index_js_4.EQueueDeliveryModel[properties.deliveryModel]}`);
                        }
                        else {
                            this.logger.debug(`No properties found for queue ${queueName}`);
                        }
                        cb(null, properties);
                    }
                });
            }, cb);
        }
    }
    getQueues(cb) {
        this.logger.debug('Getting all queues');
        (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => {
            this.logger.debug('Retrieving all queues from Redis');
            (0, _get_queues_js_1._getQueues)(client, (err, queues) => {
                if (err) {
                    this.logger.error(`Error getting queues: ${err.message}`, err);
                    cb(err);
                }
                else {
                    const queueCount = (queues === null || queues === void 0 ? void 0 : queues.length) || 0;
                    this.logger.debug(`Retrieved ${queueCount} queues`);
                    cb(null, queues);
                }
            });
        }, cb);
    }
    getConsumers(queue, cb) {
        const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
        this.logger.debug(`Getting consumers for queue: ${queueDesc}`);
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error) {
            this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
            return cb(queueParams);
        }
        const queueName = `${queueParams.name}@${queueParams.ns}`;
        this.logger.debug(`Parsed queue parameters: ${queueName}`);
        (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => (0, _get_queue_consumers_js_1._getQueueConsumers)(client, queueParams, cb), cb);
    }
    getConsumerIds(queue, cb) {
        const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
        this.logger.debug(`Getting consumer Ids for queue: ${queueDesc}`);
        const queueParams = (0, _parse_queue_params_js_1._parseQueueParams)(queue);
        if (queueParams instanceof Error) {
            this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
            return cb(queueParams);
        }
        const queueName = `${queueParams.name}@${queueParams.ns}`;
        this.logger.debug(`Parsed queue parameters: ${queueName}`);
        (0, redis_smq_common_1.withRedisClient)(this.redisClient, (client, cb) => (0, _get_queue_consumer_ids_js_1._getQueueConsumerIds)(client, queueParams, cb), cb);
    }
}
exports.Queue = Queue;
//# sourceMappingURL=queue.js.map