@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 colors from 'ansi-colors';
import { RMQ_CONNECTION_OPTIONS, RMQ_MODULE_ID } from './constants.js';
import { getRabbitmqConfig } from './get-rabbitmq-config.js';
import { RmqClient, } from './types.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 ?? RmqClient;
        // const name = typeof token === 'string' ? token : 'RabbitMQ';
        const logger = typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger;
        const providers = [
            ...(metadata.providers ?? []),
            {
                provide: Logger,
                useValue: logger,
            },
            {
                provide: CLIENT_TOKEN,
                useExisting: token,
            },
            {
                provide: RMQ_MODULE_ID,
                useValue: crypto.randomUUID(),
            },
            {
                provide: token,
                inject: [RMQ_CONNECTION_OPTIONS],
                useFactory: async (connectionOptions) => {
                    const client = new RmqClient(connectionOptions);
                    if (logger) {
                        client.on('connection', () => {
                            logger.log('RabbitMQ client connected');
                        });
                        client.on('error', err => {
                            logger.error('RabbitMQ connection error: ' + err?.message);
                        });
                    }
                    return client;
                },
            },
        ];
        return {
            global: opts.global,
            module: RabbitmqCoreModule_1,
            imports: opts.imports,
            providers,
            exports: [RMQ_CONNECTION_OPTIONS, token, ...(metadata.exports ?? [])],
        };
    }
    /**
     *
     * @constructor
     */
    constructor(client, connectionOptions, logger) {
        this.client = client;
        this.connectionOptions = connectionOptions;
        this.logger = logger;
    }
    async onApplicationBootstrap() {
        const options = this.connectionOptions;
        if (options.lazyConnect || !options.hosts?.length)
            return;
        this.logger?.log('Connecting to RabbitMQ at ' + colors.blue(options.hosts.toString()));
        Logger.flush();
        await this.client.onConnect();
    }
    onApplicationShutdown() {
        return this.client.close();
    }
};
RabbitmqCoreModule = RabbitmqCoreModule_1 = __decorate([
    __param(0, Inject(CLIENT_TOKEN)),
    __param(1, Inject(RMQ_CONNECTION_OPTIONS)),
    __metadata("design:paramtypes", [RmqClient, Object, Logger])
], RabbitmqCoreModule);
export { RabbitmqCoreModule };