@nestjs/microservices/server/server-rmq.js

Nest - modern, fast, powerful node.js web framework (@microservices)

/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
import { createRequire } from 'module';
import { BLOCKED_RMQ_MESSAGE, CONNECTION_FAILED_MESSAGE, DISCONNECTED_RMQ_MESSAGE, NO_MESSAGE_HANDLER, RMQ_SEPARATOR, RMQ_WILDCARD_ALL, RMQ_WILDCARD_SINGLE, RMQ_DEFAULT_IS_GLOBAL_PREFETCH_COUNT, RMQ_DEFAULT_NOACK, RMQ_DEFAULT_NO_ASSERT, RMQ_DEFAULT_PREFETCH_COUNT, RMQ_DEFAULT_QUEUE, RMQ_DEFAULT_QUEUE_OPTIONS, RMQ_DEFAULT_URL, RMQ_NO_EVENT_HANDLER, RMQ_NO_MESSAGE_HANDLER, UNBLOCKED_RMQ_MESSAGE, } from '../constants.js';
import { RmqContext } from '../ctx-host/index.js';
import { Transport } from '../enums/index.js';
import { RmqRecordSerializer } from '../serializers/rmq-record.serializer.js';
import { Server } from './server.js';
import { isNil, isString, isUndefined } from '@nestjs/common/internal';
const INFINITE_CONNECTION_ATTEMPTS = -1;
/**
 * @publicApi
 */
export class ServerRMQ extends Server {
    options;
    transportId = Transport.RMQ;
    server = null;
    channel = null;
    connectionAttempts = 0;
    urls;
    queue;
    noAck;
    queueOptions;
    wildcardHandlers = new Map();
    pendingEventListeners = [];
    constructor(options) {
        super();
        this.options = options;
        this.urls = this.getOptionsProp(this.options, 'urls') || [RMQ_DEFAULT_URL];
        this.queue =
            this.getOptionsProp(this.options, 'queue') || RMQ_DEFAULT_QUEUE;
        this.noAck = this.getOptionsProp(this.options, 'noAck', RMQ_DEFAULT_NOACK);
        this.queueOptions =
            this.getOptionsProp(this.options, 'queueOptions') ||
                RMQ_DEFAULT_QUEUE_OPTIONS;
        this.loadPackageSynchronously('amqplib', ServerRMQ.name, () => createRequire(import.meta.url)('amqplib'));
        this.initializeSerializer(options);
        this.initializeDeserializer(options);
    }
    async listen(callback) {
        try {
            await this.start(callback);
        }
        catch (err) {
            callback(err);
        }
    }
    async close() {
        this.channel && (await this.channel.close());
        this.server && (await this.server.close());
        this.pendingEventListeners = [];
    }
    async start(callback) {
        this.server = await this.createClient();
        this.server.once("connect" /* RmqEventsMap.CONNECT */, () => {
            if (this.channel) {
                return;
            }
            this._status$.next("connected" /* RmqStatus.CONNECTED */);
            this.channel = this.server.createChannel({
                json: false,
                setup: (channel) => this.setupChannel(channel, callback),
            });
        });
        const maxConnectionAttempts = this.getOptionsProp(this.options, 'maxConnectionAttempts', INFINITE_CONNECTION_ATTEMPTS);
        this.registerConnectListener();
        this.registerDisconnectListener();
        this.registerBlockedListener();
        this.registerUnblockedListener();
        this.pendingEventListeners.forEach(({ event, callback }) => this.server.on(event, callback));
        this.pendingEventListeners = [];
        const connectFailedEvent = 'connectFailed';
        this.server.once(connectFailedEvent, async (error) => {
            this._status$.next("disconnected" /* RmqStatus.DISCONNECTED */);
            this.logger.error(CONNECTION_FAILED_MESSAGE);
            if (error?.err) {
                this.logger.error(error.err);
            }
            const isReconnecting = !!this.channel;
            if (maxConnectionAttempts === INFINITE_CONNECTION_ATTEMPTS ||
                isReconnecting) {
                return;
            }
            if (++this.connectionAttempts === maxConnectionAttempts) {
                await this.close();
                callback?.(error.err ?? new Error(CONNECTION_FAILED_MESSAGE));
            }
        });
    }
    async createClient() {
        const rmqPackage = await this.loadPackage('amqp-connection-manager', ServerRMQ.name, () => import('amqp-connection-manager'));
        const socketOptions = this.getOptionsProp(this.options, 'socketOptions');
        return rmqPackage.connect(this.urls, {
            connectionOptions: socketOptions?.connectionOptions,
            heartbeatIntervalInSeconds: socketOptions?.heartbeatIntervalInSeconds,
            reconnectTimeInSeconds: socketOptions?.reconnectTimeInSeconds,
        });
    }
    registerConnectListener() {
        this.server.on("connect" /* RmqEventsMap.CONNECT */, (err) => {
            this._status$.next("connected" /* RmqStatus.CONNECTED */);
        });
    }
    registerDisconnectListener() {
        this.server.on("disconnect" /* RmqEventsMap.DISCONNECT */, (err) => {
            this._status$.next("disconnected" /* RmqStatus.DISCONNECTED */);
            this.logger.error(DISCONNECTED_RMQ_MESSAGE);
            this.logger.error(err);
        });
    }
    registerBlockedListener() {
        this.server.on("blocked" /* RmqEventsMap.BLOCKED */, ({ reason }) => {
            this._status$.next("blocked" /* RmqStatus.BLOCKED */);
            this.logger.warn(BLOCKED_RMQ_MESSAGE(reason));
        });
    }
    registerUnblockedListener() {
        this.server.on("unblocked" /* RmqEventsMap.UNBLOCKED */, () => {
            this._status$.next("unblocked" /* RmqStatus.UNBLOCKED */);
            this.logger.log(UNBLOCKED_RMQ_MESSAGE);
        });
    }
    async setupChannel(channel, callback) {
        const noAssert = this.getOptionsProp(this.options, 'noAssert') ??
            this.queueOptions.noAssert ??
            RMQ_DEFAULT_NO_ASSERT;
        let createdQueue;
        if (this.queue === RMQ_DEFAULT_QUEUE || !noAssert) {
            const { queue } = await channel.assertQueue(this.queue, this.queueOptions);
            createdQueue = queue;
        }
        else {
            createdQueue = this.queue;
        }
        const isGlobalPrefetchCount = this.getOptionsProp(this.options, 'isGlobalPrefetchCount', RMQ_DEFAULT_IS_GLOBAL_PREFETCH_COUNT);
        const prefetchCount = this.getOptionsProp(this.options, 'prefetchCount', RMQ_DEFAULT_PREFETCH_COUNT);
        if (this.options.exchange || this.options.wildcards) {
            // Use queue name as exchange name if exchange is not provided and "wildcards" is set to true
            const exchange = this.getOptionsProp(this.options, 'exchange', this.options.queue);
            const exchangeType = this.getOptionsProp(this.options, 'exchangeType', 'topic');
            await channel.assertExchange(exchange, exchangeType, {
                durable: true,
                arguments: this.getOptionsProp(this.options, 'exchangeArguments', {}),
            });
            if (this.options.routingKey || this.options.exchangeType === 'fanout') {
                await channel.bindQueue(createdQueue, exchange, this.options.exchangeType === 'fanout' ? '' : this.options.routingKey);
            }
            if (this.options.wildcards) {
                const routingKeys = Array.from(this.getHandlers().keys());
                await Promise.all(routingKeys.map(routingKey => channel.bindQueue(createdQueue, exchange, routingKey)));
                // When "wildcards" is set to true,  we need to initialize wildcard handlers
                // otherwise we would not be able to associate the incoming messages with the handlers
                this.initializeWildcardHandlersIfExist();
            }
        }
        await channel.prefetch(prefetchCount, isGlobalPrefetchCount);
        channel.consume(createdQueue, (msg) => this.handleMessage(msg, channel), {
            noAck: this.noAck,
            consumerTag: this.getOptionsProp(this.options, 'consumerTag', undefined),
        });
        callback();
    }
    async handleMessage(message, channel) {
        if (isNil(message)) {
            return;
        }
        const { content, properties } = message;
        const rawMessage = this.parseMessageContent(content);
        const packet = await this.deserializer.deserialize(rawMessage, properties);
        const pattern = isString(packet.pattern)
            ? packet.pattern
            : JSON.stringify(packet.pattern);
        const rmqContext = new RmqContext([message, channel, pattern]);
        if (isUndefined(packet.id)) {
            return this.handleEvent(pattern, packet, rmqContext);
        }
        const handler = this.getHandlerByPattern(pattern);
        if (!handler) {
            if (!this.noAck) {
                this.logger.warn(RMQ_NO_MESSAGE_HANDLER `${pattern}`);
                this.channel.nack(rmqContext.getMessage(), false, false);
            }
            const status = 'error';
            const noHandlerPacket = {
                id: packet.id,
                err: NO_MESSAGE_HANDLER,
                status,
            };
            return this.sendMessage(noHandlerPacket, properties.replyTo, properties.correlationId, rmqContext);
        }
        return this.onProcessingStartHook(this.transportId, rmqContext, async () => {
            const response$ = this.transformToObservable(await handler(packet.data, rmqContext));
            const publish = (data) => this.sendMessage(data, properties.replyTo, properties.correlationId, rmqContext);
            response$ && this.send(response$, publish);
        });
    }
    async handleEvent(pattern, packet, context) {
        const handler = this.getHandlerByPattern(pattern);
        if (!handler && !this.noAck) {
            this.channel.nack(context.getMessage(), false, false);
            return this.logger.warn(RMQ_NO_EVENT_HANDLER `${pattern}`);
        }
        return super.handleEvent(pattern, packet, context);
    }
    sendMessage(message, replyTo, correlationId, context) {
        const outgoingResponse = this.serializer.serialize(message);
        const options = outgoingResponse.options;
        delete outgoingResponse.options;
        const buffer = Buffer.from(JSON.stringify(outgoingResponse));
        const sendOptions = { correlationId, ...options };
        this.onProcessingEndHook?.(this.transportId, context);
        this.channel.sendToQueue(replyTo, buffer, sendOptions);
    }
    unwrap() {
        if (!this.server) {
            throw new Error('Not initialized. Please call the "listen"/"startAllMicroservices" method before accessing the server.');
        }
        return this.server;
    }
    on(event, callback) {
        if (this.server) {
            this.server.addListener(event, callback);
        }
        else {
            this.pendingEventListeners.push({ event, callback });
        }
    }
    getHandlerByPattern(pattern) {
        if (!this.options.wildcards) {
            return super.getHandlerByPattern(pattern);
        }
        // Search for non-wildcard handler first
        const handler = super.getHandlerByPattern(pattern);
        if (handler) {
            return handler;
        }
        // Search for wildcard handler
        if (this.wildcardHandlers.size === 0) {
            return null;
        }
        for (const [wildcardPattern, handler] of this.wildcardHandlers) {
            if (this.matchRmqPattern(wildcardPattern, pattern)) {
                return handler;
            }
        }
        return null;
    }
    initializeSerializer(options) {
        this.serializer = options?.serializer ?? new RmqRecordSerializer();
    }
    parseMessageContent(content) {
        try {
            return JSON.parse(content.toString());
        }
        catch {
            return content.toString();
        }
    }
    initializeWildcardHandlersIfExist() {
        if (this.wildcardHandlers.size !== 0) {
            return;
        }
        const handlers = this.getHandlers();
        handlers.forEach((handler, pattern) => {
            if (typeof pattern !== 'string') {
                return;
            }
            if (pattern.includes(RMQ_WILDCARD_ALL) ||
                pattern.includes(RMQ_WILDCARD_SINGLE)) {
                this.wildcardHandlers.set(pattern, handler);
            }
        });
    }
    matchRmqPattern(pattern, routingKey) {
        if (!routingKey) {
            return pattern === RMQ_WILDCARD_ALL;
        }
        const patternSegments = pattern.split(RMQ_SEPARATOR);
        const routingKeySegments = routingKey.split(RMQ_SEPARATOR);
        const patternSegmentsLength = patternSegments.length;
        const routingKeySegmentsLength = routingKeySegments.length;
        const lastIndex = patternSegmentsLength - 1;
        for (const [i, currentPattern] of patternSegments.entries()) {
            const currentRoutingKey = routingKeySegments[i];
            if (!currentRoutingKey && !currentPattern) {
                continue;
            }
            if (!currentRoutingKey && currentPattern !== RMQ_WILDCARD_ALL) {
                return false;
            }
            if (currentPattern === RMQ_WILDCARD_ALL) {
                return i === lastIndex;
            }
            if (currentPattern !== RMQ_WILDCARD_SINGLE &&
                currentPattern !== currentRoutingKey) {
                return false;
            }
        }
        return patternSegmentsLength === routingKeySegmentsLength;
    }
}