@opra/rabbitmq 1.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @opra/core
+
+OPRA schema package.

package/cjs/augmentation/opra-common.augmentation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@opra/core");
+const common_1 = require("@opra/common");
+const constants_js_1 = require("../constants.js");
+/** Implementation **/
+common_1.classes.RpcOperationDecoratorFactory.augment((decorator, decoratorChain) => {
+    decorator.RabbitMQ = (config) => {
+        decoratorChain.push((_, target, propertyKey) => {
+            if (typeof config === 'function') {
+                Reflect.defineMetadata(constants_js_1.RMQ_OPERATION_METADATA_RESOLVER, config, target, propertyKey);
+            }
+            else {
+                Reflect.defineMetadata(constants_js_1.RMQ_OPERATION_METADATA, { ...config }, target, propertyKey);
+            }
+        });
+        return decorator;
+    };
+});

package/cjs/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RMQ_OPERATION_METADATA_RESOLVER = exports.RMQ_OPERATION_METADATA = exports.RMQ_DEFAULT_GROUP = void 0;
+exports.RMQ_DEFAULT_GROUP = 'default';
+exports.RMQ_OPERATION_METADATA = 'RMQ_OPERATION_METADATA';
+exports.RMQ_OPERATION_METADATA_RESOLVER = 'RMQ_OPERATION_METADATA_RESOLVER';

package/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./augmentation/opra-common.augmentation.js");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./rabbitmq-adapter.js"), exports);
+tslib_1.__exportStar(require("./rabbitmq-context.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/rabbitmq-adapter.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqAdapter = void 0;
+const tslib_1 = require("tslib");
+const node_zlib_1 = tslib_1.__importDefault(require("node:zlib"));
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+const core_1 = require("@opra/core");
+const amqplib_1 = tslib_1.__importDefault(require("amqplib"));
+const content_type_1 = require("content-type");
+const iconv_lite_1 = tslib_1.__importDefault(require("iconv-lite"));
+const util_1 = require("util");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("./constants.js");
+const rabbitmq_context_js_1 = require("./rabbitmq-context.js");
+const gunzipAsync = (0, util_1.promisify)(node_zlib_1.default.gunzip);
+const deflateAsync = (0, util_1.promisify)(node_zlib_1.default.deflate);
+const inflateAsync = (0, util_1.promisify)(node_zlib_1.default.inflate);
+const brotliAsync = (0, util_1.promisify)(node_zlib_1.default.brotliCompress);
+const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
+const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+const noOp = () => undefined;
+/**
+ *
+ * @class RabbitmqAdapter
+ */
+class RabbitmqAdapter extends core_1.PlatformAdapter {
+    /**
+     *
+     * @param document
+     * @param config
+     * @constructor
+     */
+    constructor(document, config) {
+        super(config);
+        this._controllerInstances = new Map();
+        this._connections = [];
+        this._status = 'idle';
+        this.protocol = 'rpc';
+        this.platform = RabbitmqAdapter.PlatformName;
+        this._document = document;
+        this._config = config;
+        if (!(this.document.api instanceof common_1.RpcApi &&
+            this.document.api.platform === RabbitmqAdapter.PlatformName)) {
+            throw new TypeError(`The document doesn't expose a RabbitMQ Api`);
+        }
+        // this._config = config;
+        this.interceptors = [...(config.interceptors || [])];
+        globalErrorTypes.forEach(type => {
+            process.on(type, e => {
+                this._emitError(e);
+                return this.close();
+            });
+        });
+        signalTraps.forEach(type => {
+            process.once(type, () => this.close());
+        });
+    }
+    get api() {
+        return this.document.rpcApi;
+    }
+    get scope() {
+        return this._config.scope;
+    }
+    get status() {
+        return this._status;
+    }
+    /**
+     * Starts the service
+     */
+    async start() {
+        if (this.status !== 'idle')
+            return;
+        this._status = 'starting';
+        const handlerArgs = [];
+        try {
+            /** Initialize consumers */
+            for (const controller of this.document.rpcApi.controllers.values()) {
+                let instance = controller.instance;
+                if (!instance && controller.ctor)
+                    instance = new controller.ctor();
+                if (!instance)
+                    continue;
+                this._controllerInstances.set(controller, instance);
+                /** Build HandlerData array */
+                for (const operation of controller.operations.values()) {
+                    const operationConfig = await this._getOperationConfig(controller, instance, operation);
+                    if (!operationConfig)
+                        continue;
+                    const args = {
+                        consumer: null,
+                        controller,
+                        instance,
+                        operation,
+                        operationConfig,
+                        handler: null,
+                        topics: (Array.isArray(operation.channel)
+                            ? operation.channel
+                            : [operation.channel]).map(String),
+                    };
+                    this._createHandler(args);
+                    handlerArgs.push(args);
+                }
+            }
+            /** Connect to server */
+            for (const connectionOptions of this._config.connection) {
+                const connection = await amqplib_1.default.connect(connectionOptions);
+                this._connections.push(connection);
+                const hostname = typeof connectionOptions === 'object'
+                    ? connectionOptions.hostname
+                    : connectionOptions;
+                this.logger?.info?.(`Connected to ${hostname}`);
+                /** Subscribe to channels */
+                for (const args of handlerArgs) {
+                    /** Create channel per operation */
+                    const channel = await connection.createChannel();
+                    for (const topic of args.topics) {
+                        const opts = this._config.queues?.[topic];
+                        if (opts)
+                            await channel.assertQueue(topic, opts);
+                    }
+                    for (const topic of args.topics) {
+                        await channel.assertQueue(topic);
+                        await channel
+                            .consume(topic, async (msg) => {
+                            if (!msg)
+                                return;
+                            await this.emitAsync('message', msg).catch(() => undefined);
+                            try {
+                                await args.handler(msg);
+                                // channel.ack(msg);
+                            }
+                            catch (e) {
+                                this._emitError(e);
+                            }
+                            await this.emitAsync('message-finish', msg);
+                        }, 
+                        /** Consume options */
+                        args.operationConfig.consumer)
+                            .catch(e => {
+                            this._emitError(e);
+                            throw e;
+                        });
+                        this.logger?.info?.(`Subscribed to topic${args.topics.length > 1 ? 's' : ''} "${args.topics}"`);
+                    }
+                }
+            }
+            this._status = 'started';
+        }
+        catch (e) {
+            await this.close();
+            throw e;
+        }
+    }
+    // protected async _connect() {
+    //   if (!this._connection)
+    //     this._connection = await amqplib.connect(this._config.connection);
+    //   return this._connection;
+    // }
+    /**
+     * Closes all connections and stops the service
+     */
+    async close() {
+        await Promise.all(this._connections.map(c => c.close()));
+        this._connections = [];
+        this._controllerInstances.clear();
+        this._status = 'idle';
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+    /**
+     *
+     * @param controller
+     * @param instance
+     * @param operation
+     * @protected
+     */
+    async _getOperationConfig(controller, instance, operation) {
+        if (typeof instance[operation.name] !== 'function')
+            return;
+        const proto = controller.ctor?.prototype || Object.getPrototypeOf(instance);
+        if (Reflect.hasMetadata(common_1.RPC_CONTROLLER_METADATA, proto, operation.name))
+            return;
+        const operationConfig = {
+            consumer: {
+                noAck: true,
+            },
+        };
+        if (this._config.defaults) {
+            if (this._config.defaults.consumer) {
+                Object.assign(operationConfig.consumer, this._config.defaults.consumer);
+            }
+        }
+        let metadata = Reflect.getMetadata(constants_js_1.RMQ_OPERATION_METADATA, proto, operation.name);
+        if (!metadata) {
+            const configResolver = Reflect.getMetadata(constants_js_1.RMQ_OPERATION_METADATA_RESOLVER, proto, operation.name);
+            if (configResolver) {
+                metadata = await configResolver();
+            }
+        }
+        if (metadata) {
+            if (typeof metadata.consumer === 'object') {
+                Object.assign(operationConfig.consumer, metadata.consumer);
+            }
+        }
+        return operationConfig;
+    }
+    /**
+     *
+     * @param args
+     * @protected
+     */
+    _createHandler(args) {
+        const { controller, instance, operation } = args;
+        /** Prepare parsers */
+        const decodePayload = operation.payloadType?.generateCodec('decode', {
+            scope: this.scope,
+            ignoreWriteonlyFields: true,
+        });
+        operation.headers.forEach(header => {
+            let decode = this[core_1.kAssetCache].get(header, 'decode');
+            if (!decode) {
+                decode =
+                    header.type?.generateCodec('decode', {
+                        scope: this.scope,
+                        ignoreReadonlyFields: true,
+                    }) || valgen_1.vg.isAny();
+                this[core_1.kAssetCache].set(header, 'decode', decode);
+            }
+        });
+        args.handler = async (message) => {
+            if (!message)
+                return;
+            const operationHandler = instance[operation.name];
+            let content;
+            const headers = {};
+            try {
+                /** Parse and decode `payload` */
+                content = await this._parseContent(message);
+                if (content && decodePayload) {
+                    if (Buffer.isBuffer(content))
+                        content = content.toString('utf-8');
+                    content = decodePayload(content);
+                }
+                // message.properties.
+                /** Parse and decode `headers` */
+                if (message.properties.headers) {
+                    for (const [k, v] of Object.entries(message.properties.headers)) {
+                        const header = operation.findHeader(k);
+                        const decode = this[core_1.kAssetCache].get(header, 'decode') || valgen_1.vg.isAny();
+                        headers[k] = decode(Buffer.isBuffer(v) ? v.toString() : v);
+                    }
+                }
+            }
+            catch (e) {
+                this._emitError(e);
+                return;
+            }
+            /** Create context */
+            const context = new rabbitmq_context_js_1.RabbitmqContext({
+                adapter: this,
+                platform: this.platform,
+                controller,
+                controllerInstance: instance,
+                operation,
+                operationHandler,
+                fields: message.fields,
+                properties: message.properties,
+                content,
+                headers,
+            });
+            await this.emitAsync('before-execute', context);
+            try {
+                /** Call operation handler */
+                const result = await operationHandler.call(instance, context);
+                await this.emitAsync('after-execute', context, result);
+            }
+            catch (e) {
+                this._emitError(e, context);
+            }
+        };
+    }
+    async _parseContent(msg) {
+        if (!msg.content?.length)
+            return;
+        let content = msg.content;
+        if (msg.properties.contentEncoding) {
+            switch (msg.properties.contentEncoding) {
+                case 'gzip':
+                case 'x-gzip': {
+                    content = await gunzipAsync(content);
+                    break;
+                }
+                case 'deflate':
+                case 'x-deflate': {
+                    content = await deflateAsync(content);
+                    break;
+                }
+                case 'inflate':
+                case 'x-inflate': {
+                    content = await inflateAsync(content);
+                    break;
+                }
+                case 'br': {
+                    content = await brotliAsync(content);
+                    break;
+                }
+                case 'base64': {
+                    content = content.toString('base64');
+                    break;
+                }
+            }
+        }
+        const mediaType = msg.properties.contentType &&
+            (0, content_type_1.parse)(msg.properties.contentType || '');
+        let charset = (mediaType?.parameters.charset || '').toLowerCase();
+        if (!charset && type_is_1.default.is(mediaType?.type, ['json', 'xml', 'txt']))
+            charset = 'utf-8';
+        if (charset) {
+            content = iconv_lite_1.default.decode(content, charset);
+            if (type_is_1.default.is(mediaType.type, ['json']))
+                return JSON.parse(content);
+        }
+        return content;
+    }
+    _emitError(error, context) {
+        Promise.resolve()
+            .then(async () => {
+            const logger = this.logger;
+            if (context) {
+                if (!context.errors.length)
+                    context.errors.push(error);
+                context.errors = this._wrapExceptions(context.errors);
+                if (context.listenerCount('error')) {
+                    await this.emitAsync('error', context.errors[0], context);
+                }
+                if (logger?.error) {
+                    context.errors.forEach(err => logger.error(err));
+                }
+                return;
+            }
+            this.logger?.error(error);
+            if (this.listenerCount('error'))
+                this.emit('error', error);
+        })
+            .catch(noOp);
+    }
+    _wrapExceptions(exceptions) {
+        const wrappedErrors = exceptions.map(e => e instanceof common_1.OpraException ? e : new common_1.OpraException(e));
+        if (!wrappedErrors.length)
+            wrappedErrors.push(new common_1.OpraException('Internal Server Error'));
+        return wrappedErrors;
+    }
+}
+exports.RabbitmqAdapter = RabbitmqAdapter;
+RabbitmqAdapter.PlatformName = 'rabbitmq';

package/cjs/rabbitmq-context.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqContext = void 0;
+const core_1 = require("@opra/core");
+/**
+ * RabbitmqContext class provides the context for handling RabbitMQ messages.
+ * It extends the ExecutionContext and implements the AsyncEventEmitter.
+ */
+class RabbitmqContext extends core_1.ExecutionContext {
+    /**
+     * Constructor
+     * @param init the context options
+     */
+    constructor(init) {
+        super({
+            ...init,
+            document: init.adapter.document,
+            documentNode: init.controller?.node,
+            protocol: 'rpc',
+        });
+        this.adapter = init.adapter;
+        this.platform = init.adapter.platform;
+        this.protocol = 'rpc';
+        if (init.controller)
+            this.controller = init.controller;
+        if (init.controllerInstance)
+            this.controllerInstance = init.controllerInstance;
+        if (init.operation)
+            this.operation = init.operation;
+        if (init.operationHandler)
+            this.operationHandler = init.operationHandler;
+        this.fields = init.fields;
+        this.properties = init.properties;
+        this.headers = init.headers || {};
+        this.content = init.content;
+    }
+}
+exports.RabbitmqContext = RabbitmqContext;

package/esm/augmentation/opra-common.augmentation.js

@@ -0,0 +1,17 @@
+import '@opra/core';
+import { classes } from '@opra/common';
+import { RMQ_OPERATION_METADATA, RMQ_OPERATION_METADATA_RESOLVER, } from '../constants.js';
+/** Implementation **/
+classes.RpcOperationDecoratorFactory.augment((decorator, decoratorChain) => {
+    decorator.RabbitMQ = (config) => {
+        decoratorChain.push((_, target, propertyKey) => {
+            if (typeof config === 'function') {
+                Reflect.defineMetadata(RMQ_OPERATION_METADATA_RESOLVER, config, target, propertyKey);
+            }
+            else {
+                Reflect.defineMetadata(RMQ_OPERATION_METADATA, { ...config }, target, propertyKey);
+            }
+        });
+        return decorator;
+    };
+});

package/esm/constants.js

@@ -0,0 +1,3 @@
+export const RMQ_DEFAULT_GROUP = 'default';
+export const RMQ_OPERATION_METADATA = 'RMQ_OPERATION_METADATA';
+export const RMQ_OPERATION_METADATA_RESOLVER = 'RMQ_OPERATION_METADATA_RESOLVER';

package/esm/index.js

@@ -0,0 +1,4 @@
+import './augmentation/opra-common.augmentation.js';
+export * from './constants.js';
+export * from './rabbitmq-adapter.js';
+export * from './rabbitmq-context.js';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/rabbitmq-adapter.js

@@ -0,0 +1,353 @@
+import zlib from 'node:zlib';
+import typeIs from '@browsery/type-is';
+import { OpraException, RPC_CONTROLLER_METADATA, RpcApi, } from '@opra/common';
+import { kAssetCache, PlatformAdapter } from '@opra/core';
+import amqplib from 'amqplib';
+import { parse as parseContentType } from 'content-type';
+import iconv from 'iconv-lite';
+import { promisify } from 'util';
+import { vg } from 'valgen';
+import { RMQ_OPERATION_METADATA, RMQ_OPERATION_METADATA_RESOLVER, } from './constants.js';
+import { RabbitmqContext } from './rabbitmq-context.js';
+const gunzipAsync = promisify(zlib.gunzip);
+const deflateAsync = promisify(zlib.deflate);
+const inflateAsync = promisify(zlib.inflate);
+const brotliAsync = promisify(zlib.brotliCompress);
+const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
+const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+const noOp = () => undefined;
+/**
+ *
+ * @class RabbitmqAdapter
+ */
+export class RabbitmqAdapter extends PlatformAdapter {
+    /**
+     *
+     * @param document
+     * @param config
+     * @constructor
+     */
+    constructor(document, config) {
+        super(config);
+        this._controllerInstances = new Map();
+        this._connections = [];
+        this._status = 'idle';
+        this.protocol = 'rpc';
+        this.platform = RabbitmqAdapter.PlatformName;
+        this._document = document;
+        this._config = config;
+        if (!(this.document.api instanceof RpcApi &&
+            this.document.api.platform === RabbitmqAdapter.PlatformName)) {
+            throw new TypeError(`The document doesn't expose a RabbitMQ Api`);
+        }
+        // this._config = config;
+        this.interceptors = [...(config.interceptors || [])];
+        globalErrorTypes.forEach(type => {
+            process.on(type, e => {
+                this._emitError(e);
+                return this.close();
+            });
+        });
+        signalTraps.forEach(type => {
+            process.once(type, () => this.close());
+        });
+    }
+    get api() {
+        return this.document.rpcApi;
+    }
+    get scope() {
+        return this._config.scope;
+    }
+    get status() {
+        return this._status;
+    }
+    /**
+     * Starts the service
+     */
+    async start() {
+        if (this.status !== 'idle')
+            return;
+        this._status = 'starting';
+        const handlerArgs = [];
+        try {
+            /** Initialize consumers */
+            for (const controller of this.document.rpcApi.controllers.values()) {
+                let instance = controller.instance;
+                if (!instance && controller.ctor)
+                    instance = new controller.ctor();
+                if (!instance)
+                    continue;
+                this._controllerInstances.set(controller, instance);
+                /** Build HandlerData array */
+                for (const operation of controller.operations.values()) {
+                    const operationConfig = await this._getOperationConfig(controller, instance, operation);
+                    if (!operationConfig)
+                        continue;
+                    const args = {
+                        consumer: null,
+                        controller,
+                        instance,
+                        operation,
+                        operationConfig,
+                        handler: null,
+                        topics: (Array.isArray(operation.channel)
+                            ? operation.channel
+                            : [operation.channel]).map(String),
+                    };
+                    this._createHandler(args);
+                    handlerArgs.push(args);
+                }
+            }
+            /** Connect to server */
+            for (const connectionOptions of this._config.connection) {
+                const connection = await amqplib.connect(connectionOptions);
+                this._connections.push(connection);
+                const hostname = typeof connectionOptions === 'object'
+                    ? connectionOptions.hostname
+                    : connectionOptions;
+                this.logger?.info?.(`Connected to ${hostname}`);
+                /** Subscribe to channels */
+                for (const args of handlerArgs) {
+                    /** Create channel per operation */
+                    const channel = await connection.createChannel();
+                    for (const topic of args.topics) {
+                        const opts = this._config.queues?.[topic];
+                        if (opts)
+                            await channel.assertQueue(topic, opts);
+                    }
+                    for (const topic of args.topics) {
+                        await channel.assertQueue(topic);
+                        await channel
+                            .consume(topic, async (msg) => {
+                            if (!msg)
+                                return;
+                            await this.emitAsync('message', msg).catch(() => undefined);
+                            try {
+                                await args.handler(msg);
+                                // channel.ack(msg);
+                            }
+                            catch (e) {
+                                this._emitError(e);
+                            }
+                            await this.emitAsync('message-finish', msg);
+                        }, 
+                        /** Consume options */
+                        args.operationConfig.consumer)
+                            .catch(e => {
+                            this._emitError(e);
+                            throw e;
+                        });
+                        this.logger?.info?.(`Subscribed to topic${args.topics.length > 1 ? 's' : ''} "${args.topics}"`);
+                    }
+                }
+            }
+            this._status = 'started';
+        }
+        catch (e) {
+            await this.close();
+            throw e;
+        }
+    }
+    // protected async _connect() {
+    //   if (!this._connection)
+    //     this._connection = await amqplib.connect(this._config.connection);
+    //   return this._connection;
+    // }
+    /**
+     * Closes all connections and stops the service
+     */
+    async close() {
+        await Promise.all(this._connections.map(c => c.close()));
+        this._connections = [];
+        this._controllerInstances.clear();
+        this._status = 'idle';
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+    /**
+     *
+     * @param controller
+     * @param instance
+     * @param operation
+     * @protected
+     */
+    async _getOperationConfig(controller, instance, operation) {
+        if (typeof instance[operation.name] !== 'function')
+            return;
+        const proto = controller.ctor?.prototype || Object.getPrototypeOf(instance);
+        if (Reflect.hasMetadata(RPC_CONTROLLER_METADATA, proto, operation.name))
+            return;
+        const operationConfig = {
+            consumer: {
+                noAck: true,
+            },
+        };
+        if (this._config.defaults) {
+            if (this._config.defaults.consumer) {
+                Object.assign(operationConfig.consumer, this._config.defaults.consumer);
+            }
+        }
+        let metadata = Reflect.getMetadata(RMQ_OPERATION_METADATA, proto, operation.name);
+        if (!metadata) {
+            const configResolver = Reflect.getMetadata(RMQ_OPERATION_METADATA_RESOLVER, proto, operation.name);
+            if (configResolver) {
+                metadata = await configResolver();
+            }
+        }
+        if (metadata) {
+            if (typeof metadata.consumer === 'object') {
+                Object.assign(operationConfig.consumer, metadata.consumer);
+            }
+        }
+        return operationConfig;
+    }
+    /**
+     *
+     * @param args
+     * @protected
+     */
+    _createHandler(args) {
+        const { controller, instance, operation } = args;
+        /** Prepare parsers */
+        const decodePayload = operation.payloadType?.generateCodec('decode', {
+            scope: this.scope,
+            ignoreWriteonlyFields: true,
+        });
+        operation.headers.forEach(header => {
+            let decode = this[kAssetCache].get(header, 'decode');
+            if (!decode) {
+                decode =
+                    header.type?.generateCodec('decode', {
+                        scope: this.scope,
+                        ignoreReadonlyFields: true,
+                    }) || vg.isAny();
+                this[kAssetCache].set(header, 'decode', decode);
+            }
+        });
+        args.handler = async (message) => {
+            if (!message)
+                return;
+            const operationHandler = instance[operation.name];
+            let content;
+            const headers = {};
+            try {
+                /** Parse and decode `payload` */
+                content = await this._parseContent(message);
+                if (content && decodePayload) {
+                    if (Buffer.isBuffer(content))
+                        content = content.toString('utf-8');
+                    content = decodePayload(content);
+                }
+                // message.properties.
+                /** Parse and decode `headers` */
+                if (message.properties.headers) {
+                    for (const [k, v] of Object.entries(message.properties.headers)) {
+                        const header = operation.findHeader(k);
+                        const decode = this[kAssetCache].get(header, 'decode') || vg.isAny();
+                        headers[k] = decode(Buffer.isBuffer(v) ? v.toString() : v);
+                    }
+                }
+            }
+            catch (e) {
+                this._emitError(e);
+                return;
+            }
+            /** Create context */
+            const context = new RabbitmqContext({
+                adapter: this,
+                platform: this.platform,
+                controller,
+                controllerInstance: instance,
+                operation,
+                operationHandler,
+                fields: message.fields,
+                properties: message.properties,
+                content,
+                headers,
+            });
+            await this.emitAsync('before-execute', context);
+            try {
+                /** Call operation handler */
+                const result = await operationHandler.call(instance, context);
+                await this.emitAsync('after-execute', context, result);
+            }
+            catch (e) {
+                this._emitError(e, context);
+            }
+        };
+    }
+    async _parseContent(msg) {
+        if (!msg.content?.length)
+            return;
+        let content = msg.content;
+        if (msg.properties.contentEncoding) {
+            switch (msg.properties.contentEncoding) {
+                case 'gzip':
+                case 'x-gzip': {
+                    content = await gunzipAsync(content);
+                    break;
+                }
+                case 'deflate':
+                case 'x-deflate': {
+                    content = await deflateAsync(content);
+                    break;
+                }
+                case 'inflate':
+                case 'x-inflate': {
+                    content = await inflateAsync(content);
+                    break;
+                }
+                case 'br': {
+                    content = await brotliAsync(content);
+                    break;
+                }
+                case 'base64': {
+                    content = content.toString('base64');
+                    break;
+                }
+            }
+        }
+        const mediaType = msg.properties.contentType &&
+            parseContentType(msg.properties.contentType || '');
+        let charset = (mediaType?.parameters.charset || '').toLowerCase();
+        if (!charset && typeIs.is(mediaType?.type, ['json', 'xml', 'txt']))
+            charset = 'utf-8';
+        if (charset) {
+            content = iconv.decode(content, charset);
+            if (typeIs.is(mediaType.type, ['json']))
+                return JSON.parse(content);
+        }
+        return content;
+    }
+    _emitError(error, context) {
+        Promise.resolve()
+            .then(async () => {
+            const logger = this.logger;
+            if (context) {
+                if (!context.errors.length)
+                    context.errors.push(error);
+                context.errors = this._wrapExceptions(context.errors);
+                if (context.listenerCount('error')) {
+                    await this.emitAsync('error', context.errors[0], context);
+                }
+                if (logger?.error) {
+                    context.errors.forEach(err => logger.error(err));
+                }
+                return;
+            }
+            this.logger?.error(error);
+            if (this.listenerCount('error'))
+                this.emit('error', error);
+        })
+            .catch(noOp);
+    }
+    _wrapExceptions(exceptions) {
+        const wrappedErrors = exceptions.map(e => e instanceof OpraException ? e : new OpraException(e));
+        if (!wrappedErrors.length)
+            wrappedErrors.push(new OpraException('Internal Server Error'));
+        return wrappedErrors;
+    }
+}
+RabbitmqAdapter.PlatformName = 'rabbitmq';

package/esm/rabbitmq-context.js

@@ -0,0 +1,34 @@
+import { ExecutionContext } from '@opra/core';
+/**
+ * RabbitmqContext class provides the context for handling RabbitMQ messages.
+ * It extends the ExecutionContext and implements the AsyncEventEmitter.
+ */
+export class RabbitmqContext extends ExecutionContext {
+    /**
+     * Constructor
+     * @param init the context options
+     */
+    constructor(init) {
+        super({
+            ...init,
+            document: init.adapter.document,
+            documentNode: init.controller?.node,
+            protocol: 'rpc',
+        });
+        this.adapter = init.adapter;
+        this.platform = init.adapter.platform;
+        this.protocol = 'rpc';
+        if (init.controller)
+            this.controller = init.controller;
+        if (init.controllerInstance)
+            this.controllerInstance = init.controllerInstance;
+        if (init.operation)
+            this.operation = init.operation;
+        if (init.operationHandler)
+            this.operationHandler = init.operationHandler;
+        this.fields = init.fields;
+        this.properties = init.properties;
+        this.headers = init.headers || {};
+        this.content = init.content;
+    }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@opra/rabbitmq",
+  "version": "1.10.0",
+  "description": "Opra RabbitMQ package",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@browsery/type-is": "^1.6.18-r8",
+    "@opra/common": "^1.10.0",
+    "@opra/core": "^1.10.0",
+    "content-type": "^1.0.5",
+    "iconv-lite": "^0.6.3",
+    "node-events-async": "^1.0.0",
+    "tslib": "^2.8.1",
+    "valgen": "^5.13.0"
+  },
+  "peerDependencies": {
+    "amqplib": "^0.10.5"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/rabbitmq"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "rabbitmq",
+    "amqp",
+    "amqplib",
+    "message",
+    "queue",
+    "consumer"
+  ]
+}

package/types/augmentation/opra-common.augmentation.d.ts

@@ -0,0 +1,7 @@
+import '@opra/core';
+import { RabbitmqAdapter } from '../rabbitmq-adapter.js';
+declare module '@opra/common' {
+    interface RpcOperationDecorator {
+        RabbitMQ(config: RabbitmqAdapter.OperationOptions | (() => RabbitmqAdapter.OperationOptions | Promise<RabbitmqAdapter.OperationOptions>)): this;
+    }
+}

package/types/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const RMQ_DEFAULT_GROUP = "default";
+export declare const RMQ_OPERATION_METADATA = "RMQ_OPERATION_METADATA";
+export declare const RMQ_OPERATION_METADATA_RESOLVER = "RMQ_OPERATION_METADATA_RESOLVER";

package/types/index.d.cts

@@ -0,0 +1,4 @@
+import './augmentation/opra-common.augmentation.js';
+export * from './constants.js';
+export * from './rabbitmq-adapter.js';
+export * from './rabbitmq-context.js';

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import './augmentation/opra-common.augmentation.js';
+export * from './constants.js';
+export * from './rabbitmq-adapter.js';
+export * from './rabbitmq-context.js';

package/types/rabbitmq-adapter.d.ts

@@ -0,0 +1,102 @@
+import { ApiDocument, OpraException, OpraSchema, RpcApi, RpcController, RpcOperation } from '@opra/common';
+import { PlatformAdapter } from '@opra/core';
+import amqplib from 'amqplib';
+import { ConsumeMessage } from 'amqplib/properties';
+import { RabbitmqContext } from './rabbitmq-context.js';
+export interface OperationConfig {
+    consumer: amqplib.Options.Consume & {};
+}
+interface HandlerArguments {
+    consumer: amqplib.Options.Consume & {};
+    controller: RpcController;
+    instance: any;
+    operation: RpcOperation;
+    operationConfig: OperationConfig;
+    handler: (msg: ConsumeMessage | null) => void | Promise<void>;
+    topics: string[];
+}
+/**
+ *
+ * @class RabbitmqAdapter
+ */
+export declare class RabbitmqAdapter extends PlatformAdapter {
+    static readonly PlatformName = "rabbitmq";
+    protected _config: RabbitmqAdapter.Config;
+    protected _controllerInstances: Map<RpcController, any>;
+    protected _connections: amqplib.Connection[];
+    protected _status: RabbitmqAdapter.Status;
+    readonly protocol: OpraSchema.Transport;
+    readonly platform = "rabbitmq";
+    readonly interceptors: (RabbitmqAdapter.InterceptorFunction | RabbitmqAdapter.IRabbitmqInterceptor)[];
+    /**
+     *
+     * @param document
+     * @param config
+     * @constructor
+     */
+    constructor(document: ApiDocument, config: RabbitmqAdapter.Config);
+    get api(): RpcApi;
+    get scope(): string | undefined;
+    get status(): RabbitmqAdapter.Status;
+    /**
+     * Starts the service
+     */
+    start(): Promise<void>;
+    /**
+     * Closes all connections and stops the service
+     */
+    close(): Promise<void>;
+    getControllerInstance<T>(controllerPath: string): T | undefined;
+    /**
+     *
+     * @param controller
+     * @param instance
+     * @param operation
+     * @protected
+     */
+    protected _getOperationConfig(controller: RpcController, instance: any, operation: RpcOperation): Promise<OperationConfig | undefined>;
+    /**
+     *
+     * @param args
+     * @protected
+     */
+    protected _createHandler(args: HandlerArguments): void;
+    protected _parseContent(msg: ConsumeMessage): Promise<any>;
+    protected _emitError(error: any, context?: RabbitmqContext): void;
+    protected _wrapExceptions(exceptions: any[]): OpraException[];
+}
+/**
+ * @namespace RabbitmqAdapter
+ */
+export declare namespace RabbitmqAdapter {
+    type NextCallback = () => Promise<any>;
+    type Status = 'idle' | 'starting' | 'started';
+    type ConnectionOptions = amqplib.Options.Connect;
+    interface Config extends PlatformAdapter.Options {
+        connection: (string | ConnectionOptions)[];
+        queues?: Record<string, amqplib.Options.AssertQueue>;
+        defaults?: {
+            consumer?: amqplib.Options.Consume;
+        };
+        scope?: string;
+        interceptors?: (InterceptorFunction | IRabbitmqInterceptor)[];
+        logExtra?: boolean;
+    }
+    interface OperationOptions {
+        /**
+         * ConsumerConfig
+         */
+        consumer?: amqplib.Options.Consume;
+    }
+    /**
+     * @type InterceptorFunction
+     */
+    type InterceptorFunction = IRabbitmqInterceptor['intercept'];
+    /**
+     * @interface IRabbitmqInterceptor
+     */
+    type IRabbitmqInterceptor = {
+        intercept(context: RabbitmqContext, next: NextCallback): Promise<any>;
+    };
+}
+export {};

package/types/rabbitmq-context.d.ts

@@ -0,0 +1,40 @@
+import { OpraSchema, RpcController, RpcOperation } from '@opra/common';
+import { ExecutionContext } from '@opra/core';
+import amqplib from 'amqplib';
+import type { AsyncEventEmitter } from 'node-events-async';
+import type { RabbitmqAdapter } from './rabbitmq-adapter';
+/**
+ * RabbitmqContext class provides the context for handling RabbitMQ messages.
+ * It extends the ExecutionContext and implements the AsyncEventEmitter.
+ */
+export declare class RabbitmqContext extends ExecutionContext implements AsyncEventEmitter {
+    readonly protocol: OpraSchema.Transport;
+    readonly platform: string;
+    readonly adapter: RabbitmqAdapter;
+    readonly controller?: RpcController;
+    readonly controllerInstance?: any;
+    readonly operation?: RpcOperation;
+    readonly operationHandler?: Function;
+    readonly fields: amqplib.MessageFields;
+    readonly properties: amqplib.MessageProperties;
+    readonly content: any;
+    readonly headers: Record<string, any>;
+    /**
+     * Constructor
+     * @param init the context options
+     */
+    constructor(init: RabbitmqContext.Initiator);
+}
+export declare namespace RabbitmqContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol' | 'documentNode'> {
+        adapter: RabbitmqAdapter;
+        controller?: RpcController;
+        controllerInstance?: any;
+        operation?: RpcOperation;
+        operationHandler?: Function;
+        content: any;
+        headers: Record<string, any>;
+        fields: amqplib.MessageFields;
+        properties: amqplib.MessageProperties;
+    }
+}