@opra/nestjs 1.10.0 → 1.11.1

package/cjs/kafka/opra-kafka-core.module.js

@@ -1,137 +0,0 @@
-"use strict";
-var OpraKafkaCoreModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraKafkaCoreModule = void 0;
-const tslib_1 = require("tslib");
-const objects_1 = require("@jsopen/objects");
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const common_2 = require("@opra/common");
-const kafka_1 = require("@opra/kafka");
-const constants_js_1 = require("../constants.js");
-const rpc_controller_factory_service_js_1 = require("../helpers/rpc-controller-factory.service.js");
-const opraKafkaNestjsAdapterToken = Symbol('OpraKafkaNestjsAdapter');
-let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
-    constructor(controllerFactory, adapter, config) {
-        this.controllerFactory = controllerFactory;
-        this.adapter = adapter;
-        this.config = config;
-    }
-    static forRoot(moduleOptions) {
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: constants_js_1.OPRA_KAFKA_MODULE_CONFIG,
-                    useValue: {
-                        ...moduleOptions,
-                        logger: moduleOptions.logger || new common_1.Logger(moduleOptions.name),
-                    },
-                },
-            ],
-        });
-    }
-    static forRootAsync(moduleOptions) {
-        if (!moduleOptions.useFactory)
-            throw new Error('Invalid configuration. Must provide "useFactory"');
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: constants_js_1.OPRA_KAFKA_MODULE_CONFIG,
-                    inject: moduleOptions.inject,
-                    useFactory: async (...args) => {
-                        const result = await moduleOptions.useFactory(...args);
-                        result.logger = result.logger || new common_1.Logger(result.name);
-                        return result;
-                    },
-                },
-            ],
-        });
-    }
-    static _getDynamicModule(moduleOptions) {
-        const token = moduleOptions.id || kafka_1.KafkaAdapter;
-        const adapterProvider = {
-            provide: token,
-            inject: [rpc_controller_factory_service_js_1.RpcControllerFactory, core_1.ModuleRef, constants_js_1.OPRA_KAFKA_MODULE_CONFIG],
-            useFactory: async (controllerFactory, moduleRef, config) => {
-                const controllers = controllerFactory
-                    .exploreControllers()
-                    .map(x => x.wrapper.instance.constructor);
-                const document = await common_2.ApiDocumentFactory.createDocument({
-                    info: config.info,
-                    types: config.types,
-                    references: config.references,
-                    api: {
-                        name: config.name,
-                        description: config.description,
-                        transport: 'rpc',
-                        platform: kafka_1.KafkaAdapter.PlatformName,
-                        controllers,
-                    },
-                });
-                const interceptors = moduleOptions.interceptors
-                    ? moduleOptions.interceptors.map(x => {
-                        if ((0, objects_1.isConstructor)(x)) {
-                            return async (ctx, next) => {
-                                const interceptor = moduleRef.get(x);
-                                if (typeof interceptor.intercept === 'function')
-                                    return interceptor.intercept(ctx, next);
-                            };
-                        }
-                        return x;
-                    })
-                    : undefined;
-                return new kafka_1.KafkaAdapter(document, { ...config, interceptors });
-            },
-        };
-        return {
-            global: moduleOptions.global,
-            module: OpraKafkaCoreModule_1,
-            controllers: moduleOptions.controllers,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                rpc_controller_factory_service_js_1.RpcControllerFactory,
-                adapterProvider,
-                {
-                    provide: opraKafkaNestjsAdapterToken,
-                    useExisting: token,
-                },
-            ],
-            imports: [...(moduleOptions?.imports || [])],
-            exports: [...(moduleOptions?.exports || []), adapterProvider],
-        };
-    }
-    onModuleInit() {
-        /** NestJS initialize controller instances on init stage.
-         * So we should update instance properties */
-        const rpcApi = this.adapter.document.rpcApi;
-        const controllers = Array.from(rpcApi.controllers.values());
-        for (const { wrapper } of this.controllerFactory
-            .exploreControllers()
-            .values()) {
-            const ctor = wrapper.instance.constructor;
-            const controller = controllers.find(x => x.ctor === ctor);
-            if (controller) {
-                controller.instance = wrapper.instance;
-            }
-        }
-    }
-    async onApplicationBootstrap() {
-        await this.adapter.start();
-    }
-    async onApplicationShutdown() {
-        await this.adapter.close();
-    }
-};
-exports.OpraKafkaCoreModule = OpraKafkaCoreModule;
-exports.OpraKafkaCoreModule = OpraKafkaCoreModule = OpraKafkaCoreModule_1 = tslib_1.__decorate([
-    (0, common_1.Module)({}),
-    (0, common_1.Global)(),
-    tslib_1.__param(1, (0, common_1.Inject)(opraKafkaNestjsAdapterToken)),
-    tslib_1.__param(2, (0, common_1.Inject)(constants_js_1.OPRA_KAFKA_MODULE_CONFIG)),
-    tslib_1.__metadata("design:paramtypes", [rpc_controller_factory_service_js_1.RpcControllerFactory,
-        kafka_1.KafkaAdapter, Object])
-], OpraKafkaCoreModule);

package/cjs/kafka/opra-kafka.module.js

@@ -1,33 +0,0 @@
-"use strict";
-var OpraKafkaModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraKafkaModule = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const opra_kafka_core_module_js_1 = require("./opra-kafka-core.module.js");
-let OpraKafkaModule = OpraKafkaModule_1 = class OpraKafkaModule {
-    /**
-     *
-     * @param options
-     */
-    static forRoot(options) {
-        return {
-            module: OpraKafkaModule_1,
-            imports: [opra_kafka_core_module_js_1.OpraKafkaCoreModule.forRoot(options)],
-        };
-    }
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options) {
-        return {
-            module: OpraKafkaModule_1,
-            imports: [opra_kafka_core_module_js_1.OpraKafkaCoreModule.forRootAsync(options)],
-        };
-    }
-};
-exports.OpraKafkaModule = OpraKafkaModule;
-exports.OpraKafkaModule = OpraKafkaModule = OpraKafkaModule_1 = tslib_1.__decorate([
-    (0, common_1.Module)({})
-], OpraKafkaModule);

package/cjs/rabbitmq/opra-rabbitmq-core.module.js

@@ -1,137 +0,0 @@
-"use strict";
-var OpraRabbitmqCoreModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraRabbitmqCoreModule = void 0;
-const tslib_1 = require("tslib");
-const objects_1 = require("@jsopen/objects");
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const common_2 = require("@opra/common");
-const rabbitmq_1 = require("@opra/rabbitmq");
-const constants_js_1 = require("../constants.js");
-const rpc_controller_factory_service_js_1 = require("../helpers/rpc-controller-factory.service.js");
-const opraRabbitmqNestjsAdapterToken = Symbol('OpraRabbitmqNestjsAdapter');
-let OpraRabbitmqCoreModule = OpraRabbitmqCoreModule_1 = class OpraRabbitmqCoreModule {
-    constructor(controllerFactory, adapter, config) {
-        this.controllerFactory = controllerFactory;
-        this.adapter = adapter;
-        this.config = config;
-    }
-    static forRoot(moduleOptions) {
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: constants_js_1.OPRA_RMQ_MODULE_CONFIG,
-                    useValue: {
-                        ...moduleOptions,
-                        logger: moduleOptions.logger || new common_1.Logger(moduleOptions.name),
-                    },
-                },
-            ],
-        });
-    }
-    static forRootAsync(moduleOptions) {
-        if (!moduleOptions.useFactory)
-            throw new Error('Invalid configuration. Must provide "useFactory"');
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: constants_js_1.OPRA_RMQ_MODULE_CONFIG,
-                    inject: moduleOptions.inject,
-                    useFactory: async (...args) => {
-                        const result = await moduleOptions.useFactory(...args);
-                        result.logger = result.logger || new common_1.Logger(result.name);
-                        return result;
-                    },
-                },
-            ],
-        });
-    }
-    static _getDynamicModule(moduleOptions) {
-        const token = moduleOptions.id || rabbitmq_1.RabbitmqAdapter;
-        const adapterProvider = {
-            provide: token,
-            inject: [rpc_controller_factory_service_js_1.RpcControllerFactory, core_1.ModuleRef, constants_js_1.OPRA_RMQ_MODULE_CONFIG],
-            useFactory: async (controllerFactory, moduleRef, config) => {
-                const controllers = controllerFactory
-                    .exploreControllers()
-                    .map(x => x.wrapper.instance.constructor);
-                const document = await common_2.ApiDocumentFactory.createDocument({
-                    info: config.info,
-                    types: config.types,
-                    references: config.references,
-                    api: {
-                        name: config.name,
-                        description: config.description,
-                        transport: 'rpc',
-                        platform: rabbitmq_1.RabbitmqAdapter.PlatformName,
-                        controllers,
-                    },
-                });
-                const interceptors = moduleOptions.interceptors
-                    ? moduleOptions.interceptors.map(x => {
-                        if ((0, objects_1.isConstructor)(x)) {
-                            return async (ctx, next) => {
-                                const interceptor = moduleRef.get(x);
-                                if (typeof interceptor.intercept === 'function')
-                                    return interceptor.intercept(ctx, next);
-                            };
-                        }
-                        return x;
-                    })
-                    : undefined;
-                return new rabbitmq_1.RabbitmqAdapter(document, { ...config, interceptors });
-            },
-        };
-        return {
-            global: moduleOptions.global,
-            module: OpraRabbitmqCoreModule_1,
-            controllers: moduleOptions.controllers,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                rpc_controller_factory_service_js_1.RpcControllerFactory,
-                adapterProvider,
-                {
-                    provide: opraRabbitmqNestjsAdapterToken,
-                    useExisting: token,
-                },
-            ],
-            imports: [...(moduleOptions?.imports || [])],
-            exports: [...(moduleOptions?.exports || []), adapterProvider],
-        };
-    }
-    onModuleInit() {
-        /** NestJS initialize controller instances on init stage.
-         * So we should update instance properties */
-        const rpcApi = this.adapter.document.rpcApi;
-        const controllers = Array.from(rpcApi.controllers.values());
-        for (const { wrapper } of this.controllerFactory
-            .exploreControllers()
-            .values()) {
-            const ctor = wrapper.instance.constructor;
-            const controller = controllers.find(x => x.ctor === ctor);
-            if (controller) {
-                controller.instance = wrapper.instance;
-            }
-        }
-    }
-    async onApplicationBootstrap() {
-        await this.adapter.start();
-    }
-    async onApplicationShutdown() {
-        await this.adapter.close();
-    }
-};
-exports.OpraRabbitmqCoreModule = OpraRabbitmqCoreModule;
-exports.OpraRabbitmqCoreModule = OpraRabbitmqCoreModule = OpraRabbitmqCoreModule_1 = tslib_1.__decorate([
-    (0, common_1.Module)({}),
-    (0, common_1.Global)(),
-    tslib_1.__param(1, (0, common_1.Inject)(opraRabbitmqNestjsAdapterToken)),
-    tslib_1.__param(2, (0, common_1.Inject)(constants_js_1.OPRA_RMQ_MODULE_CONFIG)),
-    tslib_1.__metadata("design:paramtypes", [rpc_controller_factory_service_js_1.RpcControllerFactory,
-        rabbitmq_1.RabbitmqAdapter, Object])
-], OpraRabbitmqCoreModule);

package/cjs/rabbitmq/opra-rabbitmq.module.js

@@ -1,33 +0,0 @@
-"use strict";
-var OpraRabbitmqModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraRabbitmqModule = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const opra_rabbitmq_core_module_js_1 = require("./opra-rabbitmq-core.module.js");
-let OpraRabbitmqModule = OpraRabbitmqModule_1 = class OpraRabbitmqModule {
-    /**
-     *
-     * @param options
-     */
-    static forRoot(options) {
-        return {
-            module: OpraRabbitmqModule_1,
-            imports: [opra_rabbitmq_core_module_js_1.OpraRabbitmqCoreModule.forRoot(options)],
-        };
-    }
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options) {
-        return {
-            module: OpraRabbitmqModule_1,
-            imports: [opra_rabbitmq_core_module_js_1.OpraRabbitmqCoreModule.forRootAsync(options)],
-        };
-    }
-};
-exports.OpraRabbitmqModule = OpraRabbitmqModule;
-exports.OpraRabbitmqModule = OpraRabbitmqModule = OpraRabbitmqModule_1 = tslib_1.__decorate([
-    (0, common_1.Module)({})
-], OpraRabbitmqModule);

package/esm/http/opra-http-core.module.js

@@ -1,116 +0,0 @@
-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 { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
-import { OpraExceptionFilter } from './services/opra-exception-filter.js';
-import { OpraMiddleware } from './services/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 };

package/esm/http/opra-http-nestjs-adapter.js

@@ -1,164 +0,0 @@
-import { __decorate, __metadata, __param } from "tslib";
-import nodePath from 'node:path';
-import { isConstructor } from '@jsopen/objects';
-import { Controller, Delete, Get, Head, Next, Options, Patch, Post, Put, Req, Res, Search, } from '@nestjs/common';
-import { HTTP_CONTROLLER_METADATA, NotFoundError, } from '@opra/common';
-import { HttpAdapter } from '@opra/http';
-import { asMutable } from 'ts-gems';
-import { Public } from '../decorators/public.decorator.js';
-import { BaseOpraNestFactory } from '../helpers/base-opra-nest-factory.js';
-export class OpraHttpNestjsAdapter extends HttpAdapter {
-    constructor(options) {
-        super(options);
-        this.nestControllers = [];
-        this._addRootController(options.schemaIsPublic);
-        if (options.controllers) {
-            for (const c of options.controllers) {
-                this._addToNestControllers(c, this.basePath, []);
-            }
-        }
-    }
-    async close() {
-        //
-    }
-    _addRootController(isPublic) {
-        const _this = this;
-        let RootController = class RootController {
-            schema(_req, next) {
-                _this.handler.sendDocumentSchema(_req.opraContext).catch(() => next());
-            }
-        };
-        __decorate([
-            Get('/\\$schema'),
-            __param(0, Req()),
-            __param(1, Next()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object, Function]),
-            __metadata("design:returntype", void 0)
-        ], RootController.prototype, "schema", null);
-        RootController = __decorate([
-            Controller({
-                path: this.basePath,
-            })
-        ], RootController);
-        if (isPublic) {
-            Public()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
-        }
-        this.nestControllers.push(RootController);
-    }
-    _addToNestControllers(sourceClass, currentPath, parentTree) {
-        const metadata = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, sourceClass);
-        if (!metadata)
-            return;
-        /** Create a new controller class */
-        const newClass = {
-            [sourceClass.name]: class extends sourceClass {
-            },
-        }[sourceClass.name];
-        /** Copy metadata keys from source class to new one */
-        BaseOpraNestFactory.copyDecoratorMetadata(newClass, ...parentTree);
-        Controller()(newClass);
-        const newPath = metadata.path
-            ? nodePath.join(currentPath, metadata.path)
-            : currentPath;
-        const adapter = this;
-        // adapter.logger =
-        /** Disable default error handler. Errors will be handled by OpraExceptionFilter */
-        adapter.handler.onError = (context, error) => {
-            throw error;
-        };
-        this.nestControllers.push(newClass);
-        let metadataKeys;
-        if (metadata.operations) {
-            for (const [k, v] of Object.entries(metadata.operations)) {
-                const operationHandler = sourceClass.prototype[k];
-                Object.defineProperty(newClass.prototype, k, {
-                    writable: true,
-                    /** NestJS handler method */
-                    async value(_req, _res) {
-                        _res.statusCode = 200;
-                        const api = adapter.document.api;
-                        const controller = api.findController(sourceClass);
-                        const operation = controller?.operations.get(k);
-                        const context = asMutable(_req.opraContext);
-                        if (!(context && operation && typeof operationHandler === 'function')) {
-                            throw new NotFoundError({
-                                message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
-                                details: {
-                                    path: _req.baseUrl,
-                                    method: _req.method,
-                                },
-                            });
-                        }
-                        /** Configure the HttpContext */
-                        context.operation = operation;
-                        context.controller = operation.owner;
-                        context.controllerInstance = this;
-                        context.operationHandler = operationHandler;
-                        /** Handle request */
-                        await adapter.handler.handleRequest(context);
-                    },
-                });
-                /** Copy metadata keys from source function to new one */
-                metadataKeys = Reflect.getOwnMetadataKeys(operationHandler);
-                const newFn = newClass.prototype[k];
-                for (const key of metadataKeys) {
-                    const m = Reflect.getMetadata(key, operationHandler);
-                    Reflect.defineMetadata(key, m, newFn);
-                }
-                Req()(newClass.prototype, k, 0);
-                Res()(newClass.prototype, k, 1);
-                const descriptor = Object.getOwnPropertyDescriptor(newClass.prototype, k);
-                const operationPath = v.mergePath
-                    ? newPath + (v.path || '')
-                    : nodePath.posix.join(newPath, v.path || '');
-                switch (v.method || 'GET') {
-                    case 'DELETE':
-                        /** Call @Delete decorator over new property */
-                        Delete(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'GET':
-                        /** Call @Get decorator over new property */
-                        Get(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'HEAD':
-                        /** Call @Head decorator over new property */
-                        Head(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'OPTIONS':
-                        /** Call @Options decorator over new property */
-                        Options(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'PATCH':
-                        /** Call @Patch decorator over new property */
-                        Patch(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'POST':
-                        /** Call @Post decorator over new property */
-                        Post(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'PUT':
-                        /** Call @Put decorator over new property */
-                        Put(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    case 'SEARCH':
-                        /** Call @Search decorator over new property */
-                        Search(operationPath)(newClass.prototype, k, descriptor);
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-        if (metadata.controllers) {
-            for (const child of metadata.controllers) {
-                if (!isConstructor(child))
-                    throw new TypeError('Controllers should be injectable a class');
-                this._addToNestControllers(child, newPath, [
-                    ...parentTree,
-                    sourceClass,
-                ]);
-            }
-        }
-    }
-}

package/esm/http/opra-http.module.js

@@ -1,30 +0,0 @@
-var OpraHttpModule_1;
-import { __decorate } from "tslib";
-import { Module } from '@nestjs/common';
-import { OpraHttpCoreModule } from './opra-http-core.module.js';
-let OpraHttpModule = OpraHttpModule_1 = class OpraHttpModule {
-    /**
-     *
-     * @param init
-     */
-    static forRoot(init) {
-        return {
-            module: OpraHttpModule_1,
-            imports: [OpraHttpCoreModule.forRoot(init)],
-        };
-    }
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options) {
-        return {
-            module: OpraHttpModule_1,
-            imports: [OpraHttpCoreModule.forRootAsync(options)],
-        };
-    }
-};
-OpraHttpModule = OpraHttpModule_1 = __decorate([
-    Module({})
-], OpraHttpModule);
-export { OpraHttpModule };

package/esm/http/services/opra-exception-filter.js

@@ -1,24 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { Catch } from '@nestjs/common';
-import { BaseExceptionFilter, ModuleRef } from '@nestjs/core';
-import { OpraHttpNestjsAdapter } from '../opra-http-nestjs-adapter.js';
-let OpraExceptionFilter = class OpraExceptionFilter extends BaseExceptionFilter {
-    constructor(moduleRef) {
-        super();
-        this.moduleRef = moduleRef;
-    }
-    catch(exception, host) {
-        const ctx = host.switchToHttp().getRequest().opraContext;
-        if (ctx) {
-            const adapter = this.moduleRef.get(OpraHttpNestjsAdapter);
-            ctx.errors.push(exception);
-            return adapter.handler.sendResponse(ctx);
-        }
-        super.catch(exception, host);
-    }
-};
-OpraExceptionFilter = __decorate([
-    Catch(),
-    __metadata("design:paramtypes", [ModuleRef])
-], OpraExceptionFilter);
-export { OpraExceptionFilter };