@opra/kafka 1.0.0-beta.3

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/msg-operation.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.MsgOperationDecoratorFactory.augment((decorator, decoratorChain) => {
+    decorator.Kafka = (config) => {
+        decoratorChain.push((_, target, propertyKey) => {
+            if (typeof config === 'function') {
+                Reflect.defineMetadata(constants_js_1.KAFKA_OPERATION_METADATA_RESOLVER, config, target, propertyKey);
+            }
+            else {
+                Reflect.defineMetadata(constants_js_1.KAFKA_OPERATION_METADATA, { ...config }, target, propertyKey);
+            }
+        });
+        return decorator;
+    };
+});

package/cjs/constants.js

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

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./augmentation/msg-operation.augmentation.js");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./kafka-adapter.js"), exports);
+tslib_1.__exportStar(require("./kafka-context.js"), exports);
+tslib_1.__exportStar(require("./request-parser.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/kafka-adapter.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaAdapter = void 0;
+const common_1 = require("@opra/common");
+const core_1 = require("@opra/core");
+const kafkajs_1 = require("kafkajs");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("./constants.js");
+const kafka_context_js_1 = require("./kafka-context.js");
+const request_parser_js_1 = require("./request-parser.js");
+const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
+const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+/**
+ *
+ * @class KafkaAdapter
+ */
+class KafkaAdapter extends core_1.PlatformAdapter {
+    /**
+     *
+     * @param init
+     * @constructor
+     */
+    constructor(init) {
+        super(init.document, init);
+        this._controllerInstances = new Map();
+        this._consumers = new Map();
+        this.protocol = 'msg';
+        this.platform = KafkaAdapter.PlatformName;
+        if (!(init.document.api instanceof common_1.MsgApi && init.document.api.platform === KafkaAdapter.PlatformName)) {
+            throw new TypeError(`The document doesn't expose a Kafka Api`);
+        }
+        this.interceptors = [...(init.interceptors || [])];
+        this.kafka = new kafkajs_1.Kafka({
+            ...init,
+            logCreator: init.logger ? () => this._createLogCreator(init.logger) : undefined,
+        });
+        this._logger = init.logger;
+        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.msgApi;
+    }
+    /**
+     * Starts the service
+     */
+    async start() {
+        /* istanbul ignore next */
+        if (this._consumers.size > 0)
+            return;
+        await this._initConsumers();
+        return this._start();
+    }
+    /**
+     * Closes all connections and stops the service
+     */
+    async close() {
+        for (const [controller, instance] of this._controllerInstances.entries()) {
+            if (controller.onShutdown) {
+                try {
+                    await controller.onShutdown.call(instance, controller);
+                }
+                catch (e) {
+                    this._emitError(e);
+                }
+            }
+        }
+        await Promise.allSettled(Array.from(this._consumers.keys()).map(c => c.disconnect()));
+        this._consumers.clear();
+        this._controllerInstances.clear();
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+    /**
+     * Creates and initializes all consumers
+     *
+     * @protected
+     */
+    async _initConsumers() {
+        /* istanbul ignore next */
+        if (this._consumers.size > 0)
+            return;
+        /** Create consumers */
+        for (const controller of this.document.msgApi.controllers.values()) {
+            let instance = controller.instance;
+            if (!instance && controller.ctor)
+                instance = new controller.ctor();
+            if (!instance)
+                continue;
+            for (const operation of controller.operations.values()) {
+                await this._initConsumer(controller, instance, operation);
+            }
+            this._controllerInstances.set(controller, instance);
+        }
+    }
+    /**
+     * Creates and initializes a consumer for given operation
+     *
+     * @protected
+     */
+    async _initConsumer(controller, instance, operation) {
+        if (typeof instance[operation.name] !== 'function')
+            return;
+        const proto = controller.ctor?.prototype || Object.getPrototypeOf(controller.instance);
+        let operationOptions = Reflect.getMetadata(constants_js_1.KAFKA_OPERATION_METADATA, proto, operation.name);
+        const configResolver = Reflect.getMetadata(constants_js_1.KAFKA_OPERATION_METADATA_RESOLVER, proto, operation.name);
+        if (configResolver) {
+            const cfg = await configResolver();
+            operationOptions = { ...operationOptions, ...cfg };
+        }
+        const groupId = operationOptions?.groupId || constants_js_1.KAFKA_DEFAULT_GROUP;
+        const options = { ...operationOptions, groupId };
+        const consumer = this.kafka.consumer(options);
+        this._consumers.set(consumer, { consumer, controller, instance, operation, options });
+        if (typeof controller.onInit === 'function')
+            controller.onInit.call(instance, controller);
+    }
+    async _start() {
+        const arr = Array.from(this._consumers.values());
+        if (!arr.length)
+            return;
+        /** Start first consumer to test if server is available */
+        await this._startConsumer(arr.shift());
+        /** if first connection is success than start all consumers at same time */
+        await Promise.allSettled(arr.map(x => this._startConsumer(x)));
+    }
+    /**
+     * Starts all consumers
+     * @protected
+     */
+    async _startConsumer(args) {
+        const { consumer, controller, instance, operation, options } = args;
+        /** Prepare parsers */
+        const parseKey = request_parser_js_1.RequestParser.STRING;
+        const parsePayload = request_parser_js_1.RequestParser.STRING;
+        /** Prepare decoders */
+        const decodeKey = operation.keyType?.generateCodec('decode', { ignoreWriteonlyFields: true }) || valgen_1.vg.isAny();
+        const decodePayload = operation.payloadType?.generateCodec('decode', { ignoreWriteonlyFields: true }) || valgen_1.vg.isAny();
+        operation.headers.forEach(header => {
+            let decode = this[core_1.kAssetCache].get(header, 'decode');
+            if (!decode) {
+                decode = header.type?.generateCodec('decode', { ignoreReadonlyFields: true }) || valgen_1.vg.isAny();
+                this[core_1.kAssetCache].set(header, 'decode', decode);
+            }
+        });
+        /** Connect to Kafka server */
+        await consumer.connect().catch(e => {
+            this._emitError(e);
+            throw e;
+        });
+        /** Subscribe to channels */
+        if (Array.isArray(operation.channel)) {
+            await consumer.subscribe({ topics: operation.channel, fromBeginning: options.fromBeginning }).catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
+        else {
+            await consumer.subscribe({ topic: operation.channel, fromBeginning: options.fromBeginning }).catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
+        /** Run message listener */
+        await consumer
+            .run({
+            eachMessage: async ({ topic, partition, message, heartbeat, pause }) => {
+                const operationHandler = instance[operation.name];
+                let key;
+                let payload;
+                const headers = {};
+                try {
+                    /** Parse and decode `key` */
+                    if (message.key) {
+                        const s = parseKey(message.key);
+                        key = decodeKey(s);
+                    }
+                    /** Parse and decode `payload` */
+                    if (message.value != null) {
+                        const s = parsePayload(message.value);
+                        payload = decodePayload(s);
+                    }
+                    /** Parse and decode `headers` */
+                    if (message.headers) {
+                        for (const [k, v] of Object.entries(message.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 ctx = new kafka_context_js_1.KafkaContext({
+                    adapter: this,
+                    platform: this.platform,
+                    controller,
+                    controllerInstance: instance,
+                    operation,
+                    operationHandler,
+                    topic,
+                    partition,
+                    payload,
+                    key,
+                    headers,
+                    rawMessage: message,
+                    heartbeat,
+                    pause,
+                });
+                await this.emitAsync('createContext', ctx);
+                await operationHandler(ctx);
+            },
+        })
+            .catch(e => {
+            this._emitError(e);
+            throw e;
+        });
+    }
+    _emitError(e) {
+        this._logger?.error(e);
+        if (this.listenerCount('error'))
+            this.emit('error', e);
+    }
+    _createLogCreator(logger, logExtra) {
+        return ({ namespace, level, log }) => {
+            const { message, ...extra } = log;
+            delete extra.namespace;
+            delete extra.timestamp;
+            delete extra.logger;
+            let fn;
+            switch (level) {
+                case kafkajs_1.logLevel.ERROR:
+                    fn = logger.error || logger.info;
+                    break;
+                case kafkajs_1.logLevel.WARN:
+                    fn = logger.warn || logger.info;
+                    break;
+                case kafkajs_1.logLevel.DEBUG:
+                    fn = logger.debug;
+                    break;
+                case kafkajs_1.logLevel.NOTHING:
+                    break;
+                default:
+                    fn = logger.info;
+                    break;
+            }
+            if (!fn)
+                return;
+            if (!logExtra)
+                return fn(message);
+            return fn(message, {
+                ...extra,
+                namespace,
+            });
+        };
+    }
+}
+exports.KafkaAdapter = KafkaAdapter;
+/**
+ * @namespace KafkaAdapter
+ */
+(function (KafkaAdapter) {
+    KafkaAdapter.PlatformName = 'kafka';
+})(KafkaAdapter || (exports.KafkaAdapter = KafkaAdapter = {}));

package/cjs/kafka-context.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaContext = void 0;
+const core_1 = require("@opra/core");
+class KafkaContext extends core_1.ExecutionContext {
+    constructor(init) {
+        super({ ...init, document: init.adapter.document, protocol: 'msg' });
+        this.adapter = init.adapter;
+        this.platform = init.adapter.platform;
+        this.protocol = 'msg';
+        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.partition = init.partition;
+        this.headers = init.headers || {};
+        this.key = init.key;
+        this.payload = init.payload;
+        this.heartbeat = init.heartbeat;
+        this.pause = init.pause;
+        this.rawMessage = init.rawMessage;
+    }
+}
+exports.KafkaContext = KafkaContext;

package/cjs/package.json

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

package/cjs/parsers/binary.parser.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryParser = void 0;
+const binaryParser = function (buffer) {
+    return buffer;
+};
+exports.binaryParser = binaryParser;

package/cjs/parsers/string.parser.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringParser = void 0;
+const stringParser = function (buffer) {
+    return buffer.toString();
+};
+exports.stringParser = stringParser;

package/cjs/request-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestParser = void 0;
+const binary_parser_js_1 = require("./parsers/binary.parser.js");
+const string_parser_js_1 = require("./parsers/string.parser.js");
+exports.RequestParser = {
+    BINARY: binary_parser_js_1.binaryParser,
+    STRING: string_parser_js_1.stringParser,
+};

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/augmentation/msg-operation.augmentation.js

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

package/esm/constants.js

@@ -0,0 +1,3 @@
+export const KAFKA_DEFAULT_GROUP = 'default';
+export const KAFKA_OPERATION_METADATA = 'KAFKA_OPERATION_METADATA';
+export const KAFKA_OPERATION_METADATA_RESOLVER = 'KAFKA_OPERATION_METADATA_RESOLVER';

package/esm/index.js

@@ -0,0 +1,6 @@
+import './augmentation/msg-operation.augmentation.js';
+export * from './constants.js';
+export * from './kafka-adapter.js';
+export * from './kafka-context.js';
+export * from './request-parser.js';
+export * from './types.js';

package/esm/kafka-adapter.js

@@ -0,0 +1,272 @@
+import { MsgApi } from '@opra/common';
+import { kAssetCache, PlatformAdapter } from '@opra/core';
+import { Kafka, logLevel } from 'kafkajs';
+import { vg } from 'valgen';
+import { KAFKA_DEFAULT_GROUP, KAFKA_OPERATION_METADATA, KAFKA_OPERATION_METADATA_RESOLVER } from './constants.js';
+import { KafkaContext } from './kafka-context.js';
+import { RequestParser } from './request-parser.js';
+const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
+const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+/**
+ *
+ * @class KafkaAdapter
+ */
+export class KafkaAdapter extends PlatformAdapter {
+    /**
+     *
+     * @param init
+     * @constructor
+     */
+    constructor(init) {
+        super(init.document, init);
+        this._controllerInstances = new Map();
+        this._consumers = new Map();
+        this.protocol = 'msg';
+        this.platform = KafkaAdapter.PlatformName;
+        if (!(init.document.api instanceof MsgApi && init.document.api.platform === KafkaAdapter.PlatformName)) {
+            throw new TypeError(`The document doesn't expose a Kafka Api`);
+        }
+        this.interceptors = [...(init.interceptors || [])];
+        this.kafka = new Kafka({
+            ...init,
+            logCreator: init.logger ? () => this._createLogCreator(init.logger) : undefined,
+        });
+        this._logger = init.logger;
+        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.msgApi;
+    }
+    /**
+     * Starts the service
+     */
+    async start() {
+        /* istanbul ignore next */
+        if (this._consumers.size > 0)
+            return;
+        await this._initConsumers();
+        return this._start();
+    }
+    /**
+     * Closes all connections and stops the service
+     */
+    async close() {
+        for (const [controller, instance] of this._controllerInstances.entries()) {
+            if (controller.onShutdown) {
+                try {
+                    await controller.onShutdown.call(instance, controller);
+                }
+                catch (e) {
+                    this._emitError(e);
+                }
+            }
+        }
+        await Promise.allSettled(Array.from(this._consumers.keys()).map(c => c.disconnect()));
+        this._consumers.clear();
+        this._controllerInstances.clear();
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+    /**
+     * Creates and initializes all consumers
+     *
+     * @protected
+     */
+    async _initConsumers() {
+        /* istanbul ignore next */
+        if (this._consumers.size > 0)
+            return;
+        /** Create consumers */
+        for (const controller of this.document.msgApi.controllers.values()) {
+            let instance = controller.instance;
+            if (!instance && controller.ctor)
+                instance = new controller.ctor();
+            if (!instance)
+                continue;
+            for (const operation of controller.operations.values()) {
+                await this._initConsumer(controller, instance, operation);
+            }
+            this._controllerInstances.set(controller, instance);
+        }
+    }
+    /**
+     * Creates and initializes a consumer for given operation
+     *
+     * @protected
+     */
+    async _initConsumer(controller, instance, operation) {
+        if (typeof instance[operation.name] !== 'function')
+            return;
+        const proto = controller.ctor?.prototype || Object.getPrototypeOf(controller.instance);
+        let operationOptions = Reflect.getMetadata(KAFKA_OPERATION_METADATA, proto, operation.name);
+        const configResolver = Reflect.getMetadata(KAFKA_OPERATION_METADATA_RESOLVER, proto, operation.name);
+        if (configResolver) {
+            const cfg = await configResolver();
+            operationOptions = { ...operationOptions, ...cfg };
+        }
+        const groupId = operationOptions?.groupId || KAFKA_DEFAULT_GROUP;
+        const options = { ...operationOptions, groupId };
+        const consumer = this.kafka.consumer(options);
+        this._consumers.set(consumer, { consumer, controller, instance, operation, options });
+        if (typeof controller.onInit === 'function')
+            controller.onInit.call(instance, controller);
+    }
+    async _start() {
+        const arr = Array.from(this._consumers.values());
+        if (!arr.length)
+            return;
+        /** Start first consumer to test if server is available */
+        await this._startConsumer(arr.shift());
+        /** if first connection is success than start all consumers at same time */
+        await Promise.allSettled(arr.map(x => this._startConsumer(x)));
+    }
+    /**
+     * Starts all consumers
+     * @protected
+     */
+    async _startConsumer(args) {
+        const { consumer, controller, instance, operation, options } = args;
+        /** Prepare parsers */
+        const parseKey = RequestParser.STRING;
+        const parsePayload = RequestParser.STRING;
+        /** Prepare decoders */
+        const decodeKey = operation.keyType?.generateCodec('decode', { ignoreWriteonlyFields: true }) || vg.isAny();
+        const decodePayload = operation.payloadType?.generateCodec('decode', { ignoreWriteonlyFields: true }) || vg.isAny();
+        operation.headers.forEach(header => {
+            let decode = this[kAssetCache].get(header, 'decode');
+            if (!decode) {
+                decode = header.type?.generateCodec('decode', { ignoreReadonlyFields: true }) || vg.isAny();
+                this[kAssetCache].set(header, 'decode', decode);
+            }
+        });
+        /** Connect to Kafka server */
+        await consumer.connect().catch(e => {
+            this._emitError(e);
+            throw e;
+        });
+        /** Subscribe to channels */
+        if (Array.isArray(operation.channel)) {
+            await consumer.subscribe({ topics: operation.channel, fromBeginning: options.fromBeginning }).catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
+        else {
+            await consumer.subscribe({ topic: operation.channel, fromBeginning: options.fromBeginning }).catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
+        /** Run message listener */
+        await consumer
+            .run({
+            eachMessage: async ({ topic, partition, message, heartbeat, pause }) => {
+                const operationHandler = instance[operation.name];
+                let key;
+                let payload;
+                const headers = {};
+                try {
+                    /** Parse and decode `key` */
+                    if (message.key) {
+                        const s = parseKey(message.key);
+                        key = decodeKey(s);
+                    }
+                    /** Parse and decode `payload` */
+                    if (message.value != null) {
+                        const s = parsePayload(message.value);
+                        payload = decodePayload(s);
+                    }
+                    /** Parse and decode `headers` */
+                    if (message.headers) {
+                        for (const [k, v] of Object.entries(message.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 ctx = new KafkaContext({
+                    adapter: this,
+                    platform: this.platform,
+                    controller,
+                    controllerInstance: instance,
+                    operation,
+                    operationHandler,
+                    topic,
+                    partition,
+                    payload,
+                    key,
+                    headers,
+                    rawMessage: message,
+                    heartbeat,
+                    pause,
+                });
+                await this.emitAsync('createContext', ctx);
+                await operationHandler(ctx);
+            },
+        })
+            .catch(e => {
+            this._emitError(e);
+            throw e;
+        });
+    }
+    _emitError(e) {
+        this._logger?.error(e);
+        if (this.listenerCount('error'))
+            this.emit('error', e);
+    }
+    _createLogCreator(logger, logExtra) {
+        return ({ namespace, level, log }) => {
+            const { message, ...extra } = log;
+            delete extra.namespace;
+            delete extra.timestamp;
+            delete extra.logger;
+            let fn;
+            switch (level) {
+                case logLevel.ERROR:
+                    fn = logger.error || logger.info;
+                    break;
+                case logLevel.WARN:
+                    fn = logger.warn || logger.info;
+                    break;
+                case logLevel.DEBUG:
+                    fn = logger.debug;
+                    break;
+                case logLevel.NOTHING:
+                    break;
+                default:
+                    fn = logger.info;
+                    break;
+            }
+            if (!fn)
+                return;
+            if (!logExtra)
+                return fn(message);
+            return fn(message, {
+                ...extra,
+                namespace,
+            });
+        };
+    }
+}
+/**
+ * @namespace KafkaAdapter
+ */
+(function (KafkaAdapter) {
+    KafkaAdapter.PlatformName = 'kafka';
+})(KafkaAdapter || (KafkaAdapter = {}));

package/esm/kafka-context.js

@@ -0,0 +1,24 @@
+import { ExecutionContext } from '@opra/core';
+export class KafkaContext extends ExecutionContext {
+    constructor(init) {
+        super({ ...init, document: init.adapter.document, protocol: 'msg' });
+        this.adapter = init.adapter;
+        this.platform = init.adapter.platform;
+        this.protocol = 'msg';
+        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.partition = init.partition;
+        this.headers = init.headers || {};
+        this.key = init.key;
+        this.payload = init.payload;
+        this.heartbeat = init.heartbeat;
+        this.pause = init.pause;
+        this.rawMessage = init.rawMessage;
+    }
+}

package/esm/package.json

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

package/esm/parsers/binary.parser.js

@@ -0,0 +1,3 @@
+export const binaryParser = function (buffer) {
+    return buffer;
+};

package/esm/parsers/string.parser.js

@@ -0,0 +1,3 @@
+export const stringParser = function (buffer) {
+    return buffer.toString();
+};

package/esm/request-parser.js

@@ -0,0 +1,6 @@
+import { binaryParser } from './parsers/binary.parser.js';
+import { stringParser } from './parsers/string.parser.js';
+export const RequestParser = {
+    BINARY: binaryParser,
+    STRING: stringParser,
+};

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@opra/kafka",
+  "version": "1.0.0-beta.3",
+  "description": "Opra Kafka package",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@opra/common": "^1.0.0-beta.3",
+    "@opra/core": "^1.0.0-beta.3",
+    "node-events-async": "^1.0.0",
+    "tslib": "^2.7.0",
+    "valgen": "^5.10.0"
+  },
+  "peerDependencies": {
+    "kafkajs": "^2.2.4"
+  },
+  "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/kafka"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "kafka",
+    "consumer"
+  ]
+}

package/types/augmentation/msg-operation.augmentation.d.ts

@@ -0,0 +1,7 @@
+import '@opra/core';
+import { KafkaOperationOptions } from '../types.js';
+declare module '@opra/common' {
+    interface MsgOperationDecorator {
+        Kafka(config: KafkaOperationOptions | (() => KafkaOperationOptions | Promise<KafkaOperationOptions>)): this;
+    }
+}

package/types/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const KAFKA_DEFAULT_GROUP = "default";
+export declare const KAFKA_OPERATION_METADATA = "KAFKA_OPERATION_METADATA";
+export declare const KAFKA_OPERATION_METADATA_RESOLVER = "KAFKA_OPERATION_METADATA_RESOLVER";

package/types/index.d.cts

@@ -0,0 +1,6 @@
+import './augmentation/msg-operation.augmentation.js';
+export * from './constants.js';
+export * from './kafka-adapter.js';
+export * from './kafka-context.js';
+export * from './request-parser.js';
+export * from './types.js';

package/types/index.d.ts

@@ -0,0 +1,6 @@
+import './augmentation/msg-operation.augmentation.js';
+export * from './constants.js';
+export * from './kafka-adapter.js';
+export * from './kafka-context.js';
+export * from './request-parser.js';
+export * from './types.js';

package/types/kafka-adapter.d.ts

@@ -0,0 +1,94 @@
+import { ApiDocument, MsgApi, MsgController, MsgOperation, OpraSchema } from '@opra/common';
+import { type ILogger, PlatformAdapter } from '@opra/core';
+import { type Consumer, Kafka, type KafkaConfig } from 'kafkajs';
+import type { StrictOmit } from 'ts-gems';
+import { KafkaContext } from './kafka-context.js';
+import type { KafkaOperationOptions } from './types.js';
+/**
+ *
+ * @class KafkaAdapter
+ */
+export declare class KafkaAdapter extends PlatformAdapter {
+    protected _controllerInstances: Map<MsgController, any>;
+    protected _consumers: Map<Consumer, {
+        consumer: Consumer;
+        controller: MsgController;
+        instance: any;
+        operation: MsgOperation;
+        options: KafkaOperationOptions;
+    }>;
+    protected _logger?: ILogger;
+    readonly kafka: Kafka;
+    readonly protocol: OpraSchema.Transport;
+    readonly platform = "kafka";
+    interceptors: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor)[];
+    /**
+     *
+     * @param init
+     * @constructor
+     */
+    constructor(init: KafkaAdapter.InitArguments);
+    get api(): MsgApi;
+    /**
+     * Starts the service
+     */
+    start(): Promise<void>;
+    /**
+     * Closes all connections and stops the service
+     */
+    close(): Promise<void>;
+    getControllerInstance<T>(controllerPath: string): T | undefined;
+    /**
+     * Creates and initializes all consumers
+     *
+     * @protected
+     */
+    protected _initConsumers(): Promise<void>;
+    /**
+     * Creates and initializes a consumer for given operation
+     *
+     * @protected
+     */
+    protected _initConsumer(controller: MsgController, instance: any, operation: MsgOperation): Promise<void>;
+    protected _start(): Promise<void>;
+    /**
+     * Starts all consumers
+     * @protected
+     */
+    protected _startConsumer(args: {
+        consumer: Consumer;
+        controller: MsgController;
+        instance: any;
+        operation: MsgOperation;
+        options: KafkaOperationOptions;
+    }): Promise<void>;
+    protected _emitError(e: any): void;
+    protected _createLogCreator(logger: ILogger, logExtra?: boolean): ({ namespace, level, log }: {
+        namespace: any;
+        level: any;
+        log: any;
+    }) => any;
+}
+/**
+ * @namespace KafkaAdapter
+ */
+export declare namespace KafkaAdapter {
+    const PlatformName = "kafka";
+    type NextCallback = () => Promise<void>;
+    interface InitArguments extends StrictOmit<KafkaConfig, 'logCreator' | 'logLevel'>, PlatformAdapter.Options {
+        document: ApiDocument;
+        interceptors?: (InterceptorFunction | IKafkaInterceptor)[];
+        logger?: ILogger;
+        logExtra?: boolean;
+    }
+    /**
+     * @type InterceptorFunction
+     */
+    type InterceptorFunction = IKafkaInterceptor['intercept'];
+    /**
+     * @interface IKafkaInterceptor
+     */
+    type IKafkaInterceptor = {
+        intercept(context: KafkaContext, next: NextCallback): Promise<void>;
+    };
+}

package/types/kafka-context.d.ts

@@ -0,0 +1,39 @@
+import { MsgController, MsgOperation, OpraSchema } from '@opra/common';
+import { ExecutionContext } from '@opra/core';
+import type { KafkaMessage } from 'kafkajs';
+import type { AsyncEventEmitter } from 'node-events-async';
+import type { KafkaAdapter } from './kafka-adapter.js';
+export declare namespace KafkaContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol'> {
+        adapter: KafkaAdapter;
+        controller?: MsgController;
+        controllerInstance?: any;
+        operation?: MsgOperation;
+        operationHandler?: Function;
+        topic: string;
+        partition: number;
+        key: any;
+        payload: any;
+        headers: Record<string, any>;
+        rawMessage: KafkaMessage;
+        heartbeat(): Promise<void>;
+        pause(): () => void;
+    }
+}
+export declare class KafkaContext extends ExecutionContext implements AsyncEventEmitter {
+    readonly protocol: OpraSchema.Transport;
+    readonly platform: string;
+    readonly adapter: KafkaAdapter;
+    readonly controller?: MsgController;
+    readonly controllerInstance?: any;
+    readonly operation?: MsgOperation;
+    readonly operationHandler?: Function;
+    readonly key: any;
+    readonly payload: any;
+    readonly partition: number;
+    readonly headers: Record<string, any>;
+    readonly rawMessage: KafkaMessage;
+    readonly heartbeat: () => Promise<void>;
+    readonly pause: () => void;
+    constructor(init: KafkaContext.Initiator);
+}

package/types/parsers/binary.parser.d.ts

@@ -0,0 +1,2 @@
+import type { RequestParseFunction } from '../types.js';
+export declare const binaryParser: RequestParseFunction;

package/types/parsers/string.parser.d.ts

@@ -0,0 +1,2 @@
+import type { RequestParseFunction } from '../types.js';
+export declare const stringParser: RequestParseFunction;

package/types/request-parser.d.ts

@@ -0,0 +1,2 @@
+import type { RequestParseFunction } from './types.js';
+export declare const RequestParser: Record<string, RequestParseFunction>;

package/types/types.d.ts

@@ -0,0 +1,8 @@
+import type { MsgOperationResponse } from '@opra/common';
+import { ConsumerConfig } from 'kafkajs';
+export type RequestParseFunction = (buffer: Buffer) => any;
+export interface KafkaOperationOptions extends ConsumerConfig {
+    fromBeginning?: boolean;
+}
+export interface KafkaOperationResponseOptions extends MsgOperationResponse.Options {
+}