redis-smq/dist/esm/src/consumer/message-handler/queue-workers/workers/requeue-immediate.worker.js

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

import { async } from 'redis-smq-common';
import { ERedisScriptName } from '../../../../common/redis/scripts.js';
import { redisKeys } from '../../../../common/redis/redis-keys/redis-keys.js';
import { _getMessages } from '../../../../message-manager/_/_get-message.js';
import { EMessageProperty, EMessagePropertyStatus, } from '../../../../message/index.js';
import { EQueueOperationalState, EQueueProperty, EQueueType, } from '../../../../queue-manager/index.js';
import { withSharedPoolConnection } from '../../../../common/redis/redis-connection-pool/with-shared-pool-connection.js';
import { UnexpectedScriptReplyError } from '../../../../errors/index.js';
import { QueueWorkerAbstract } from '../queue-worker-abstract.js';
export class RequeueImmediateWorker extends QueueWorkerAbstract {
    fetchMessageIds = (cb) => {
        withSharedPoolConnection((redisClient, cb) => {
            const { keyQueueRequeued } = redisKeys.getQueueKeys(this.queueParsedParams.queueParams.ns, this.queueParsedParams.queueParams.name, this.queueParsedParams.groupId);
            redisClient.lrange(keyQueueRequeued, 0, 99, (err, reply) => {
                if (err) {
                    this.logger.error('Error fetching message IDs.', err);
                    return cb(err);
                }
                cb(null, reply ?? []);
            });
        }, cb);
    };
    fetchMessages = (ids, cb) => {
        if (!ids.length)
            return cb(null, []);
        this.logger.debug(`Fetching ${ids.length} messages from storage.`);
        withSharedPoolConnection((redisClient, cb) => {
            _getMessages(redisClient, ids, cb);
        }, cb);
    };
    requeueMessages = (messages, cb) => {
        if (!messages.length)
            return cb();
        this.logger.debug(`Preparing to enqueue ${messages.length} messages.`);
        const { keyQueueProperties, keyQueueDelayed, keyQueueRequeued, keyQueueDeadLetter, keyQueueConsumerGroups, } = redisKeys.getQueueKeys(this.queueParsedParams.queueParams.ns, this.queueParsedParams.queueParams.name, this.queueParsedParams.groupId);
        const keys = [
            keyQueueProperties,
            keyQueueRequeued,
            keyQueueDelayed,
            keyQueueDeadLetter,
            keyQueueConsumerGroups,
        ];
        const timestamp = Date.now();
        const argv = [
            EQueueProperty.QUEUE_TYPE,
            EQueueProperty.REQUEUED_MESSAGES_COUNT,
            EQueueProperty.DELAYED_MESSAGES_COUNT,
            EQueueProperty.PENDING_MESSAGES_COUNT,
            EQueueProperty.DEAD_LETTERED_MESSAGES_COUNT,
            EMessageProperty.STATUS,
            EMessagePropertyStatus.PENDING,
            EMessagePropertyStatus.DEAD_LETTERED,
            EMessageProperty.DEAD_LETTERED_AT,
            EMessagePropertyStatus.UNACK_DELAYING,
            EMessageProperty.LAST_RETRIED_ATTEMPT_AT,
            EQueueType.LIFO_QUEUE,
            EQueueType.FIFO_QUEUE,
            EQueueProperty.OPERATIONAL_STATE,
            EQueueOperationalState.ACTIVE,
            EQueueOperationalState.PAUSED,
            EQueueOperationalState.STOPPED,
            EQueueOperationalState.LOCKED,
            timestamp,
        ];
        for (const msg of messages) {
            const messageId = msg.getId();
            const consumerGroupId = msg.getConsumerGroupId();
            const priority = msg.producibleMessage.getPriority();
            const retryDelay = msg.producibleMessage.getRetryDelay();
            const delayedTimestamp = retryDelay ? timestamp + retryDelay : 0;
            const destinationQueue = msg.getDestinationQueue();
            const { keyQueuePending, keyQueuePriority } = redisKeys.getQueueKeys(destinationQueue.ns, destinationQueue.name, consumerGroupId);
            const { keyMessage } = redisKeys.getMessageKeys(messageId);
            keys.push(keyMessage, keyQueuePending, keyQueuePriority);
            argv.push(messageId, priority ?? '', retryDelay, delayedTimestamp, consumerGroupId ?? '');
        }
        withSharedPoolConnection((redisClient, cb) => {
            this.logger.debug(`Executing REQUEUE_IMMEDIATE script with ${messages.length} messages`);
            redisClient.runScript(ERedisScriptName.REQUEUE_IMMEDIATE, keys, argv, (err, reply) => {
                if (err) {
                    this.logger.error('Error during message processing for requeue', err);
                    return cb(err);
                }
                if (typeof reply === 'number') {
                    if (reply !== messages.length) {
                        this.logger.warn(`Script reported processing ${reply} messages, but expected ${messages.length}. This may be due to a message being moved or deleted before the worker could process it.`);
                    }
                    this.logger.debug(`Successfully re-queued ${reply} messages for immediate processing.`);
                    return cb();
                }
                if (typeof reply === 'string') {
                    this.logger.warn(`Script returned queue state: ${reply}`);
                    return cb();
                }
                cb(new UnexpectedScriptReplyError({ metadata: { reply } }));
            });
        }, cb);
    };
    work = (cb) => {
        async.waterfall([this.fetchMessageIds, this.fetchMessages, this.requeueMessages], (err) => {
            if (err) {
                this.logger.error('A fatal error occurred during requeue unacknowledged messages worker cycle.', err);
            }
            cb(err);
        });
    };
}
export default RequeueImmediateWorker;
//# sourceMappingURL=requeue-immediate.worker.js.map