@opra/nestjs 1.0.0-beta.3 → 1.0.0-beta.5

package/cjs/augmentation/nestjs.augmentation.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@nestjs/common");
 const external_exception_filter_js_1 = require("@nestjs/core/exceptions/external-exception-filter.js");
+const common_2 = require("@opra/common");
+const { RpcControllerDecoratorFactory } = common_2.classes;
 const oldCatchMethod = external_exception_filter_js_1.ExternalExceptionFilter.prototype.catch;
 external_exception_filter_js_1.ExternalExceptionFilter.prototype.catch = function (exception, host) {
     const opraContext = host.getArgByIndex(3);
@@ -9,3 +12,8 @@ external_exception_filter_js_1.ExternalExceptionFilter.prototype.catch = functio
         throw exception;
     oldCatchMethod(exception, host);
 };
+RpcControllerDecoratorFactory.augment((decorator, decoratorChain) => {
+    decoratorChain.push((_, target) => {
+        (0, common_1.Controller)()(target);
+    });
+});

package/cjs/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPRA_HTTP_MODULE_OPTIONS = exports.IS_PUBLIC_KEY = void 0;
+exports.OPRA_KAFKA_MODULE_CONFIG = exports.OPRA_HTTP_API_CONFIG = exports.IS_PUBLIC_KEY = void 0;
 exports.IS_PUBLIC_KEY = 'opra:isPublic';
-exports.OPRA_HTTP_MODULE_OPTIONS = 'OPRA_HTTP_MODULE_OPTIONS';
+exports.OPRA_HTTP_API_CONFIG = 'OPRA_HTTP_API_CONFIG';
+exports.OPRA_KAFKA_MODULE_CONFIG = 'OPRA_KAFKA_MODULE_CONFIG';

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

@@ -0,0 +1,116 @@
+"use strict";
+var OpraHttpCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpCoreModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const common_2 = require("@opra/common");
+const ts_gems_1 = require("ts-gems");
+const constants_js_1 = require("../constants.js");
+const opra_http_nestjs_adapter_js_1 = require("./opra-http-nestjs-adapter.js");
+const opra_exception_filter_js_1 = require("./services/opra-exception-filter.js");
+const opra_middleware_js_1 = require("./services/opra-middleware.js");
+const opraHttpNestjsAdapterToken = Symbol('OpraHttpNestjsAdapter');
+let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
+    constructor(opraAdapter) {
+        this.opraAdapter = opraAdapter;
+    }
+    configure(consumer) {
+        consumer.apply(opra_middleware_js_1.OpraMiddleware).forRoutes({
+            path: '*',
+            method: common_1.RequestMethod.ALL,
+        });
+    }
+    static forRoot(moduleOptions) {
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: constants_js_1.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: constants_js_1.OPRA_HTTP_API_CONFIG,
+                    inject: moduleOptions.inject,
+                    useFactory: moduleOptions.useFactory,
+                },
+            ],
+        });
+    }
+    static _getDynamicModule(moduleOptions) {
+        const token = moduleOptions?.token || opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter;
+        const opraNestAdapter = new opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter({
+            ...moduleOptions,
+            interceptors: undefined,
+        });
+        const adapterProvider = {
+            provide: token,
+            inject: [core_1.ModuleRef, constants_js_1.OPRA_HTTP_API_CONFIG],
+            useFactory: async (moduleRef, apiConfig) => {
+                opraNestAdapter.logger = opraNestAdapter.logger || new common_1.Logger(apiConfig.name);
+                (0, ts_gems_1.asMutable)(opraNestAdapter).document = await common_2.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 ((0, common_2.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: core_1.APP_FILTER,
+                    useClass: opra_exception_filter_js_1.OpraExceptionFilter,
+                },
+            ],
+            imports: [...(moduleOptions?.imports || [])],
+            exports: [...(moduleOptions?.exports || []), adapterProvider],
+        };
+    }
+    async onModuleDestroy() {
+        await this.opraAdapter.close();
+    }
+};
+exports.OpraHttpCoreModule = OpraHttpCoreModule;
+exports.OpraHttpCoreModule = OpraHttpCoreModule = OpraHttpCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({}),
+    (0, common_1.Global)(),
+    tslib_1.__metadata("design:paramtypes", [opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter])
+], OpraHttpCoreModule);

package/cjs/{opra-nestjs-adapter.js → http/opra-http-nestjs-adapter.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraNestAdapter = void 0;
+exports.OpraHttpNestjsAdapter = void 0;
 const tslib_1 = require("tslib");
 const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const common_1 = require("@nestjs/common");
@@ -8,30 +8,23 @@ const constants_js_1 = require("@nestjs/common/constants.js");
 const common_2 = require("@opra/common");
 const http_1 = require("@opra/http");
 const ts_gems_1 = require("ts-gems");
-const public_decorator_js_1 = require("./decorators/public.decorator.js");
-class OpraNestAdapter extends http_1.HttpAdapter {
-    constructor(init, options) {
+const public_decorator_js_1 = require("../decorators/public.decorator.js");
+class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
+    constructor(options) {
         super((function () {
             const document = new common_2.ApiDocument();
-            document.api = new common_2.HttpApi({ owner: document, name: init.name, transport: 'http' });
+            document.api = new common_2.HttpApi({ owner: document, name: '', transport: 'http' });
             return document;
-        })(), {
-            ...options,
-            interceptors: options?.interceptors,
-        });
+        })(), options);
         this.nestControllers = [];
-        this.options = options;
-        let basePath = options?.basePath || '/';
-        if (!basePath.startsWith('/'))
-            basePath = '/' + basePath;
-        this._addRootController(basePath);
-        if (init.controllers)
-            init.controllers.forEach(c => this._addToNestControllers(c, basePath, []));
+        this._addRootController(options.schemaIsPublic);
+        if (options.controllers)
+            options.controllers.forEach(c => this._addToNestControllers(c, this.basePath, []));
     }
     async close() {
         //
     }
-    _addRootController(basePath) {
+    _addRootController(isPublic) {
         const _this = this;
         let RootController = class RootController {
             schema(_req, next) {
@@ -48,10 +41,10 @@ class OpraNestAdapter extends http_1.HttpAdapter {
         ], RootController.prototype, "schema", null);
         RootController = tslib_1.__decorate([
             (0, common_1.Controller)({
-                path: basePath,
+                path: this.basePath,
             })
         ], RootController);
-        if (this.options?.schemaRouteIsPublic) {
+        if (isPublic) {
             (0, public_decorator_js_1.Public)()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
         }
         this.nestControllers.push(RootController);
@@ -66,7 +59,7 @@ class OpraNestAdapter extends http_1.HttpAdapter {
         }[sourceClass.name];
         /** Copy metadata keys from source class to new one */
         let metadataKeys;
-        OpraNestAdapter.copyDecoratorMetadataToChild(newClass, parentTree);
+        OpraHttpNestjsAdapter.copyDecoratorMetadataToChild(newClass, parentTree);
         const newPath = metadata.path ? node_path_1.default.join(currentPath, metadata.path) : currentPath;
         const adapter = this;
         // adapter.logger =
@@ -187,4 +180,4 @@ class OpraNestAdapter extends http_1.HttpAdapter {
         }
     }
 }
-exports.OpraNestAdapter = OpraNestAdapter;
+exports.OpraHttpNestjsAdapter = OpraHttpNestjsAdapter;

package/cjs/{opra-http.module.js → http/opra-http.module.js}

@@ -9,12 +9,21 @@ let OpraHttpModule = OpraHttpModule_1 = class OpraHttpModule {
     /**
      *
      * @param init
+     */
+    static forRoot(init) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRoot(init)],
+        };
+    }
+    /**
+     *
      * @param options
      */
-    static forRoot(init, options) {
+    static forRootAsync(options) {
         return {
             module: OpraHttpModule_1,
-            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRoot(init, options)],
+            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRootAsync(options)],
         };
     }
 };

package/cjs/{services → http/services}/opra-exception-filter.js

@@ -4,7 +4,7 @@ exports.OpraExceptionFilter = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
-const opra_nestjs_adapter_js_1 = require("../opra-nestjs-adapter.js");
+const opra_http_nestjs_adapter_js_1 = require("../opra-http-nestjs-adapter.js");
 let OpraExceptionFilter = class OpraExceptionFilter extends core_1.BaseExceptionFilter {
     constructor(moduleRef) {
         super();
@@ -13,7 +13,7 @@ let OpraExceptionFilter = class OpraExceptionFilter extends core_1.BaseException
     catch(exception, host) {
         const ctx = host.switchToHttp().getRequest().opraContext;
         if (ctx) {
-            const adapter = this.moduleRef.get(opra_nestjs_adapter_js_1.OpraNestAdapter);
+            const adapter = this.moduleRef.get(opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter);
             ctx.errors.push(exception);
             return adapter.handler.sendResponse(ctx);
         }

package/cjs/{services → http/services}/opra-middleware.js

@@ -4,12 +4,10 @@ exports.OpraMiddleware = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const http_1 = require("@opra/http");
-const constants_js_1 = require("../constants.js");
-const opra_nestjs_adapter_js_1 = require("../opra-nestjs-adapter.js");
+const opra_http_nestjs_adapter_js_1 = require("../opra-http-nestjs-adapter.js");
 let OpraMiddleware = class OpraMiddleware {
-    constructor(opraAdapter, options) {
+    constructor(opraAdapter) {
         this.opraAdapter = opraAdapter;
-        this.options = options;
     }
     use(req, res, next) {
         const request = http_1.HttpIncoming.from(req);
@@ -31,6 +29,5 @@ let OpraMiddleware = class OpraMiddleware {
 exports.OpraMiddleware = OpraMiddleware;
 exports.OpraMiddleware = OpraMiddleware = tslib_1.__decorate([
     (0, common_1.Injectable)(),
-    tslib_1.__param(1, (0, common_1.Inject)(constants_js_1.OPRA_HTTP_MODULE_OPTIONS)),
-    tslib_1.__metadata("design:paramtypes", [opra_nestjs_adapter_js_1.OpraNestAdapter, Object])
+    tslib_1.__metadata("design:paramtypes", [opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter])
 ], OpraMiddleware);

package/cjs/index.js

@@ -5,5 +5,7 @@ require("reflect-metadata");
 require("./augmentation/nestjs.augmentation.js");
 tslib_1.__exportStar(require("./constants.js"), exports);
 tslib_1.__exportStar(require("./decorators/public.decorator.js"), exports);
-tslib_1.__exportStar(require("./opra-http.module.js"), exports);
-tslib_1.__exportStar(require("./opra-nestjs-adapter.js"), exports);
+tslib_1.__exportStar(require("./http/opra-http.module.js"), exports);
+tslib_1.__exportStar(require("./http/opra-http-nestjs-adapter.js"), exports);
+tslib_1.__exportStar(require("./kafka/opra-kafka.module.js"), exports);
+tslib_1.__exportStar(require("./kafka/opra-kafka-nestjs-adapter.js"), exports);

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

@@ -0,0 +1,107 @@
+"use strict";
+var OpraKafkaCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraKafkaCoreModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const common_2 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+const opra_kafka_nestjs_adapter_js_1 = require("./opra-kafka-nestjs-adapter.js");
+const opraKafkaNestjsAdapterToken = Symbol('OpraKafkaNestjsAdapter');
+let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
+    constructor(adapter, init) {
+        this.adapter = adapter;
+        this.init = init;
+    }
+    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 || opra_kafka_nestjs_adapter_js_1.OpraKafkaNestjsAdapter;
+        const adapterProvider = {
+            provide: token,
+            inject: [core_1.ModuleRef, constants_js_1.OPRA_KAFKA_MODULE_CONFIG],
+            useFactory: async (moduleRef, config) => {
+                const adapter = new opra_kafka_nestjs_adapter_js_1.OpraKafkaNestjsAdapter(moduleRef);
+                await adapter.initialize(config);
+                if (moduleOptions.interceptors) {
+                    adapter.adapter.interceptors = moduleOptions.interceptors.map(x => {
+                        if ((0, common_2.isConstructor)(x)) {
+                            return async (ctx, next) => {
+                                const interceptor = moduleRef.get(x);
+                                if (typeof interceptor.intercept === 'function')
+                                    return interceptor.intercept(ctx, next);
+                            };
+                        }
+                        return x;
+                    });
+                }
+                return adapter;
+            },
+        };
+        return {
+            global: moduleOptions.global,
+            module: OpraKafkaCoreModule_1,
+            controllers: moduleOptions.controllers,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                adapterProvider,
+                {
+                    provide: opraKafkaNestjsAdapterToken,
+                    useExisting: token,
+                },
+            ],
+            imports: [...(moduleOptions?.imports || [])],
+            exports: [...(moduleOptions?.exports || []), adapterProvider],
+        };
+    }
+    async onModuleInit() {
+        await this.adapter.initialize(this.init);
+    }
+    async onApplicationBootstrap() {
+        await this.adapter.start();
+    }
+    async onApplicationShutdown() {
+        await this.adapter.stop();
+    }
+};
+exports.OpraKafkaCoreModule = OpraKafkaCoreModule;
+exports.OpraKafkaCoreModule = OpraKafkaCoreModule = OpraKafkaCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({}),
+    (0, common_1.Global)(),
+    tslib_1.__param(0, (0, common_1.Inject)(opraKafkaNestjsAdapterToken)),
+    tslib_1.__param(1, (0, common_1.Inject)(constants_js_1.OPRA_KAFKA_MODULE_CONFIG)),
+    tslib_1.__metadata("design:paramtypes", [opra_kafka_nestjs_adapter_js_1.OpraKafkaNestjsAdapter, Object])
+], OpraKafkaCoreModule);

package/cjs/kafka/opra-kafka-nestjs-adapter.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraKafkaNestjsAdapter = void 0;
+const index_1 = require("@nestjs/core/errors/exceptions/index");
+const common_1 = require("@opra/common");
+const kafka_1 = require("@opra/kafka");
+/**
+ * @class
+ */
+class OpraKafkaNestjsAdapter {
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+    }
+    get document() {
+        if (!this._document)
+            throw new index_1.RuntimeException('Not initialized yet');
+        return this._document;
+    }
+    get adapter() {
+        if (!this._adapter)
+            throw new index_1.RuntimeException('Not initialized yet');
+        return this._adapter;
+    }
+    async start() {
+        if (!this._adapter) {
+            throw new index_1.RuntimeException('Not initialized yet');
+        }
+        return this._adapter.start();
+    }
+    async stop() {
+        return this._adapter?.close();
+    }
+    async initialize(init) {
+        const controllers = this._scanControllers();
+        this._document = await common_1.ApiDocumentFactory.createDocument({
+            info: init.info,
+            types: init.types,
+            references: init.references,
+            api: {
+                name: init.name,
+                description: init.description,
+                transport: 'rpc',
+                platform: 'kafka',
+                controllers,
+            },
+        });
+        this._adapter = new kafka_1.KafkaAdapter({
+            client: init.client,
+            logger: init.logger,
+            logExtra: init.logExtra,
+            consumers: init.consumers,
+            document: this._document,
+        });
+    }
+    _scanControllers() {
+        const container = this.moduleRef.container;
+        const modules = container.getModules();
+        const controllerInstances = [];
+        modules.forEach(({ controllers }) => {
+            controllers.forEach(wrapper => {
+                const ctor = Object.getPrototypeOf(wrapper.instance).constructor;
+                const metadata = Reflect.getMetadata(common_1.RPC_CONTROLLER_METADATA, ctor);
+                if (metadata) {
+                    const instance = {};
+                    Object.setPrototypeOf(instance, wrapper.instance);
+                    controllerInstances.push(instance);
+                    if (metadata.operations) {
+                        // for (const [k, _] of Object.keys(metadata.operations)) {
+                        //   const fn = instance[k];
+                        //   instance[k] = fn;
+                        // }
+                    }
+                }
+            });
+        });
+        return controllerInstances;
+    }
+}
+exports.OpraKafkaNestjsAdapter = OpraKafkaNestjsAdapter;

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

@@ -0,0 +1,33 @@
+"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/esm/augmentation/nestjs.augmentation.js

@@ -1,4 +1,7 @@
+import { Controller } from '@nestjs/common';
 import { ExternalExceptionFilter } from '@nestjs/core/exceptions/external-exception-filter.js';
+import { classes } from '@opra/common';
+const { RpcControllerDecoratorFactory } = classes;
 const oldCatchMethod = ExternalExceptionFilter.prototype.catch;
 ExternalExceptionFilter.prototype.catch = function (exception, host) {
     const opraContext = host.getArgByIndex(3);
@@ -7,3 +10,8 @@ ExternalExceptionFilter.prototype.catch = function (exception, host) {
         throw exception;
     oldCatchMethod(exception, host);
 };
+RpcControllerDecoratorFactory.augment((decorator, decoratorChain) => {
+    decoratorChain.push((_, target) => {
+        Controller()(target);
+    });
+});

package/esm/constants.js

@@ -1,2 +1,3 @@
 export const IS_PUBLIC_KEY = 'opra:isPublic';
-export const OPRA_HTTP_MODULE_OPTIONS = 'OPRA_HTTP_MODULE_OPTIONS';
+export const OPRA_HTTP_API_CONFIG = 'OPRA_HTTP_API_CONFIG';
+export const OPRA_KAFKA_MODULE_CONFIG = 'OPRA_KAFKA_MODULE_CONFIG';

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

@@ -0,0 +1,113 @@
+var OpraHttpCoreModule_1;
+import { __decorate, __metadata } from "tslib";
+import { Global, Logger, Module, RequestMethod, } from '@nestjs/common';
+import { APP_FILTER, ModuleRef } from '@nestjs/core';
+import { ApiDocumentFactory, isConstructor } from '@opra/common';
+import { asMutable } from 'ts-gems';
+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.logger = opraNestAdapter.logger || new Logger(apiConfig.name);
+                asMutable(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 };