@nestjs/microservices/module/clients.module.js

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

var ClientsModule_1;
import { __decorate } from "tslib";
import { Module, } from '@nestjs/common';
import { ClientProxyFactory } from '../client/index.js';
let ClientsModule = ClientsModule_1 = class ClientsModule {
    static register(options) {
        const clientsOptions = !Array.isArray(options) ? options.clients : options;
        const clients = (clientsOptions || []).map(item => {
            return {
                provide: item.name,
                useValue: this.assignOnAppShutdownHook(ClientProxyFactory.create(item)),
            };
        });
        return {
            module: ClientsModule_1,
            global: !Array.isArray(options) && options.isGlobal,
            providers: clients,
            exports: clients,
        };
    }
    static registerAsync(options) {
        const clientsOptions = !Array.isArray(options) ? options.clients : options;
        const providers = clientsOptions.flatMap(item => [
            ...this.createAsyncProviders(item),
            ...(item.extraProviders || []),
        ]);
        const imports = clientsOptions.reduce((accImports, option) => {
            if (!option.imports) {
                return accImports;
            }
            const toInsert = option.imports.filter(item => !accImports.includes(item));
            return accImports.concat(toInsert);
        }, []);
        return {
            module: ClientsModule_1,
            global: !Array.isArray(options) && options.isGlobal,
            imports,
            providers: providers,
            exports: providers,
        };
    }
    static createAsyncProviders(options) {
        if (options.useExisting || options.useFactory) {
            return [this.createAsyncOptionsProvider(options)];
        }
        return [
            this.createAsyncOptionsProvider(options),
            {
                provide: options.useClass,
                useClass: options.useClass,
            },
        ];
    }
    static createAsyncOptionsProvider(options) {
        if (options.useFactory) {
            return {
                provide: options.name,
                useFactory: this.createFactoryWrapper(options.useFactory),
                inject: options.inject || [],
            };
        }
        return {
            provide: options.name,
            useFactory: this.createFactoryWrapper((optionsFactory) => optionsFactory.createClientOptions()),
            inject: [options.useExisting || options.useClass],
        };
    }
    static createFactoryWrapper(useFactory) {
        return async (...args) => {
            const clientOptions = await useFactory(...args);
            const clientProxyRef = ClientProxyFactory.create(clientOptions);
            return this.assignOnAppShutdownHook(clientProxyRef);
        };
    }
    static assignOnAppShutdownHook(client) {
        client.onApplicationShutdown =
            client.close;
        return client;
    }
};
ClientsModule = ClientsModule_1 = __decorate([
    Module({})
], ClientsModule);
export { ClientsModule };