@opra/nestjs 1.4.1 → 1.4.3

package/cjs/helpers/base-opra-nest-factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseOpraNestFactory = void 0;
+const constants_1 = require("@nestjs/common/constants");
+class BaseOpraNestFactory {
+    static copyDecoratorMetadata(target, ...source) {
+        for (const parent of source) {
+            const metadataKeys = Reflect.getOwnMetadataKeys(parent);
+            for (const key of metadataKeys) {
+                if (typeof key === 'string' && key.startsWith('opra.') && !Reflect.hasOwnMetadata(key, target)) {
+                    const metadata = Reflect.getMetadata(key, parent);
+                    Reflect.defineMetadata(key, metadata, target);
+                    continue;
+                }
+                if (key === constants_1.GUARDS_METADATA || key === constants_1.INTERCEPTORS_METADATA || key === constants_1.EXCEPTION_FILTERS_METADATA) {
+                    const m1 = Reflect.getMetadata(key, target) || [];
+                    const metadata = [...m1];
+                    const m2 = Reflect.getOwnMetadata(key, parent) || [];
+                    m2.forEach((t) => {
+                        if (!metadata.includes(t)) {
+                            metadata.push(t);
+                        }
+                    });
+                    Reflect.defineMetadata(key, metadata, target);
+                }
+            }
+        }
+    }
+}
+exports.BaseOpraNestFactory = BaseOpraNestFactory;

package/cjs/helpers/rpc-controller-factory.service.js

@@ -0,0 +1,123 @@
+"use strict";
+var RpcControllerFactory_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcControllerFactory = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const external_context_creator_1 = require("@nestjs/core/helpers/external-context-creator");
+const injector_1 = require("@nestjs/core/injector/injector");
+const internal_core_module_1 = require("@nestjs/core/injector/internal-core-module");
+const request_constants_1 = require("@nestjs/core/router/request/request-constants");
+const constants_1 = require("@nestjs/microservices/constants");
+const common_2 = require("@opra/common");
+const base_opra_nest_factory_js_1 = require("./base-opra-nest-factory.js");
+const rpc_params_factory_js_1 = require("./rpc-params.factory.js");
+let RpcControllerFactory = RpcControllerFactory_1 = class RpcControllerFactory extends base_opra_nest_factory_js_1.BaseOpraNestFactory {
+    constructor(modulesContainer, externalContextCreator) {
+        super();
+        this.modulesContainer = modulesContainer;
+        this.externalContextCreator = externalContextCreator;
+        this.paramsFactory = new rpc_params_factory_js_1.RpcParamsFactory();
+        this.injector = new injector_1.Injector();
+    }
+    wrapControllers() {
+        const out = [];
+        for (const { module, wrapper } of this.exploreControllers()) {
+            const instance = wrapper.instance;
+            const sourceClass = instance.constructor;
+            const metadata = Reflect.getMetadata(common_2.RPC_CONTROLLER_METADATA, sourceClass);
+            const isRequestScoped = !wrapper.isDependencyTreeStatic();
+            /** Create a new controller class */
+            const newClass = {
+                [sourceClass.name]: class extends sourceClass {
+                },
+            }[sourceClass.name];
+            /** Copy metadata keys from source class to new one */
+            RpcControllerFactory_1.copyDecoratorMetadata(newClass, sourceClass);
+            (0, common_1.Controller)()(newClass);
+            out.push(newClass);
+            if (metadata.operations) {
+                for (const operationName of Object.keys(metadata.operations)) {
+                    // const orgFn: Function = sourceClass.prototype[operationName];
+                    newClass.prototype[operationName] = this._createContextCallback(instance, wrapper, module, operationName, isRequestScoped, 'rpc');
+                    Reflect.defineMetadata(constants_1.PARAM_ARGS_METADATA, [core_1.REQUEST], instance.constructor, operationName);
+                }
+            }
+        }
+        return out;
+    }
+    _createContextCallback(instance, wrapper, moduleRef, methodName, isRequestScoped, contextType, options) {
+        const paramsFactory = this.paramsFactory;
+        if (isRequestScoped) {
+            return async (opraContext) => {
+                const contextId = (0, core_1.createContextId)();
+                Object.defineProperty(opraContext, request_constants_1.REQUEST_CONTEXT_ID, {
+                    value: contextId,
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                });
+                this.registerContextProvider(opraContext, contextId);
+                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
+                const contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], methodName, constants_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
+                return contextCallback(opraContext);
+            };
+        }
+        return this.externalContextCreator.create(instance, instance[methodName], methodName, constants_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+    }
+    registerContextProvider(request, contextId) {
+        if (!this._coreModuleRef) {
+            const coreModuleArray = [...this.modulesContainer.entries()]
+                .filter(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            ([_, { metatype }]) => metatype && metatype.name === internal_core_module_1.InternalCoreModule.name)
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                .map(([_, value]) => value);
+            this._coreModuleRef = coreModuleArray[0];
+        }
+        if (!this._coreModuleRef) {
+            return;
+        }
+        const wrapper = this._coreModuleRef.getProviderByKey(core_1.REQUEST);
+        wrapper.setInstanceByContextId(contextId, {
+            instance: request,
+            isResolved: true,
+        });
+    }
+    exploreControllers() {
+        const scannedModules = new Set();
+        const controllers = new Set();
+        const scanModule = (module) => {
+            if (scannedModules.has(module))
+                return;
+            scannedModules.add(module);
+            for (const mm of module.imports.values()) {
+                scanModule(mm);
+            }
+            for (const wrapper of module.controllers.values()) {
+                if (wrapper.instance &&
+                    typeof wrapper.instance === 'object' &&
+                    wrapper.instance.constructor &&
+                    Reflect.getMetadata(common_2.RPC_CONTROLLER_METADATA, wrapper.instance.constructor) &&
+                    !controllers.has(wrapper)) {
+                    controllers.add({ module, wrapper });
+                }
+                if (wrapper.host)
+                    scanModule(wrapper.host);
+            }
+        };
+        for (const module of this.modulesContainer.values()) {
+            scanModule(module);
+        }
+        return Array.from(controllers);
+    }
+};
+exports.RpcControllerFactory = RpcControllerFactory;
+exports.RpcControllerFactory = RpcControllerFactory = RpcControllerFactory_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)()),
+    tslib_1.__param(1, (0, common_1.Inject)()),
+    tslib_1.__metadata("design:paramtypes", [core_1.ModulesContainer,
+        external_context_creator_1.ExternalContextCreator])
+], RpcControllerFactory);

package/cjs/helpers/rpc-params.factory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcParamsFactory = void 0;
+class RpcParamsFactory {
+    exchangeKeyForValue(type, data, args) {
+        if (!args) {
+            return null;
+        }
+        args = Array.isArray(args) ? args : [];
+        return args[0];
+    }
+}
+exports.RpcParamsFactory = RpcParamsFactory;

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

@@ -5,11 +5,11 @@ const tslib_1 = require("tslib");
 const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const objects_1 = require("@jsopen/objects");
 const common_1 = require("@nestjs/common");
-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");
+const base_opra_nest_factory_js_1 = require("../helpers/base-opra-nest-factory.js");
 class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
     constructor(options) {
         super(options);
@@ -53,13 +53,14 @@ class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
         const metadata = Reflect.getMetadata(common_2.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 */
-        let metadataKeys;
-        OpraHttpNestjsAdapter.copyDecoratorMetadataToChild(newClass, parentTree);
+        base_opra_nest_factory_js_1.BaseOpraNestFactory.copyDecoratorMetadata(newClass, ...parentTree);
+        (0, common_1.Controller)()(newClass);
         const newPath = metadata.path ? node_path_1.default.join(currentPath, metadata.path) : currentPath;
         const adapter = this;
         // adapter.logger =
@@ -67,8 +68,8 @@ class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
         adapter.handler.onError = (context, error) => {
             throw error;
         };
-        (0, common_1.Controller)()(newClass);
         this.nestControllers.push(newClass);
+        let metadataKeys;
         if (metadata.operations) {
             for (const [k, v] of Object.entries(metadata.operations)) {
                 const operationHandler = sourceClass.prototype[k];
@@ -156,28 +157,5 @@ class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
             }
         }
     }
-    static copyDecoratorMetadataToChild(target, parentTree) {
-        for (const parent of parentTree) {
-            const metadataKeys = Reflect.getOwnMetadataKeys(parent);
-            for (const key of metadataKeys) {
-                if (typeof key === 'string' && key.startsWith('opra:') && !Reflect.hasOwnMetadata(key, target)) {
-                    const metadata = Reflect.getMetadata(key, parent);
-                    Reflect.defineMetadata(key, metadata, target);
-                    continue;
-                }
-                if (key === constants_js_1.GUARDS_METADATA || key === constants_js_1.INTERCEPTORS_METADATA || key === constants_js_1.EXCEPTION_FILTERS_METADATA) {
-                    const m1 = Reflect.getMetadata(key, target) || [];
-                    const metadata = [...m1];
-                    const m2 = Reflect.getOwnMetadata(key, parent) || [];
-                    m2.forEach((t) => {
-                        if (!metadata.includes(t)) {
-                            metadata.push(t);
-                        }
-                    });
-                    Reflect.defineMetadata(key, metadata, target);
-                }
-            }
-        }
-    }
 }
 exports.OpraHttpNestjsAdapter = OpraHttpNestjsAdapter;

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

@@ -6,13 +6,14 @@ 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 initialize_adapter_js_1 = require("./helpers/initialize-adapter.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(moduleRef, adapter, config) {
-        this.moduleRef = moduleRef;
+    constructor(controllerFactory, adapter, config) {
+        this.controllerFactory = controllerFactory;
         this.adapter = adapter;
         this.config = config;
     }
@@ -54,8 +55,21 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
         const token = moduleOptions.id || kafka_1.KafkaAdapter;
         const adapterProvider = {
             provide: token,
-            inject: [core_1.ModuleRef, constants_js_1.OPRA_KAFKA_MODULE_CONFIG],
-            useFactory: async (moduleRef, config) => {
+            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',
+                        controllers,
+                    },
+                });
                 const interceptors = moduleOptions.interceptors
                     ? moduleOptions.interceptors.map(x => {
                         if ((0, objects_1.isConstructor)(x)) {
@@ -68,7 +82,7 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
                         return x;
                     })
                     : undefined;
-                return new kafka_1.KafkaAdapter({ ...config, interceptors });
+                return new kafka_1.KafkaAdapter(document, { ...config, interceptors });
             },
         };
         return {
@@ -77,6 +91,7 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
             controllers: moduleOptions.controllers,
             providers: [
                 ...(moduleOptions?.providers || []),
+                rpc_controller_factory_service_js_1.RpcControllerFactory,
                 adapterProvider,
                 {
                     provide: opraKafkaNestjsAdapterToken,
@@ -87,15 +102,21 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
             exports: [...(moduleOptions?.exports || []), adapterProvider],
         };
     }
-    async onModuleInit() {
-        /** Check if not initialized before */
-        if (!this.adapter.document) {
-            await (0, initialize_adapter_js_1.initializeAdapter)(this.moduleRef, this.adapter, this.config);
+    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() {
-        if (this.adapter.document)
-            await this.adapter.start();
+        await this.adapter.start();
     }
     async onApplicationShutdown() {
         await this.adapter.close();
@@ -107,6 +128,6 @@ exports.OpraKafkaCoreModule = OpraKafkaCoreModule = OpraKafkaCoreModule_1 = tsli
     (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", [core_1.ModuleRef,
+    tslib_1.__metadata("design:paramtypes", [rpc_controller_factory_service_js_1.RpcControllerFactory,
         kafka_1.KafkaAdapter, Object])
 ], OpraKafkaCoreModule);

package/esm/helpers/base-opra-nest-factory.js

@@ -0,0 +1,26 @@
+import { EXCEPTION_FILTERS_METADATA, GUARDS_METADATA, INTERCEPTORS_METADATA } from '@nestjs/common/constants';
+export class BaseOpraNestFactory {
+    static copyDecoratorMetadata(target, ...source) {
+        for (const parent of source) {
+            const metadataKeys = Reflect.getOwnMetadataKeys(parent);
+            for (const key of metadataKeys) {
+                if (typeof key === 'string' && key.startsWith('opra.') && !Reflect.hasOwnMetadata(key, target)) {
+                    const metadata = Reflect.getMetadata(key, parent);
+                    Reflect.defineMetadata(key, metadata, target);
+                    continue;
+                }
+                if (key === GUARDS_METADATA || key === INTERCEPTORS_METADATA || key === EXCEPTION_FILTERS_METADATA) {
+                    const m1 = Reflect.getMetadata(key, target) || [];
+                    const metadata = [...m1];
+                    const m2 = Reflect.getOwnMetadata(key, parent) || [];
+                    m2.forEach((t) => {
+                        if (!metadata.includes(t)) {
+                            metadata.push(t);
+                        }
+                    });
+                    Reflect.defineMetadata(key, metadata, target);
+                }
+            }
+        }
+    }
+}

package/esm/helpers/rpc-controller-factory.service.js

@@ -0,0 +1,120 @@
+var RpcControllerFactory_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { Controller, Inject, Injectable } from '@nestjs/common';
+import { createContextId, ModulesContainer, REQUEST } from '@nestjs/core';
+import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-creator';
+import { Injector } from '@nestjs/core/injector/injector';
+import { InternalCoreModule } from '@nestjs/core/injector/internal-core-module';
+import { REQUEST_CONTEXT_ID } from '@nestjs/core/router/request/request-constants';
+import { PARAM_ARGS_METADATA } from '@nestjs/microservices/constants';
+import { RPC_CONTROLLER_METADATA } from '@opra/common';
+import { BaseOpraNestFactory } from './base-opra-nest-factory.js';
+import { RpcParamsFactory } from './rpc-params.factory.js';
+let RpcControllerFactory = RpcControllerFactory_1 = class RpcControllerFactory extends BaseOpraNestFactory {
+    constructor(modulesContainer, externalContextCreator) {
+        super();
+        this.modulesContainer = modulesContainer;
+        this.externalContextCreator = externalContextCreator;
+        this.paramsFactory = new RpcParamsFactory();
+        this.injector = new Injector();
+    }
+    wrapControllers() {
+        const out = [];
+        for (const { module, wrapper } of this.exploreControllers()) {
+            const instance = wrapper.instance;
+            const sourceClass = instance.constructor;
+            const metadata = Reflect.getMetadata(RPC_CONTROLLER_METADATA, sourceClass);
+            const isRequestScoped = !wrapper.isDependencyTreeStatic();
+            /** Create a new controller class */
+            const newClass = {
+                [sourceClass.name]: class extends sourceClass {
+                },
+            }[sourceClass.name];
+            /** Copy metadata keys from source class to new one */
+            RpcControllerFactory_1.copyDecoratorMetadata(newClass, sourceClass);
+            Controller()(newClass);
+            out.push(newClass);
+            if (metadata.operations) {
+                for (const operationName of Object.keys(metadata.operations)) {
+                    // const orgFn: Function = sourceClass.prototype[operationName];
+                    newClass.prototype[operationName] = this._createContextCallback(instance, wrapper, module, operationName, isRequestScoped, 'rpc');
+                    Reflect.defineMetadata(PARAM_ARGS_METADATA, [REQUEST], instance.constructor, operationName);
+                }
+            }
+        }
+        return out;
+    }
+    _createContextCallback(instance, wrapper, moduleRef, methodName, isRequestScoped, contextType, options) {
+        const paramsFactory = this.paramsFactory;
+        if (isRequestScoped) {
+            return async (opraContext) => {
+                const contextId = createContextId();
+                Object.defineProperty(opraContext, REQUEST_CONTEXT_ID, {
+                    value: contextId,
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                });
+                this.registerContextProvider(opraContext, contextId);
+                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
+                const contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
+                return contextCallback(opraContext);
+            };
+        }
+        return this.externalContextCreator.create(instance, instance[methodName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+    }
+    registerContextProvider(request, contextId) {
+        if (!this._coreModuleRef) {
+            const coreModuleArray = [...this.modulesContainer.entries()]
+                .filter(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            ([_, { metatype }]) => metatype && metatype.name === InternalCoreModule.name)
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                .map(([_, value]) => value);
+            this._coreModuleRef = coreModuleArray[0];
+        }
+        if (!this._coreModuleRef) {
+            return;
+        }
+        const wrapper = this._coreModuleRef.getProviderByKey(REQUEST);
+        wrapper.setInstanceByContextId(contextId, {
+            instance: request,
+            isResolved: true,
+        });
+    }
+    exploreControllers() {
+        const scannedModules = new Set();
+        const controllers = new Set();
+        const scanModule = (module) => {
+            if (scannedModules.has(module))
+                return;
+            scannedModules.add(module);
+            for (const mm of module.imports.values()) {
+                scanModule(mm);
+            }
+            for (const wrapper of module.controllers.values()) {
+                if (wrapper.instance &&
+                    typeof wrapper.instance === 'object' &&
+                    wrapper.instance.constructor &&
+                    Reflect.getMetadata(RPC_CONTROLLER_METADATA, wrapper.instance.constructor) &&
+                    !controllers.has(wrapper)) {
+                    controllers.add({ module, wrapper });
+                }
+                if (wrapper.host)
+                    scanModule(wrapper.host);
+            }
+        };
+        for (const module of this.modulesContainer.values()) {
+            scanModule(module);
+        }
+        return Array.from(controllers);
+    }
+};
+RpcControllerFactory = RpcControllerFactory_1 = __decorate([
+    Injectable(),
+    __param(0, Inject()),
+    __param(1, Inject()),
+    __metadata("design:paramtypes", [ModulesContainer,
+        ExternalContextCreator])
+], RpcControllerFactory);
+export { RpcControllerFactory };

package/esm/helpers/rpc-params.factory.js

@@ -0,0 +1,9 @@
+export class RpcParamsFactory {
+    exchangeKeyForValue(type, data, args) {
+        if (!args) {
+            return null;
+        }
+        args = Array.isArray(args) ? args : [];
+        return args[0];
+    }
+}

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

@@ -2,11 +2,11 @@ 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 { EXCEPTION_FILTERS_METADATA, GUARDS_METADATA, INTERCEPTORS_METADATA } from '@nestjs/common/constants.js';
 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);
@@ -50,13 +50,14 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
         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 */
-        let metadataKeys;
-        OpraHttpNestjsAdapter.copyDecoratorMetadataToChild(newClass, parentTree);
+        BaseOpraNestFactory.copyDecoratorMetadata(newClass, ...parentTree);
+        Controller()(newClass);
         const newPath = metadata.path ? nodePath.join(currentPath, metadata.path) : currentPath;
         const adapter = this;
         // adapter.logger =
@@ -64,8 +65,8 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
         adapter.handler.onError = (context, error) => {
             throw error;
         };
-        Controller()(newClass);
         this.nestControllers.push(newClass);
+        let metadataKeys;
         if (metadata.operations) {
             for (const [k, v] of Object.entries(metadata.operations)) {
                 const operationHandler = sourceClass.prototype[k];
@@ -153,27 +154,4 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
             }
         }
     }
-    static copyDecoratorMetadataToChild(target, parentTree) {
-        for (const parent of parentTree) {
-            const metadataKeys = Reflect.getOwnMetadataKeys(parent);
-            for (const key of metadataKeys) {
-                if (typeof key === 'string' && key.startsWith('opra:') && !Reflect.hasOwnMetadata(key, target)) {
-                    const metadata = Reflect.getMetadata(key, parent);
-                    Reflect.defineMetadata(key, metadata, target);
-                    continue;
-                }
-                if (key === GUARDS_METADATA || key === INTERCEPTORS_METADATA || key === EXCEPTION_FILTERS_METADATA) {
-                    const m1 = Reflect.getMetadata(key, target) || [];
-                    const metadata = [...m1];
-                    const m2 = Reflect.getOwnMetadata(key, parent) || [];
-                    m2.forEach((t) => {
-                        if (!metadata.includes(t)) {
-                            metadata.push(t);
-                        }
-                    });
-                    Reflect.defineMetadata(key, metadata, target);
-                }
-            }
-        }
-    }
 }

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

@@ -3,13 +3,14 @@ import { __decorate, __metadata, __param } from "tslib";
 import { isConstructor } from '@jsopen/objects';
 import { Global, Inject, Logger, Module, } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
+import { ApiDocumentFactory } from '@opra/common';
 import { KafkaAdapter } from '@opra/kafka';
 import { OPRA_KAFKA_MODULE_CONFIG } from '../constants.js';
-import { initializeAdapter } from './helpers/initialize-adapter.js';
+import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
 const opraKafkaNestjsAdapterToken = Symbol('OpraKafkaNestjsAdapter');
 let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
-    constructor(moduleRef, adapter, config) {
-        this.moduleRef = moduleRef;
+    constructor(controllerFactory, adapter, config) {
+        this.controllerFactory = controllerFactory;
         this.adapter = adapter;
         this.config = config;
     }
@@ -51,8 +52,21 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
         const token = moduleOptions.id || KafkaAdapter;
         const adapterProvider = {
             provide: token,
-            inject: [ModuleRef, OPRA_KAFKA_MODULE_CONFIG],
-            useFactory: async (moduleRef, config) => {
+            inject: [RpcControllerFactory, ModuleRef, OPRA_KAFKA_MODULE_CONFIG],
+            useFactory: async (controllerFactory, moduleRef, config) => {
+                const controllers = controllerFactory.exploreControllers().map(x => x.wrapper.instance.constructor);
+                const document = await ApiDocumentFactory.createDocument({
+                    info: config.info,
+                    types: config.types,
+                    references: config.references,
+                    api: {
+                        name: config.name,
+                        description: config.description,
+                        transport: 'rpc',
+                        platform: 'kafka',
+                        controllers,
+                    },
+                });
                 const interceptors = moduleOptions.interceptors
                     ? moduleOptions.interceptors.map(x => {
                         if (isConstructor(x)) {
@@ -65,7 +79,7 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
                         return x;
                     })
                     : undefined;
-                return new KafkaAdapter({ ...config, interceptors });
+                return new KafkaAdapter(document, { ...config, interceptors });
             },
         };
         return {
@@ -74,6 +88,7 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
             controllers: moduleOptions.controllers,
             providers: [
                 ...(moduleOptions?.providers || []),
+                RpcControllerFactory,
                 adapterProvider,
                 {
                     provide: opraKafkaNestjsAdapterToken,
@@ -84,15 +99,21 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
             exports: [...(moduleOptions?.exports || []), adapterProvider],
         };
     }
-    async onModuleInit() {
-        /** Check if not initialized before */
-        if (!this.adapter.document) {
-            await initializeAdapter(this.moduleRef, this.adapter, this.config);
+    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() {
-        if (this.adapter.document)
-            await this.adapter.start();
+        await this.adapter.start();
     }
     async onApplicationShutdown() {
         await this.adapter.close();
@@ -103,7 +124,7 @@ OpraKafkaCoreModule = OpraKafkaCoreModule_1 = __decorate([
     Global(),
     __param(1, Inject(opraKafkaNestjsAdapterToken)),
     __param(2, Inject(OPRA_KAFKA_MODULE_CONFIG)),
-    __metadata("design:paramtypes", [ModuleRef,
+    __metadata("design:paramtypes", [RpcControllerFactory,
         KafkaAdapter, Object])
 ], OpraKafkaCoreModule);
 export { OpraKafkaCoreModule };

package/package.json

@@ -1,27 +1,26 @@
 {
   "name": "@opra/nestjs",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
     "@jsopen/objects": "^1.5.0",
-    "@opra/common": "^1.4.1",
-    "@opra/core": "^1.4.1",
+    "@opra/common": "^1.4.3",
+    "@opra/core": "^1.4.3",
     "fast-tokenizer": "^1.7.0",
-    "lodash.head": "^4.0.1",
     "putil-promisify": "^1.10.1",
     "reflect-metadata": "^0.2.2",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@nestjs/common": "^10.4.12",
-    "@nestjs/core": "^10.4.12"
+    "@nestjs/common": "^10.4.13",
+    "@nestjs/core": "^10.4.13"
   },
   "optionalDependencies": {
-    "@nestjs/microservices": "^10.4.12",
-    "@opra/http": "^1.4.1",
-    "@opra/kafka": "^1.4.1"
+    "@nestjs/microservices": "^10.4.13",
+    "@opra/http": "^1.4.3",
+    "@opra/kafka": "^1.4.3"
   },
   "type": "module",
   "exports": {

package/types/helpers/base-opra-nest-factory.d.ts

@@ -0,0 +1,4 @@
+import type { Type } from '@nestjs/common';
+export declare class BaseOpraNestFactory {
+    static copyDecoratorMetadata(target: Type, ...source: Type[]): void;
+}

package/types/helpers/rpc-controller-factory.service.d.ts

@@ -0,0 +1,21 @@
+import { type Type } from '@nestjs/common';
+import { ModulesContainer } from '@nestjs/core';
+import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-creator';
+import type { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import type { Module } from '@nestjs/core/injector/module.js';
+import { BaseOpraNestFactory } from './base-opra-nest-factory.js';
+export declare class RpcControllerFactory extends BaseOpraNestFactory {
+    private readonly modulesContainer;
+    private readonly externalContextCreator;
+    private _coreModuleRef?;
+    private readonly paramsFactory;
+    private readonly injector;
+    constructor(modulesContainer: ModulesContainer, externalContextCreator: ExternalContextCreator);
+    wrapControllers(): Type[];
+    private _createContextCallback;
+    private registerContextProvider;
+    exploreControllers(): {
+        module: Module;
+        wrapper: InstanceWrapper;
+    }[];
+}

package/types/helpers/rpc-params.factory.d.ts

@@ -0,0 +1,4 @@
+import type { ParamsFactory } from '@nestjs/core/helpers/external-context-creator.js';
+export declare class RpcParamsFactory implements ParamsFactory {
+    exchangeKeyForValue(type: number, data: any, args: any): any;
+}

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

@@ -9,5 +9,4 @@ export declare class OpraHttpNestjsAdapter extends HttpAdapter {
     close(): Promise<void>;
     protected _addRootController(isPublic?: boolean): void;
     protected _addToNestControllers(sourceClass: Type, currentPath: string, parentTree: Type[]): void;
-    static copyDecoratorMetadataToChild(target: Type, parentTree: Type[]): void;
 }

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

@@ -1,16 +1,16 @@
 import { type DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
 import { KafkaAdapter } from '@opra/kafka';
+import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
 import type { OpraKafkaModule } from './opra-kafka.module.js';
 export declare class OpraKafkaCoreModule implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
-    protected moduleRef: ModuleRef;
+    private controllerFactory;
     protected adapter: KafkaAdapter;
     protected config: OpraKafkaModule.ApiConfig;
-    constructor(moduleRef: ModuleRef, adapter: KafkaAdapter, config: OpraKafkaModule.ApiConfig);
+    constructor(controllerFactory: RpcControllerFactory, adapter: KafkaAdapter, config: 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>;
+    onModuleInit(): any;
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
 }

package/cjs/kafka/helpers/initialize-adapter.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeAdapter = initializeAdapter;
-const common_1 = require("@opra/common");
-async function initializeAdapter(moduleRef, adapter, config) {
-    const controllers = scanControllers(moduleRef);
-    const document = await common_1.ApiDocumentFactory.createDocument({
-        info: config.info,
-        types: config.types,
-        references: config.references,
-        api: {
-            name: config.name,
-            description: config.description,
-            transport: 'rpc',
-            platform: 'kafka',
-            controllers,
-        },
-    });
-    await adapter.initialize(document);
-}
-function scanControllers(moduleRef) {
-    const container = moduleRef.container;
-    const modules = container.getModules();
-    const out = [];
-    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)
-                return;
-            const instance = {};
-            Object.setPrototypeOf(instance, wrapper.instance);
-            out.push(wrapper.instance);
-            // if (metadata.operations) {
-            //   for (const [k, _] of Object.keys(metadata.operations)) {
-            //     const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            //     //   const fn = instance[k];
-            //     //   instance[k] = fn;
-            //   }
-            // }
-        });
-    });
-    return out;
-}

package/esm/kafka/helpers/initialize-adapter.js

@@ -1,41 +0,0 @@
-import { ApiDocumentFactory, RPC_CONTROLLER_METADATA } from '@opra/common';
-export async function initializeAdapter(moduleRef, adapter, config) {
-    const controllers = scanControllers(moduleRef);
-    const document = await ApiDocumentFactory.createDocument({
-        info: config.info,
-        types: config.types,
-        references: config.references,
-        api: {
-            name: config.name,
-            description: config.description,
-            transport: 'rpc',
-            platform: 'kafka',
-            controllers,
-        },
-    });
-    await adapter.initialize(document);
-}
-function scanControllers(moduleRef) {
-    const container = moduleRef.container;
-    const modules = container.getModules();
-    const out = [];
-    modules.forEach(({ controllers }) => {
-        controllers.forEach(wrapper => {
-            const ctor = Object.getPrototypeOf(wrapper.instance).constructor;
-            const metadata = Reflect.getMetadata(RPC_CONTROLLER_METADATA, ctor);
-            if (!metadata)
-                return;
-            const instance = {};
-            Object.setPrototypeOf(instance, wrapper.instance);
-            out.push(wrapper.instance);
-            // if (metadata.operations) {
-            //   for (const [k, _] of Object.keys(metadata.operations)) {
-            //     const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            //     //   const fn = instance[k];
-            //     //   instance[k] = fn;
-            //   }
-            // }
-        });
-    });
-    return out;
-}

package/types/kafka/helpers/initialize-adapter.d.ts

@@ -1,4 +0,0 @@
-import { ModuleRef } from '@nestjs/core';
-import { KafkaAdapter } from '@opra/kafka';
-import type { OpraKafkaModule } from '../opra-kafka.module.js';
-export declare function initializeAdapter(moduleRef: ModuleRef, adapter: KafkaAdapter, config: OpraKafkaModule.ApiConfig): Promise<void>;