@xnestjs/rabbitmq/esm/rabbitmq-core.module.js

NestJS extension library for RabbitMQ

var RabbitmqCoreModule_1;
import { __decorate, __metadata, __param } from "tslib";
import assert from 'node:assert';
import * as crypto from 'node:crypto';
import { Inject, Logger, } from '@nestjs/common';
import { ClientRMQ, ClientsModule, Transport, } from '@nestjs/microservices';
import colors from 'ansi-colors';
import { RMQ_CONNECTION_OPTIONS, RMQ_MODULE_ID } from './constants.js';
import { getRabbitmqConfig } from './get-rabbitmq-config.js';
const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
let RabbitmqCoreModule = RabbitmqCoreModule_1 = class RabbitmqCoreModule {
    /**
     *
     */
    static forRoot(moduleOptions) {
        const connectionOptions = getRabbitmqConfig(moduleOptions.useValue || {}, moduleOptions.envPrefix);
        return this._createDynamicModule(moduleOptions, {
            global: moduleOptions.global,
            providers: [
                {
                    provide: RMQ_CONNECTION_OPTIONS,
                    useValue: connectionOptions,
                },
            ],
        });
    }
    /**
     *
     */
    static forRootAsync(asyncOptions) {
        assert.ok(asyncOptions.useFactory, 'useFactory is required');
        return this._createDynamicModule(asyncOptions, {
            global: asyncOptions.global,
            providers: [
                {
                    provide: RMQ_CONNECTION_OPTIONS,
                    inject: asyncOptions.inject,
                    useFactory: async (...args) => {
                        const opts = await asyncOptions.useFactory(...args);
                        return getRabbitmqConfig(opts, asyncOptions.envPrefix);
                    },
                },
            ],
        });
    }
    static _createDynamicModule(opts, metadata) {
        const token = opts.token ?? ClientRMQ;
        const name = typeof token === 'string' ? token : 'RabbitMQ';
        const logger = typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger;
        const exports = [RMQ_CONNECTION_OPTIONS, ...(metadata.exports ?? [])];
        const providers = [
            ...(metadata.providers ?? []),
            {
                provide: Logger,
                useValue: logger,
            },
            {
                provide: CLIENT_TOKEN,
                useExisting: token,
            },
            {
                provide: RMQ_MODULE_ID,
                useValue: crypto.randomUUID(),
            },
        ];
        if (name !== token) {
            exports.push(token);
            providers.push({
                provide: token,
                useExisting: name,
            });
        }
        return {
            module: RabbitmqCoreModule_1,
            providers,
            imports: [
                /** Import ClientsModule */
                ClientsModule.registerAsync({
                    clients: [
                        {
                            name,
                            extraProviders: metadata.providers,
                            inject: [RMQ_CONNECTION_OPTIONS],
                            useFactory: (connectionOptions) => {
                                return {
                                    transport: Transport.RMQ,
                                    options: connectionOptions,
                                };
                            },
                        },
                    ],
                }),
            ],
            exports,
        };
    }
    /**
     *
     * @constructor
     */
    constructor(client, connectionOptions, logger) {
        this.client = client;
        this.connectionOptions = connectionOptions;
        this.logger = logger;
    }
    async onApplicationBootstrap() {
        const options = this.connectionOptions;
        this.client.on('error', e => {
            console.log(e);
        });
        if (options.lazyConnect || !options.urls?.length)
            return;
        this.logger?.log('Connecting to RabbitMQ at ' + colors.blue(options.urls.join(',')));
        Logger.flush();
        await this.client.connect().catch(e => {
            this.logger?.error('RabbitMQ connection failed: ' + e.message);
            throw e;
        });
    }
    onApplicationShutdown() {
        return this.client.close();
    }
};
RabbitmqCoreModule = RabbitmqCoreModule_1 = __decorate([
    __param(0, Inject(CLIENT_TOKEN)),
    __param(1, Inject(RMQ_CONNECTION_OPTIONS)),
    __metadata("design:paramtypes", [ClientRMQ, Object, Logger])
], RabbitmqCoreModule);
export { RabbitmqCoreModule };