@goparrot/pubsub-event-bus/esm/service/retry-strategy/DelayedMessageExchangeRetryStrategy.js

NestJS EventBus extension for RabbitMQ PubSub

import { __decorate, __metadata, __param } from "tslib";
import { Inject, Injectable } from '@nestjs/common';
import { RetryStrategyEnum } from '../../interface';
import { LoggerProvider } from '../../provider';
import { CQRS_EXCHANGE_CONFIG, CQRS_RETRY_OPTIONS } from '../../utils/configuration';
import { DEFAULT_RETRY_DELAYED_MESSAGE_EXCHANGE_NAME, ORIGIN_EXCHANGE_HEADER, RETRY_COUNT_HEADER } from '../../utils/retry-constants';
import { calculateDelay, getMessageExchange } from '../../utils';
let DelayedMessageExchangeRetryStrategy = class DelayedMessageExchangeRetryStrategy {
    constructor(rootRetryOptions, assertExchangeOptions) {
        this.rootRetryOptions = rootRetryOptions;
        this.assertExchangeOptions = assertExchangeOptions;
        this.strategy = RetryStrategyEnum.DELAYED_MESSAGE_EXCHANGE;
    }
    get logger() {
        return LoggerProvider.logger;
    }
    async setupInfrastructure(channelWrapper, wrappersWithRetryStrategy) {
        const delayedExchangeOptions = {
            ...this.assertExchangeOptions,
            arguments: { ...this.assertExchangeOptions.arguments, 'x-delayed-type': 'direct' },
        };
        await channelWrapper.addSetup(async (channel) => {
            await Promise.all([
                channel.assertExchange(DEFAULT_RETRY_DELAYED_MESSAGE_EXCHANGE_NAME, 'x-delayed-message', delayedExchangeOptions),
                ...wrappersWithRetryStrategy.map(async (handlerWrapper) => {
                    const { queue } = handlerWrapper;
                    return channel.bindQueue(queue, DEFAULT_RETRY_DELAYED_MESSAGE_EXCHANGE_NAME, queue);
                }),
            ]);
            this.logger.log(`Delayed message auto retry exchange "${DEFAULT_RETRY_DELAYED_MESSAGE_EXCHANGE_NAME}" asserted`);
        });
    }
    async requeue(channelWrapper, handlerWrapper, event) {
        const { handler, queue, options: { retryOptions }, } = handlerWrapper;
        const message = event.message();
        if (!message) {
            return;
        }
        const { delay = this.rootRetryOptions.delay } = retryOptions ?? {};
        const retryCount = event.retryCount + 1;
        const delayValue = calculateDelay(delay, retryCount);
        await channelWrapper.publish(DEFAULT_RETRY_DELAYED_MESSAGE_EXCHANGE_NAME, queue, event.payload, {
            ...message.properties,
            type: message.properties.type,
            headers: {
                ...message.properties.headers,
                'x-delay': delayValue,
                [RETRY_COUNT_HEADER]: retryCount,
                [ORIGIN_EXCHANGE_HEADER]: getMessageExchange(message),
            },
        });
        this.logger.log(`Event ${event.constructor.name} was republished to "${queue}" queue with ${delayValue} ms delay`, handler.name);
    }
};
DelayedMessageExchangeRetryStrategy = __decorate([
    Injectable(),
    __param(0, Inject(CQRS_RETRY_OPTIONS)),
    __param(1, Inject(CQRS_EXCHANGE_CONFIG)),
    __metadata("design:paramtypes", [Object, Object])
], DelayedMessageExchangeRetryStrategy);
export { DelayedMessageExchangeRetryStrategy };
//# sourceMappingURL=DelayedMessageExchangeRetryStrategy.js.map