@opra/nestjs 1.9.3 → 1.10.0

package/cjs/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPRA_KAFKA_MODULE_CONFIG = exports.OPRA_HTTP_API_CONFIG = exports.IS_PUBLIC_KEY = void 0;
+exports.OPRA_RMQ_MODULE_CONFIG = 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_API_CONFIG = 'OPRA_HTTP_API_CONFIG';
 exports.OPRA_KAFKA_MODULE_CONFIG = 'OPRA_KAFKA_MODULE_CONFIG';
+exports.OPRA_RMQ_MODULE_CONFIG = 'OPRA_RMQ_MODULE_CONFIG';

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseOpraNestFactory = void 0;
-const constants_1 = require("@nestjs/common/constants");
+const constants_js_1 = require("@nestjs/common/constants.js");
 class BaseOpraNestFactory {
     static copyDecoratorMetadata(target, ...source) {
         for (const parent of source) {
@@ -14,9 +14,9 @@ class BaseOpraNestFactory {
                     Reflect.defineMetadata(key, metadata, target);
                     continue;
                 }
-                if (key === constants_1.GUARDS_METADATA ||
-                    key === constants_1.INTERCEPTORS_METADATA ||
-                    key === constants_1.EXCEPTION_FILTERS_METADATA) {
+                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) || [];

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

@@ -5,11 +5,11 @@ 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 external_context_creator_js_1 = require("@nestjs/core/helpers/external-context-creator.js");
+const injector_js_1 = require("@nestjs/core/injector/injector.js");
+const index_js_1 = require("@nestjs/core/injector/internal-core-module/index.js");
+const request_constants_js_1 = require("@nestjs/core/router/request/request-constants.js");
+const constants_js_1 = require("@nestjs/microservices/constants.js");
 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");
@@ -19,7 +19,7 @@ let RpcControllerFactory = RpcControllerFactory_1 = class RpcControllerFactory e
         this.modulesContainer = modulesContainer;
         this.externalContextCreator = externalContextCreator;
         this.paramsFactory = new rpc_params_factory_js_1.RpcParamsFactory();
-        this.injector = new injector_1.Injector();
+        this.injector = new injector_js_1.Injector();
     }
     wrapControllers() {
         const out = [];
@@ -41,7 +41,7 @@ let RpcControllerFactory = RpcControllerFactory_1 = class RpcControllerFactory e
                 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);
+                    Reflect.defineMetadata(constants_js_1.PARAM_ARGS_METADATA, [core_1.REQUEST], instance.constructor, operationName);
                 }
             }
         }
@@ -52,7 +52,7 @@ let RpcControllerFactory = RpcControllerFactory_1 = class RpcControllerFactory e
         if (isRequestScoped) {
             return async (opraContext) => {
                 const contextId = (0, core_1.createContextId)();
-                Object.defineProperty(opraContext, request_constants_1.REQUEST_CONTEXT_ID, {
+                Object.defineProperty(opraContext, request_constants_js_1.REQUEST_CONTEXT_ID, {
                     value: contextId,
                     enumerable: false,
                     configurable: false,
@@ -60,18 +60,18 @@ let RpcControllerFactory = RpcControllerFactory_1 = class RpcControllerFactory e
                 });
                 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);
+                const contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], methodName, constants_js_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);
+        return this.externalContextCreator.create(instance, instance[methodName], methodName, constants_js_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)
+            ([_, { metatype }]) => metatype && metatype.name === index_js_1.InternalCoreModule.name)
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 .map(([_, value]) => value);
             this._coreModuleRef = coreModuleArray[0];
@@ -119,5 +119,5 @@ exports.RpcControllerFactory = RpcControllerFactory = RpcControllerFactory_1 = t
     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])
+        external_context_creator_js_1.ExternalContextCreator])
 ], RpcControllerFactory);

package/cjs/index.js

@@ -8,3 +8,4 @@ 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("./kafka/opra-kafka.module.js"), exports);
+tslib_1.__exportStar(require("./rabbitmq/opra-rabbitmq.module.js"), exports);

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

@@ -68,7 +68,7 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
                         name: config.name,
                         description: config.description,
                         transport: 'rpc',
-                        platform: 'kafka',
+                        platform: kafka_1.KafkaAdapter.PlatformName,
                         controllers,
                     },
                 });

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

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

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

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

package/esm/constants.js

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

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

@@ -1,4 +1,4 @@
-import { EXCEPTION_FILTERS_METADATA, GUARDS_METADATA, INTERCEPTORS_METADATA, } from '@nestjs/common/constants';
+import { EXCEPTION_FILTERS_METADATA, GUARDS_METADATA, INTERCEPTORS_METADATA, } from '@nestjs/common/constants.js';
 export class BaseOpraNestFactory {
     static copyDecoratorMetadata(target, ...source) {
         for (const parent of source) {

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

@@ -2,11 +2,11 @@ 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 { ExternalContextCreator, } from '@nestjs/core/helpers/external-context-creator.js';
+import { Injector } from '@nestjs/core/injector/injector.js';
+import { InternalCoreModule } from '@nestjs/core/injector/internal-core-module/index.js';
+import { REQUEST_CONTEXT_ID } from '@nestjs/core/router/request/request-constants.js';
+import { PARAM_ARGS_METADATA } from '@nestjs/microservices/constants.js';
 import { RPC_CONTROLLER_METADATA } from '@opra/common';
 import { BaseOpraNestFactory } from './base-opra-nest-factory.js';
 import { RpcParamsFactory } from './rpc-params.factory.js';

package/esm/index.js

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

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

@@ -65,7 +65,7 @@ let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
                         name: config.name,
                         description: config.description,
                         transport: 'rpc',
-                        platform: 'kafka',
+                        platform: KafkaAdapter.PlatformName,
                         controllers,
                     },
                 });

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

@@ -0,0 +1,134 @@
+var OpraRabbitmqCoreModule_1;
+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 { RabbitmqAdapter } from '@opra/rabbitmq';
+import { OPRA_RMQ_MODULE_CONFIG } from '../constants.js';
+import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
+const opraRabbitmqNestjsAdapterToken = Symbol('OpraRabbitmqNestjsAdapter');
+let OpraRabbitmqCoreModule = OpraRabbitmqCoreModule_1 = class OpraRabbitmqCoreModule {
+    constructor(controllerFactory, adapter, config) {
+        this.controllerFactory = controllerFactory;
+        this.adapter = adapter;
+        this.config = config;
+    }
+    static forRoot(moduleOptions) {
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: OPRA_RMQ_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_RMQ_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 || RabbitmqAdapter;
+        const adapterProvider = {
+            provide: token,
+            inject: [RpcControllerFactory, ModuleRef, OPRA_RMQ_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: RabbitmqAdapter.PlatformName,
+                        controllers,
+                    },
+                });
+                const interceptors = moduleOptions.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;
+                    })
+                    : undefined;
+                return new RabbitmqAdapter(document, { ...config, interceptors });
+            },
+        };
+        return {
+            global: moduleOptions.global,
+            module: OpraRabbitmqCoreModule_1,
+            controllers: moduleOptions.controllers,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                RpcControllerFactory,
+                adapterProvider,
+                {
+                    provide: opraRabbitmqNestjsAdapterToken,
+                    useExisting: token,
+                },
+            ],
+            imports: [...(moduleOptions?.imports || [])],
+            exports: [...(moduleOptions?.exports || []), adapterProvider],
+        };
+    }
+    onModuleInit() {
+        /** NestJS initialize controller instances on init stage.
+         * So we should update instance properties */
+        const rpcApi = this.adapter.document.rpcApi;
+        const controllers = Array.from(rpcApi.controllers.values());
+        for (const { wrapper } of this.controllerFactory
+            .exploreControllers()
+            .values()) {
+            const ctor = wrapper.instance.constructor;
+            const controller = controllers.find(x => x.ctor === ctor);
+            if (controller) {
+                controller.instance = wrapper.instance;
+            }
+        }
+    }
+    async onApplicationBootstrap() {
+        await this.adapter.start();
+    }
+    async onApplicationShutdown() {
+        await this.adapter.close();
+    }
+};
+OpraRabbitmqCoreModule = OpraRabbitmqCoreModule_1 = __decorate([
+    Module({}),
+    Global(),
+    __param(1, Inject(opraRabbitmqNestjsAdapterToken)),
+    __param(2, Inject(OPRA_RMQ_MODULE_CONFIG)),
+    __metadata("design:paramtypes", [RpcControllerFactory,
+        RabbitmqAdapter, Object])
+], OpraRabbitmqCoreModule);
+export { OpraRabbitmqCoreModule };

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

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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@opra/nestjs",
-  "version": "1.9.3",
+  "version": "1.10.0",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
     "@jsopen/objects": "^1.5.0",
-    "@opra/common": "^1.9.3",
-    "@opra/core": "^1.9.3",
+    "@opra/common": "^1.10.0",
+    "@opra/core": "^1.10.0",
     "fast-tokenizer": "^1.7.0",
     "putil-promisify": "^1.10.1",
     "reflect-metadata": "^0.2.2",
@@ -19,8 +19,10 @@
   },
   "optionalDependencies": {
     "@nestjs/microservices": "^10.0.0 || ^11.0.0",
-    "@opra/http": "^1.9.3",
-    "@opra/kafka": "^1.9.3"
+    "@opra/http": "^1.10.0",
+    "@opra/kafka": "^1.10.0",
+    "amqplib": ">=0.10.0 <1.0.0",
+    "kafkajs": "^2.2.4"
   },
   "type": "module",
   "exports": {

package/types/constants.d.ts

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

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

@@ -1,7 +1,7 @@
 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 { ExternalContextCreator } from '@nestjs/core/helpers/external-context-creator.js';
+import type { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper.js';
 import type { Module } from '@nestjs/core/injector/module.js';
 import { BaseOpraNestFactory } from './base-opra-nest-factory.js';
 export declare class RpcControllerFactory extends BaseOpraNestFactory {

package/types/index.d.cts

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

package/types/index.d.ts

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

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

@@ -1,6 +1,6 @@
 import { type DynamicModule, Logger, type Type } from '@nestjs/common';
 import { ApiDocumentFactory } from '@opra/common';
-import { KafkaAdapter } from '@opra/kafka';
+import type { KafkaAdapter } from '@opra/kafka';
 export declare namespace OpraKafkaModule {
     export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
     }

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

@@ -0,0 +1,16 @@
+import { type DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
+import { RabbitmqAdapter } from '@opra/rabbitmq';
+import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
+import type { OpraRabbitmqModule } from './opra-rabbitmq.module.js';
+export declare class OpraRabbitmqCoreModule implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
+    private controllerFactory;
+    protected adapter: RabbitmqAdapter;
+    protected config: OpraRabbitmqModule.ApiConfig;
+    constructor(controllerFactory: RpcControllerFactory, adapter: RabbitmqAdapter, config: OpraRabbitmqModule.ApiConfig);
+    static forRoot(moduleOptions: OpraRabbitmqModule.ModuleOptions): DynamicModule;
+    static forRootAsync(moduleOptions: OpraRabbitmqModule.AsyncModuleOptions): DynamicModule;
+    protected static _getDynamicModule(moduleOptions: OpraRabbitmqModule.ModuleOptions | OpraRabbitmqModule.AsyncModuleOptions): DynamicModule;
+    onModuleInit(): any;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { type DynamicModule, Logger, type Type } from '@nestjs/common';
+import { ApiDocumentFactory } from '@opra/common';
+import type { RabbitmqAdapter } from '@opra/rabbitmq';
+export declare namespace OpraRabbitmqModule {
+    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?: (RabbitmqAdapter.InterceptorFunction | RabbitmqAdapter.IRabbitmqInterceptor | Type<RabbitmqAdapter.IRabbitmqInterceptor>)[];
+    }
+    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
+        connection: RabbitmqAdapter.Config['connection'];
+        queues?: RabbitmqAdapter.Config['queues'];
+        logExtra?: RabbitmqAdapter.Config['logExtra'];
+        defaults?: RabbitmqAdapter.Config['defaults'];
+        name: string;
+        description?: string;
+        scope?: string;
+        logger?: Logger;
+    }
+    export {};
+}
+export declare class OpraRabbitmqModule {
+    /**
+     *
+     * @param options
+     */
+    static forRoot(options: OpraRabbitmqModule.ModuleOptions): DynamicModule;
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options: OpraRabbitmqModule.AsyncModuleOptions): DynamicModule;
+}