redis-smq/dist/esm/src/queue-manager/queue-manager.js

A high-performance, reliable, and scalable message queue for Node.js.

import { async, createLogger } from 'redis-smq-common';
import { ERedisScriptName } from '../common/redis/scripts.js';
import { redisKeys } from '../common/redis/redis-keys/redis-keys.js';
import { Configuration } from '../config-manager/configuration.js';
import { _deleteQueue } from './_/_delete-queue.js';
import { _getQueueConsumerIds } from './_/_get-queue-consumer-ids.js';
import { _getQueueConsumers } from './_/_get-queue-consumers.js';
import { _getQueueProperties } from './_/_get-queue-properties.js';
import { _getQueues } from './_/_get-queues.js';
import { _parseQueueParams } from './_/_parse-queue-params.js';
import { _queueExists } from './_/_queue-exists.js';
import { QueueAlreadyExistsError, UnexpectedScriptReplyError, } from '../errors/index.js';
import { EQueueDeliveryModel, EQueueOperationalState, EQueueProperty, EQueueType, } from './types/index.js';
import { withSharedPoolConnection } from '../common/redis/redis-connection-pool/with-shared-pool-connection.js';
import { EventMultiplexer } from '../event-bus/event-multiplexer.js';
import { maxQueueStateHistorySize } from '../queue-state-manager/_/_set-queue-state.js';
import { ESystemStateTransitionReason, } from '../queue-state-manager/index.js';
export class QueueManager {
    logger;
    constructor() {
        const config = Configuration.getConfig();
        this.logger = createLogger(config.logger, this.constructor.name);
    }
    save(queue, queueType, deliveryModel, cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
            this.logger.debug(`Saving queue: ${queueDesc}, type: ${queueType}, delivery model: ${deliveryModel}`);
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
                return callback(queueParams);
            }
            const queueName = `${queueParams.name}@${queueParams.ns}`;
            this.logger.debug(`Parsed queue parameters: ${queueName}`);
            withSharedPoolConnection((client, done) => {
                const { keyQueueProperties, keyQueueStateHistory } = redisKeys.getQueueKeys(queueParams.ns, queueParams.name, null);
                const { keyNamespaces, keyQueues } = redisKeys.getMainKeys();
                const { keyNamespaceQueues } = redisKeys.getNamespaceKeys(queueParams.ns);
                const keys = [
                    keyNamespaces,
                    keyNamespaceQueues,
                    keyQueues,
                    keyQueueProperties,
                    keyQueueStateHistory,
                ];
                const now = Date.now();
                const initialState = {
                    timestamp: now,
                    from: null,
                    to: EQueueOperationalState.ACTIVE,
                    reason: ESystemStateTransitionReason.SYSTEM_INIT,
                    metadata: {
                        queueType,
                        deliveryModel,
                    },
                };
                const initialTransitionData = JSON.stringify(initialState);
                const args = [
                    queueParams.ns,
                    JSON.stringify(queueParams),
                    EQueueProperty.QUEUE_TYPE,
                    queueType,
                    EQueueProperty.DELIVERY_MODEL,
                    deliveryModel,
                    EQueueProperty.RATE_LIMIT,
                    '',
                    EQueueProperty.MESSAGES_COUNT,
                    EQueueProperty.ACKNOWLEDGED_MESSAGES_COUNT,
                    EQueueProperty.DEAD_LETTERED_MESSAGES_COUNT,
                    EQueueProperty.PENDING_MESSAGES_COUNT,
                    EQueueProperty.SCHEDULED_MESSAGES_COUNT,
                    EQueueProperty.PROCESSING_MESSAGES_COUNT,
                    EQueueProperty.DELAYED_MESSAGES_COUNT,
                    EQueueProperty.REQUEUED_MESSAGES_COUNT,
                    EQueueProperty.OPERATIONAL_STATE,
                    EQueueOperationalState.ACTIVE,
                    maxQueueStateHistorySize,
                    EQueueProperty.LAST_STATE_CHANGE_AT,
                    now,
                    EQueueProperty.LOCK_ID,
                    initialTransitionData,
                ];
                this.logger.debug(`Executing CREATE_QUEUE script for ${queueName} with keys: [${keys.join(', ')}]`);
                client.runScript(ERedisScriptName.CREATE_QUEUE, keys, args, (err, reply) => {
                    if (err)
                        return done(err);
                    if (!['OK', 'QUEUE_EXISTS'].includes(String(reply))) {
                        this.logger.error('CREATE_QUEUE script returned an unexpected reply: ', reply);
                        return done(new UnexpectedScriptReplyError({ metadata: { reply } }));
                    }
                    if (reply === 'QUEUE_EXISTS') {
                        const error = new QueueAlreadyExistsError();
                        this.logger.error(`Queue ${queueName} already exists`, error);
                        return done(error);
                    }
                    this.logger.debug(`Queue ${queueName} created successfully.`);
                    const properties = {
                        queueType,
                        deliveryModel,
                        rateLimit: null,
                        messagesCount: 0,
                        acknowledgedMessagesCount: 0,
                        deadLetteredMessagesCount: 0,
                        pendingMessagesCount: 0,
                        scheduledMessagesCount: 0,
                        processingMessagesCount: 0,
                        delayedMessagesCount: 0,
                        requeuedMessagesCount: 0,
                        operationalState: EQueueOperationalState.ACTIVE,
                        lockId: null,
                        lastStateChangeAt: now,
                    };
                    this.logger.debug(`Emitting queue.queueCreated event for ${queueName}`);
                    EventMultiplexer.publish('queue.queueCreated', queueParams, properties);
                    this.logger.info(`Queue ${queueName} successfully created with type=${queueType}, deliveryModel=${deliveryModel}, state=${EQueueOperationalState.ACTIVE}`);
                    done(null, { queue: queueParams, properties });
                });
            }, callback);
        });
    }
    exists(queue, cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
            this.logger.debug(`Checking if queue exists: ${queueDesc}`);
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
                callback(queueParams);
            }
            else {
                const queueName = `${queueParams.name}@${queueParams.ns}`;
                this.logger.debug(`Parsed queue parameters: ${queueName}`);
                withSharedPoolConnection((client, cb) => {
                    this.logger.debug(`Checking if queue ${queueName} exists in Redis`);
                    _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);
                        }
                    });
                }, callback);
            }
        });
    }
    delete(queue, cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
            this.logger.debug(`Deleting queue: ${queueDesc}`);
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
                return callback(queueParams);
            }
            const queueName = `${queueParams.name}@${queueParams.ns}`;
            this.logger.debug(`Parsed queue parameters: ${queueName}`);
            withSharedPoolConnection((client, cb) => {
                this.logger.debug(`Executing delete queue operation for ${queueName}`);
                _deleteQueue(client, queueParams, (err) => {
                    if (err) {
                        this.logger.error(`Error deleting queue ${queueName}: ${err.message}`, err);
                        return cb(err);
                    }
                    this.logger.debug(`Queue ${queueName} deleted from Redis, emitting queue.queueDeleted event`);
                    EventMultiplexer.publish('queue.queueDeleted', queueParams);
                    this.logger.info(`Queue ${queueParams.name}@${queueParams.ns} successfully deleted`);
                    cb();
                });
            }, callback);
        });
    }
    getProperties(queue, cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
            this.logger.debug(`Getting properties for queue: ${queueDesc}`);
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
                callback(queueParams);
            }
            else {
                const queueName = `${queueParams.name}@${queueParams.ns}`;
                this.logger.debug(`Parsed queue parameters: ${queueName}`);
                withSharedPoolConnection((client, cb) => {
                    this.logger.debug(`Retrieving properties for queue ${queueName}`);
                    _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=${EQueueType[properties.queueType]}, deliveryModel=${EQueueDeliveryModel[properties.deliveryModel]}, state=${properties.operationalState}`);
                            }
                            else {
                                this.logger.debug(`No properties found for queue ${queueName}`);
                            }
                            cb(null, properties);
                        }
                    });
                }, callback);
            }
        });
    }
    getQueues(cb) {
        return async.withOptionalCallback(cb, (callback) => {
            this.logger.debug('Getting all queues');
            withSharedPoolConnection((client, cb) => {
                this.logger.debug('Retrieving all queues from Redis');
                _getQueues(client, (err, queues) => {
                    if (err) {
                        this.logger.error(`Error getting queues: ${err.message}`, err);
                        cb(err);
                    }
                    else {
                        const queueCount = queues?.length || 0;
                        this.logger.debug(`Retrieved ${queueCount} queues`);
                        cb(null, queues);
                    }
                });
            }, callback);
        });
    }
    getConsumers(queue, cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
            this.logger.debug(`Getting consumers for queue: ${queueDesc}`);
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
                return callback(queueParams);
            }
            const queueName = `${queueParams.name}@${queueParams.ns}`;
            this.logger.debug(`Parsed queue parameters: ${queueName}`);
            withSharedPoolConnection((client, cb) => _getQueueConsumers(client, queueParams, cb), callback);
        });
    }
    getConsumerIds(queue, cb) {
        return async.withOptionalCallback(cb, (callback) => {
            const queueDesc = typeof queue === 'string' ? queue : `${queue.name}@${queue.ns}`;
            this.logger.debug(`Getting consumer Ids for queue: ${queueDesc}`);
            const queueParams = _parseQueueParams(queue);
            if (queueParams instanceof Error) {
                this.logger.error(`Error parsing queue parameters for ${queueDesc}: ${queueParams.message}`, queueParams);
                return callback(queueParams);
            }
            const queueName = `${queueParams.name}@${queueParams.ns}`;
            this.logger.debug(`Parsed queue parameters: ${queueName}`);
            withSharedPoolConnection((client, cb) => _getQueueConsumerIds(client, queueParams, cb), callback);
        });
    }
}
//# sourceMappingURL=queue-manager.js.map