@opra/nestjs-http/esm/opra-http-core.module.js

Opra NestJS Http Module

var OpraHttpCoreModule_1;
import { __decorate, __metadata } from "tslib";
import { isConstructor } from '@jsopen/objects';
import { Global, Logger, Module, RequestMethod, } from '@nestjs/common';
import { APP_FILTER, ModuleRef } from '@nestjs/core';
import { ApiDocumentFactory } from '@opra/common';
import { OPRA_HTTP_API_CONFIG } from './constants.js';
import { OpraExceptionFilter } from './opra-exception-filter.js';
import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
import { OpraMiddleware } from './opra-middleware.js';
const opraHttpNestjsAdapterToken = Symbol('OpraHttpNestjsAdapter');
let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
    constructor(opraAdapter) {
        this.opraAdapter = opraAdapter;
    }
    configure(consumer) {
        consumer.apply(OpraMiddleware).forRoutes({
            path: '*',
            method: RequestMethod.ALL,
        });
    }
    static forRoot(moduleOptions) {
        return this._getDynamicModule({
            ...moduleOptions,
            providers: [
                ...(moduleOptions?.providers || []),
                {
                    provide: OPRA_HTTP_API_CONFIG,
                    useValue: { ...moduleOptions },
                },
            ],
        });
    }
    static forRootAsync(moduleOptions) {
        if (!moduleOptions.useFactory)
            throw new Error('Invalid configuration. Must provide "useFactory"');
        return this._getDynamicModule({
            ...moduleOptions,
            providers: [
                ...(moduleOptions?.providers || []),
                {
                    provide: OPRA_HTTP_API_CONFIG,
                    inject: moduleOptions.inject,
                    useFactory: moduleOptions.useFactory,
                },
            ],
        });
    }
    static _getDynamicModule(moduleOptions) {
        const token = moduleOptions?.token || OpraHttpNestjsAdapter;
        const opraNestAdapter = new OpraHttpNestjsAdapter({
            ...moduleOptions,
            interceptors: undefined,
        });
        const adapterProvider = {
            provide: token,
            inject: [ModuleRef, OPRA_HTTP_API_CONFIG],
            useFactory: async (moduleRef, apiConfig) => {
                opraNestAdapter.scope = apiConfig.scope;
                opraNestAdapter.logger =
                    opraNestAdapter.logger || new Logger(apiConfig.name);
                opraNestAdapter._document =
                    await ApiDocumentFactory.createDocument({
                        ...apiConfig,
                        api: {
                            transport: 'http',
                            name: apiConfig.name,
                            description: apiConfig.description,
                            controllers: moduleOptions.controllers,
                        },
                    });
                if (moduleOptions.interceptors) {
                    opraNestAdapter.interceptors = moduleOptions.interceptors.map(x => {
                        if (isConstructor(x)) {
                            return async (ctx, next) => {
                                const interceptor = moduleRef.get(x);
                                if (typeof interceptor.intercept === 'function')
                                    return interceptor.intercept(ctx, next);
                            };
                        }
                        return x;
                    });
                }
                return opraNestAdapter;
            },
        };
        return {
            global: moduleOptions.global,
            module: OpraHttpCoreModule_1,
            controllers: opraNestAdapter.nestControllers,
            providers: [
                ...(moduleOptions?.providers || []),
                adapterProvider,
                {
                    provide: opraHttpNestjsAdapterToken,
                    useExisting: token,
                },
                {
                    provide: APP_FILTER,
                    useClass: OpraExceptionFilter,
                },
            ],
            imports: [...(moduleOptions?.imports || [])],
            exports: [...(moduleOptions?.exports || []), adapterProvider],
        };
    }
    async onModuleDestroy() {
        await this.opraAdapter.close();
    }
};
OpraHttpCoreModule = OpraHttpCoreModule_1 = __decorate([
    Module({}),
    Global(),
    __metadata("design:paramtypes", [OpraHttpNestjsAdapter])
], OpraHttpCoreModule);
export { OpraHttpCoreModule };