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

package/cjs/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPRA_KAFKA_MODULE_OPTIONS = 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_KAFKA_MODULE_OPTIONS = 'OPRA_KAFKA_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

@@ -11,6 +11,7 @@ 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;
@@ -21,53 +22,86 @@ let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
             method: common_1.RequestMethod.ALL,
         });
     }
-    static forRoot(init) {
-        const opraAdapter = new opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter(init);
-        const token = init?.id || opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter;
-        const providers = [
-            ...(init?.providers || []),
-            {
-                provide: constants_js_1.OPRA_HTTP_MODULE_OPTIONS,
-                useValue: { ...init.options },
-            },
-            {
-                provide: token,
-                inject: [core_1.ModuleRef],
-                useFactory: async (moduleRef) => {
-                    (0, ts_gems_1.asMutable)(opraAdapter).document = await common_2.ApiDocumentFactory.createDocument({
-                        ...init,
-                        api: { transport: 'http', name: init.name, controllers: init.controllers },
-                    });
-                    opraAdapter.interceptors.map(x => {
+    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 (ctx, next) => {
+                            return async (ctx, next) => {
                                 const interceptor = moduleRef.get(x);
                                 if (typeof interceptor.intercept === 'function')
-                                    return interceptor.intercept(ctx, next());
+                                    return interceptor.intercept(ctx, next);
                             };
                         }
                         return x;
                     });
-                    return opraAdapter;
-                },
-            },
-            {
-                provide: core_1.APP_FILTER,
-                useClass: opra_exception_filter_js_1.OpraExceptionFilter,
+                }
+                return opraNestAdapter;
             },
-        ];
-        if (token !== opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter) {
-            providers.push({
-                provide: token,
-                useValue: opraAdapter,
-            });
-        }
+        };
         return {
+            global: moduleOptions.global,
             module: OpraHttpCoreModule_1,
-            controllers: opraAdapter.nestControllers,
-            imports: [...(init?.imports || [])],
-            exports: [...(init?.exports || []), token],
-            providers,
+            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() {

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

@@ -10,28 +10,21 @@ const http_1 = require("@opra/http");
 const ts_gems_1 = require("ts-gems");
 const public_decorator_js_1 = require("../decorators/public.decorator.js");
 class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
-    constructor(init) {
+    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;
-        })(), {
-            ...init.options,
-            interceptors: init.options?.interceptors,
-        });
+        })(), options);
         this.nestControllers = [];
-        this.options = init.options;
-        let basePath = init.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 OpraHttpNestjsAdapter 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);

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

@@ -16,6 +16,16 @@ let OpraHttpModule = OpraHttpModule_1 = class OpraHttpModule {
             imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRoot(init)],
         };
     }
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRootAsync(options)],
+        };
+    }
 };
 exports.OpraHttpModule = OpraHttpModule;
 exports.OpraHttpModule = OpraHttpModule = OpraHttpModule_1 = tslib_1.__decorate([

package/cjs/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_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_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter, Object])
+    tslib_1.__metadata("design:paramtypes", [opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter])
 ], OpraMiddleware);

package/cjs/index.js

@@ -7,5 +7,5 @@ tslib_1.__exportStar(require("./constants.js"), exports);
 tslib_1.__exportStar(require("./decorators/public.decorator.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("./rpc/kafka/opra-kafka.module.js"), exports);
-tslib_1.__exportStar(require("./rpc/kafka/opra-kafka-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/{rpc/kafka → kafka}/opra-kafka.module.js

@@ -8,12 +8,22 @@ const opra_kafka_core_module_js_1 = require("./opra-kafka-core.module.js");
 let OpraKafkaModule = OpraKafkaModule_1 = class OpraKafkaModule {
     /**
      *
-     * @param init
+     * @param options
      */
-    static forRoot(init) {
+    static forRoot(options) {
         return {
             module: OpraKafkaModule_1,
-            imports: [opra_kafka_core_module_js_1.OpraKafkaCoreModule.forRoot(init)],
+            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)],
         };
     }
 };

package/esm/constants.js

@@ -1,3 +1,3 @@
 export const IS_PUBLIC_KEY = 'opra:isPublic';
-export const OPRA_HTTP_MODULE_OPTIONS = 'OPRA_HTTP_MODULE_OPTIONS';
-export const OPRA_KAFKA_MODULE_OPTIONS = 'OPRA_KAFKA_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

@@ -1,13 +1,14 @@
 var OpraHttpCoreModule_1;
 import { __decorate, __metadata } from "tslib";
-import { Global, Module, RequestMethod, } from '@nestjs/common';
+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_MODULE_OPTIONS } from '../constants.js';
+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;
@@ -18,53 +19,86 @@ let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
             method: RequestMethod.ALL,
         });
     }
-    static forRoot(init) {
-        const opraAdapter = new OpraHttpNestjsAdapter(init);
-        const token = init?.id || OpraHttpNestjsAdapter;
-        const providers = [
-            ...(init?.providers || []),
-            {
-                provide: OPRA_HTTP_MODULE_OPTIONS,
-                useValue: { ...init.options },
-            },
-            {
-                provide: token,
-                inject: [ModuleRef],
-                useFactory: async (moduleRef) => {
-                    asMutable(opraAdapter).document = await ApiDocumentFactory.createDocument({
-                        ...init,
-                        api: { transport: 'http', name: init.name, controllers: init.controllers },
-                    });
-                    opraAdapter.interceptors.map(x => {
+    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 (ctx, next) => {
+                            return async (ctx, next) => {
                                 const interceptor = moduleRef.get(x);
                                 if (typeof interceptor.intercept === 'function')
-                                    return interceptor.intercept(ctx, next());
+                                    return interceptor.intercept(ctx, next);
                             };
                         }
                         return x;
                     });
-                    return opraAdapter;
-                },
-            },
-            {
-                provide: APP_FILTER,
-                useClass: OpraExceptionFilter,
+                }
+                return opraNestAdapter;
             },
-        ];
-        if (token !== OpraHttpNestjsAdapter) {
-            providers.push({
-                provide: token,
-                useValue: opraAdapter,
-            });
-        }
+        };
         return {
+            global: moduleOptions.global,
             module: OpraHttpCoreModule_1,
-            controllers: opraAdapter.nestControllers,
-            imports: [...(init?.imports || [])],
-            exports: [...(init?.exports || []), token],
-            providers,
+            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() {

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

@@ -7,28 +7,21 @@ import { HttpAdapter } from '@opra/http';
 import { asMutable } from 'ts-gems';
 import { Public } from '../decorators/public.decorator.js';
 export class OpraHttpNestjsAdapter extends HttpAdapter {
-    constructor(init) {
+    constructor(options) {
         super((function () {
             const document = new ApiDocument();
-            document.api = new HttpApi({ owner: document, name: init.name, transport: 'http' });
+            document.api = new HttpApi({ owner: document, name: '', transport: 'http' });
             return document;
-        })(), {
-            ...init.options,
-            interceptors: init.options?.interceptors,
-        });
+        })(), options);
         this.nestControllers = [];
-        this.options = init.options;
-        let basePath = init.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) {
@@ -45,10 +38,10 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
         ], RootController.prototype, "schema", null);
         RootController = __decorate([
             Controller({
-                path: basePath,
+                path: this.basePath,
             })
         ], RootController);
-        if (this.options?.schemaRouteIsPublic) {
+        if (isPublic) {
             Public()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
         }
         this.nestControllers.push(RootController);

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

@@ -13,6 +13,16 @@ let OpraHttpModule = OpraHttpModule_1 = class OpraHttpModule {
             imports: [OpraHttpCoreModule.forRoot(init)],
         };
     }
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [OpraHttpCoreModule.forRootAsync(options)],
+        };
+    }
 };
 OpraHttpModule = OpraHttpModule_1 = __decorate([
     Module({})

package/esm/http/services/opra-middleware.js

@@ -1,12 +1,10 @@
-import { __decorate, __metadata, __param } from "tslib";
-import { Inject, Injectable } from '@nestjs/common';
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@nestjs/common';
 import { HttpContext, HttpIncoming, HttpOutgoing } from '@opra/http';
-import { OPRA_HTTP_MODULE_OPTIONS } from '../../constants.js';
 import { OpraHttpNestjsAdapter } from '../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 = HttpIncoming.from(req);
@@ -27,7 +25,6 @@ let OpraMiddleware = class OpraMiddleware {
 };
 OpraMiddleware = __decorate([
     Injectable(),
-    __param(1, Inject(OPRA_HTTP_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [OpraHttpNestjsAdapter, Object])
+    __metadata("design:paramtypes", [OpraHttpNestjsAdapter])
 ], OpraMiddleware);
 export { OpraMiddleware };

package/esm/index.js

@@ -4,5 +4,5 @@ export * from './constants.js';
 export * from './decorators/public.decorator.js';
 export * from './http/opra-http.module.js';
 export * from './http/opra-http-nestjs-adapter.js';
-export * from './rpc/kafka/opra-kafka.module.js';
-export * from './rpc/kafka/opra-kafka-nestjs-adapter.js';
+export * from './kafka/opra-kafka.module.js';
+export * from './kafka/opra-kafka-nestjs-adapter.js';

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

@@ -0,0 +1,104 @@
+var OpraKafkaCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { Global, Inject, Logger, Module, } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { isConstructor } from '@opra/common';
+import { OPRA_KAFKA_MODULE_CONFIG } from '../constants.js';
+import { OpraKafkaNestjsAdapter } from './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: OPRA_KAFKA_MODULE_CONFIG,
+                    useValue: {
+                        ...moduleOptions,
+                        logger: moduleOptions.logger || new 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: OPRA_KAFKA_MODULE_CONFIG,
+                    inject: moduleOptions.inject,
+                    useFactory: async (...args) => {
+                        const result = await moduleOptions.useFactory(...args);
+                        result.logger = result.logger || new Logger(result.name);
+                        return result;
+                    },
+                },
+            ],
+        });
+    }
+    static _getDynamicModule(moduleOptions) {
+        const token = moduleOptions.id || OpraKafkaNestjsAdapter;
+        const adapterProvider = {
+            provide: token,
+            inject: [ModuleRef, OPRA_KAFKA_MODULE_CONFIG],
+            useFactory: async (moduleRef, config) => {
+                const adapter = new OpraKafkaNestjsAdapter(moduleRef);
+                await adapter.initialize(config);
+                if (moduleOptions.interceptors) {
+                    adapter.adapter.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 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();
+    }
+};
+OpraKafkaCoreModule = OpraKafkaCoreModule_1 = __decorate([
+    Module({}),
+    Global(),
+    __param(0, Inject(opraKafkaNestjsAdapterToken)),
+    __param(1, Inject(OPRA_KAFKA_MODULE_CONFIG)),
+    __metadata("design:paramtypes", [OpraKafkaNestjsAdapter, Object])
+], OpraKafkaCoreModule);
+export { OpraKafkaCoreModule };

package/esm/{rpc/kafka → kafka}/opra-kafka.module.js

@@ -5,12 +5,22 @@ import { OpraKafkaCoreModule } from './opra-kafka-core.module.js';
 let OpraKafkaModule = OpraKafkaModule_1 = class OpraKafkaModule {
     /**
      *
-     * @param init
+     * @param options
      */
-    static forRoot(init) {
+    static forRoot(options) {
         return {
             module: OpraKafkaModule_1,
-            imports: [OpraKafkaCoreModule.forRoot(init)],
+            imports: [OpraKafkaCoreModule.forRoot(options)],
+        };
+    }
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options) {
+        return {
+            module: OpraKafkaModule_1,
+            imports: [OpraKafkaCoreModule.forRootAsync(options)],
         };
     }
 };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@opra/nestjs",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
-    "@opra/common": "^1.0.0-beta.4",
-    "@opra/core": "^1.0.0-beta.4",
+    "@opra/common": "^1.0.0-beta.5",
+    "@opra/core": "^1.0.0-beta.5",
     "fast-tokenizer": "^1.7.0",
     "lodash.head": "^4.0.1",
     "putil-promisify": "^1.10.1",
@@ -19,8 +19,8 @@
   },
   "optionalDependencies": {
     "@nestjs/microservices": "^10.4.4",
-    "@opra/http": "^1.0.0-beta.4",
-    "@opra/kafka": "^1.0.0-beta.4"
+    "@opra/http": "^1.0.0-beta.5",
+    "@opra/kafka": "^1.0.0-beta.5"
   },
   "type": "module",
   "exports": {

package/types/constants.d.ts

@@ -1,3 +1,3 @@
 export declare const IS_PUBLIC_KEY = "opra:isPublic";
-export declare const OPRA_HTTP_MODULE_OPTIONS = "OPRA_HTTP_MODULE_OPTIONS";
-export declare const OPRA_KAFKA_MODULE_OPTIONS = "OPRA_KAFKA_MODULE_OPTIONS";
+export declare const OPRA_HTTP_API_CONFIG = "OPRA_HTTP_API_CONFIG";
+export declare const OPRA_KAFKA_MODULE_CONFIG = "OPRA_KAFKA_MODULE_CONFIG";

package/types/http/opra-http-core.module.d.ts

@@ -5,6 +5,8 @@ export declare class OpraHttpCoreModule implements OnModuleDestroy, NestModule {
     protected opraAdapter: OpraHttpNestjsAdapter;
     constructor(opraAdapter: OpraHttpNestjsAdapter);
     configure(consumer: MiddlewareConsumer): void;
-    static forRoot(init: OpraHttpModule.Initiator): DynamicModule;
+    static forRoot(moduleOptions: OpraHttpModule.ModuleOptions): DynamicModule;
+    static forRootAsync(moduleOptions: OpraHttpModule.AsyncModuleOptions): DynamicModule;
+    protected static _getDynamicModule(moduleOptions: OpraHttpModule.ModuleOptions | OpraHttpModule.AsyncModuleOptions): DynamicModule;
     onModuleDestroy(): Promise<void>;
 }

package/types/http/opra-http-nestjs-adapter.d.ts

@@ -1,12 +1,13 @@
 import { type Type } from '@nestjs/common';
 import { HttpAdapter } from '@opra/http';
-import type { OpraHttpModule } from './opra-http.module.js';
 export declare class OpraHttpNestjsAdapter extends HttpAdapter {
     readonly nestControllers: Type[];
-    readonly options?: OpraHttpModule.Options;
-    constructor(init: OpraHttpModule.Initiator);
+    constructor(options: HttpAdapter.Options & {
+        schemaIsPublic?: boolean;
+        controllers?: Type[];
+    });
     close(): Promise<void>;
-    protected _addRootController(basePath: string): void;
+    protected _addRootController(isPublic?: boolean): void;
     protected _addToNestControllers(sourceClass: Type, currentPath: string, parentTree: Type[]): void;
     static copyDecoratorMetadataToChild(target: Type, parentTree: Type[]): void;
 }

package/types/http/opra-http.module.d.ts

@@ -1,22 +1,35 @@
-import { type DynamicModule, type Type } from '@nestjs/common';
+import { type DynamicModule, Logger, type Type } from '@nestjs/common';
 import { ApiDocumentFactory } from '@opra/common';
 import { HttpAdapter } from '@opra/http';
 export declare namespace OpraHttpModule {
-    interface Initiator extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers'>, Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
-        id?: any;
-        name: string;
-        options?: Options;
+    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
+    }
+    export interface AsyncModuleOptions extends BaseModuleOptions {
+        inject?: any[];
+        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
     }
-    interface Options {
+    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
+        token?: any;
         basePath?: string;
-        schemaRouteIsPublic?: boolean;
+        schemaIsPublic?: boolean;
         interceptors?: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor | Type<HttpAdapter.IHttpInterceptor>)[];
     }
+    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
+        name: string;
+        description?: string;
+        logger?: Logger;
+    }
+    export {};
 }
 export declare class OpraHttpModule {
     /**
      *
      * @param init
      */
-    static forRoot(init: OpraHttpModule.Initiator): DynamicModule;
+    static forRoot(init: OpraHttpModule.ModuleOptions): DynamicModule;
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options: OpraHttpModule.AsyncModuleOptions): DynamicModule;
 }

package/types/http/services/opra-middleware.d.ts

@@ -1,10 +1,8 @@
 import { type NestMiddleware } from '@nestjs/common';
 import type { NextFunction, Request, Response } from 'express';
-import type { OpraHttpModule } from '../opra-http.module.js';
 import { OpraHttpNestjsAdapter } from '../opra-http-nestjs-adapter.js';
 export declare class OpraMiddleware implements NestMiddleware {
     protected opraAdapter: OpraHttpNestjsAdapter;
-    protected options: OpraHttpModule.Options;
-    constructor(opraAdapter: OpraHttpNestjsAdapter, options: OpraHttpModule.Options);
+    constructor(opraAdapter: OpraHttpNestjsAdapter);
     use(req: Request, res: Response, next: NextFunction): void;
 }

package/types/index.d.cts

@@ -4,5 +4,5 @@ export * from './constants.js';
 export * from './decorators/public.decorator.js';
 export * from './http/opra-http.module.js';
 export * from './http/opra-http-nestjs-adapter.js';
-export * from './rpc/kafka/opra-kafka.module.js';
-export * from './rpc/kafka/opra-kafka-nestjs-adapter.js';
+export * from './kafka/opra-kafka.module.js';
+export * from './kafka/opra-kafka-nestjs-adapter.js';

package/types/index.d.ts

@@ -4,5 +4,5 @@ export * from './constants.js';
 export * from './decorators/public.decorator.js';
 export * from './http/opra-http.module.js';
 export * from './http/opra-http-nestjs-adapter.js';
-export * from './rpc/kafka/opra-kafka.module.js';
-export * from './rpc/kafka/opra-kafka-nestjs-adapter.js';
+export * from './kafka/opra-kafka.module.js';
+export * from './kafka/opra-kafka-nestjs-adapter.js';

package/types/{rpc/kafka → kafka}/opra-kafka-core.module.d.ts

@@ -3,9 +3,11 @@ import type { OpraKafkaModule } from './opra-kafka.module.js';
 import { OpraKafkaNestjsAdapter } from './opra-kafka-nestjs-adapter.js';
 export declare class OpraKafkaCoreModule implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
     protected adapter: OpraKafkaNestjsAdapter;
-    protected init: OpraKafkaModule.Initiator;
-    constructor(adapter: OpraKafkaNestjsAdapter, init: OpraKafkaModule.Initiator);
-    static forRoot(init: OpraKafkaModule.Initiator): DynamicModule;
+    protected init: OpraKafkaModule.ApiConfig;
+    constructor(adapter: OpraKafkaNestjsAdapter, init: OpraKafkaModule.ApiConfig);
+    static forRoot(moduleOptions: OpraKafkaModule.ModuleOptions): DynamicModule;
+    static forRootAsync(moduleOptions: OpraKafkaModule.AsyncModuleOptions): DynamicModule;
+    protected static _getDynamicModule(moduleOptions: OpraKafkaModule.ModuleOptions | OpraKafkaModule.AsyncModuleOptions): DynamicModule;
     onModuleInit(): Promise<void>;
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;

package/types/{rpc/kafka → kafka}/opra-kafka-nestjs-adapter.d.ts

@@ -14,6 +14,6 @@ export declare class OpraKafkaNestjsAdapter {
     get adapter(): KafkaAdapter;
     start(): Promise<void>;
     stop(): Promise<void | undefined>;
-    initialize(init: OpraKafkaModule.Initiator): Promise<void>;
+    initialize(init: OpraKafkaModule.ApiConfig): Promise<void>;
     protected _scanControllers(): any[];
 }

package/types/kafka/opra-kafka.module.d.ts

@@ -0,0 +1,33 @@
+import { type DynamicModule, Logger, type Type } from '@nestjs/common';
+import { ApiDocumentFactory } from '@opra/common';
+import { KafkaAdapter } from '@opra/kafka';
+export declare namespace OpraKafkaModule {
+    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
+    }
+    export interface AsyncModuleOptions extends BaseModuleOptions {
+        inject?: any[];
+        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
+    }
+    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
+        id?: any;
+        interceptors?: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor | Type<KafkaAdapter.IKafkaInterceptor>)[];
+    }
+    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'>, Pick<KafkaAdapter.Config, 'client' | 'consumers' | 'logExtra'> {
+        name: string;
+        description?: string;
+        logger?: Logger;
+    }
+    export {};
+}
+export declare class OpraKafkaModule {
+    /**
+     *
+     * @param options
+     */
+    static forRoot(options: OpraKafkaModule.ModuleOptions): DynamicModule;
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options: OpraKafkaModule.AsyncModuleOptions): DynamicModule;
+}

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

@@ -1,60 +0,0 @@
-"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 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(init) {
-        const adapterProvider = {
-            provide: init.id || opra_kafka_nestjs_adapter_js_1.OpraKafkaNestjsAdapter,
-            inject: [core_1.ModuleRef],
-            useFactory: (moduleRef) => new opra_kafka_nestjs_adapter_js_1.OpraKafkaNestjsAdapter(moduleRef),
-        };
-        const providers = [
-            ...(init?.providers || []),
-            {
-                provide: constants_js_1.OPRA_KAFKA_MODULE_OPTIONS,
-                useValue: { ...init },
-            },
-            adapterProvider,
-            {
-                provide: opraKafkaNestjsAdapterToken,
-                useExisting: adapterProvider.provide,
-            },
-        ];
-        return {
-            global: true,
-            module: OpraKafkaCoreModule_1,
-            controllers: init.controllers,
-            providers,
-            imports: [...(init?.imports || [])],
-            exports: [...(init?.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_OPTIONS)),
-    tslib_1.__metadata("design:paramtypes", [opra_kafka_nestjs_adapter_js_1.OpraKafkaNestjsAdapter, Object])
-], OpraKafkaCoreModule);

package/esm/rpc/kafka/opra-kafka-core.module.js

@@ -1,57 +0,0 @@
-var OpraKafkaCoreModule_1;
-import { __decorate, __metadata, __param } from "tslib";
-import { Global, Inject, Module, } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { OPRA_KAFKA_MODULE_OPTIONS } from '../../constants.js';
-import { OpraKafkaNestjsAdapter } from './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(init) {
-        const adapterProvider = {
-            provide: init.id || OpraKafkaNestjsAdapter,
-            inject: [ModuleRef],
-            useFactory: (moduleRef) => new OpraKafkaNestjsAdapter(moduleRef),
-        };
-        const providers = [
-            ...(init?.providers || []),
-            {
-                provide: OPRA_KAFKA_MODULE_OPTIONS,
-                useValue: { ...init },
-            },
-            adapterProvider,
-            {
-                provide: opraKafkaNestjsAdapterToken,
-                useExisting: adapterProvider.provide,
-            },
-        ];
-        return {
-            global: true,
-            module: OpraKafkaCoreModule_1,
-            controllers: init.controllers,
-            providers,
-            imports: [...(init?.imports || [])],
-            exports: [...(init?.exports || []), adapterProvider],
-        };
-    }
-    async onModuleInit() {
-        await this.adapter.initialize(this.init);
-    }
-    async onApplicationBootstrap() {
-        await this.adapter.start();
-    }
-    async onApplicationShutdown() {
-        await this.adapter.stop();
-    }
-};
-OpraKafkaCoreModule = OpraKafkaCoreModule_1 = __decorate([
-    Module({}),
-    Global(),
-    __param(0, Inject(opraKafkaNestjsAdapterToken)),
-    __param(1, Inject(OPRA_KAFKA_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [OpraKafkaNestjsAdapter, Object])
-], OpraKafkaCoreModule);
-export { OpraKafkaCoreModule };

package/types/rpc/kafka/opra-kafka.module.d.ts

@@ -1,21 +0,0 @@
-import { type DynamicModule, Logger, type Type } from '@nestjs/common';
-import { ApiDocumentFactory } from '@opra/common';
-import { KafkaAdapter } from '@opra/kafka';
-import type { StrictOmit } from 'ts-gems';
-export declare namespace OpraKafkaModule {
-    interface Initiator extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers'>, Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'>, StrictOmit<KafkaAdapter.Config, 'document' | 'logger' | 'interceptors'> {
-        id?: any;
-        name: string;
-        description?: string;
-        types?: ApiDocumentFactory.InitArguments['types'];
-        logger?: Logger;
-        interceptors?: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor | Type<KafkaAdapter.IKafkaInterceptor>)[];
-    }
-}
-export declare class OpraKafkaModule {
-    /**
-     *
-     * @param init
-     */
-    static forRoot(init: OpraKafkaModule.Initiator): DynamicModule;
-}