@opra/kafka 1.0.0-beta.5 → 1.0.1

package/cjs/kafka-adapter.js

@@ -10,6 +10,7 @@ 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'];
+const kGroupId = Symbol('kGroupId');
 /**
  *
  * @class KafkaAdapter
@@ -24,6 +25,7 @@ class KafkaAdapter extends core_1.PlatformAdapter {
         super(config.document, config);
         this._controllerInstances = new Map();
         this._consumers = new Map();
+        this._handlerArgs = [];
         this.protocol = 'rpc';
         this.platform = KafkaAdapter.PlatformName;
         if (!(config.document.api instanceof common_1.RpcApi && config.document.api.platform === KafkaAdapter.PlatformName)) {
@@ -56,24 +58,71 @@ class KafkaAdapter extends core_1.PlatformAdapter {
         /* istanbul ignore next */
         if (this._consumers.size > 0)
             return;
-        await this._initConsumers();
-        return this._start();
+        /* istanbul ignore next */
+        if (this._consumers.size > 0)
+            return;
+        await this._createAllConsumers();
+        /** Connect all consumers */
+        for (const consumer of this._consumers.values()) {
+            await consumer.connect().catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
+        /** Subscribe to channels */
+        for (const args of this._handlerArgs) {
+            const { consumer, operation, operationOptions } = args;
+            args.topics = Array.isArray(operation.channel) ? operation.channel : [operation.channel];
+            await consumer.subscribe({ topics: args.topics, fromBeginning: operationOptions.fromBeginning }).catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+            this.logger?.info?.(`Subscribed to topic${args.topics.length > 1 ? 's' : ''} "${args.topics}"`);
+        }
+        /** Start consumer listeners */
+        const topicMap = new Map();
+        for (const consumer of this._consumers.values()) {
+            const groupId = consumer[kGroupId];
+            await consumer
+                .run({
+                eachMessage: async (payload) => {
+                    await this.emitAsync('message', payload).catch(() => undefined);
+                    const { topic } = payload;
+                    const topicCacheKey = groupId + ':' + topic;
+                    let handlerArgsArray = topicMap.get(topicCacheKey);
+                    if (!handlerArgsArray) {
+                        handlerArgsArray = this._handlerArgs.filter(args => args.consumer === consumer &&
+                            args.topics.find(t => (t instanceof RegExp ? t.test(topic) : t === topic)));
+                        /* istanbul ignore next */
+                        if (!handlerArgsArray) {
+                            this._emitError(new Error(`Unhandled topic (${topic})`));
+                            return;
+                        }
+                        topicMap.set(topicCacheKey, handlerArgsArray);
+                    }
+                    /** Iterate and call all matching handlers */
+                    for (const args of handlerArgsArray) {
+                        try {
+                            await args.handler(payload);
+                        }
+                        catch (e) {
+                            this._emitError(e);
+                        }
+                    }
+                    await this.emitAsync('message-finish', payload);
+                },
+            })
+                .catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
     }
     /**
      * 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.values()).map(c => c.consumer.disconnect()));
+        await Promise.allSettled(Array.from(this._consumers.values()).map(c => c.disconnect()));
         this._consumers.clear();
         this._controllerInstances.clear();
     }
@@ -82,82 +131,98 @@ class KafkaAdapter extends core_1.PlatformAdapter {
         return controller && this._controllerInstances.get(controller);
     }
     /**
-     * Creates and initializes all consumers
      *
+     * @param controller
+     * @param instance
+     * @param operation
      * @protected
      */
-    async _initConsumers() {
-        /* istanbul ignore next */
-        if (this._consumers.size > 0)
+    async _getOperationOptions(controller, instance, operation) {
+        if (typeof instance[operation.name] !== 'function')
             return;
-        /** Create consumers */
+        const proto = controller.ctor?.prototype || Object.getPrototypeOf(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 };
+        }
+        return operationOptions;
+    }
+    /**
+     *
+     * @protected
+     */
+    async _createAllConsumers() {
         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()) {
-                await this._initConsumer(controller, instance, operation);
+                const operationOptions = await this._getOperationOptions(controller, instance, operation);
+                if (!operationOptions)
+                    continue;
+                // const consumerConfig = this._getConsumerConfig(operationOptions);
+                const args = {
+                    consumer: null,
+                    controller,
+                    instance,
+                    operation,
+                    operationOptions,
+                    handler: null,
+                    topics: null,
+                };
+                this._createHandler(args);
+                this._handlerArgs.push(args);
             }
-            this._controllerInstances.set(controller, instance);
+        }
+        /** Initialize consumers */
+        for (const args of this._handlerArgs) {
+            await this._createConsumer(args);
         }
     }
     /**
-     * Creates and initializes a consumer for given operation
      *
+     * @param args
      * @protected
      */
-    async _initConsumer(controller, instance, operation) {
-        if (typeof instance[operation.name] !== 'function')
-            return;
-        const proto = controller.ctor?.prototype || Object.getPrototypeOf(controller.instance);
-        // this._config.consumers
-        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 };
-        }
+    async _createConsumer(args) {
+        const { operationOptions } = args;
         const consumerConfig = {
             groupId: constants_js_1.KAFKA_DEFAULT_GROUP,
         };
-        if (typeof operationOptions?.consumer === 'object') {
-            if (this._consumers.has(operationOptions.consumer.groupId)) {
+        let consumer;
+        if (typeof operationOptions.consumer === 'object') {
+            consumer = this._consumers.get(operationOptions.consumer.groupId);
+            if (consumer) {
                 throw new Error(`Operation consumer for groupId (${operationOptions.consumer.groupId}) already exists`);
             }
-            Object.assign(consumerConfig, operationOptions?.consumer);
+            Object.assign(consumerConfig, operationOptions.consumer);
         }
-        else if (operationOptions?.consumer) {
+        else if (operationOptions.consumer) {
             const x = this._config.consumers?.[operationOptions.consumer];
             Object.assign(consumerConfig, { ...x, groupId: operationOptions.consumer });
         }
-        const consumer = this.kafka.consumer(consumerConfig);
-        this._consumers.set(consumerConfig.groupId, {
-            consumer,
-            controller,
-            instance,
-            operation,
-            options: { ...operationOptions },
-        });
-        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)));
+        consumer = this._consumers.get(consumerConfig.groupId);
+        /** Create consumers */
+        if (!consumer) {
+            consumer = this.kafka.consumer(consumerConfig);
+            consumer[kGroupId] = consumerConfig.groupId;
+            this._consumers.set(consumerConfig.groupId, consumer);
+        }
+        args.consumer = consumer;
     }
     /**
-     * Starts all consumers
+     *
+     * @param args
      * @protected
      */
-    async _startConsumer(args) {
-        const { consumer, controller, instance, operation, options } = args;
+    _createHandler(args) {
+        const { controller, instance, operation } = args;
         /** Prepare parsers */
         const parseKey = request_parser_js_1.RequestParser.STRING;
         const parsePayload = request_parser_js_1.RequestParser.STRING;
@@ -171,81 +236,56 @@ class KafkaAdapter extends core_1.PlatformAdapter {
                 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);
-                        }
-                    }
+        args.handler = 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);
                 }
-                catch (e) {
-                    this._emitError(e);
-                    return;
+                /** Parse and decode `payload` */
+                if (message.value != null) {
+                    const s = parsePayload(message.value);
+                    payload = decodePayload(s);
                 }
-                /** 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;
-        });
+                /** 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('before-execute', ctx);
+            const result = await operationHandler.call(instance, ctx);
+            await this.emitAsync('after-execute', ctx, result);
+        };
     }
     _emitError(e) {
         this._logger?.error(e);
@@ -254,7 +294,7 @@ class KafkaAdapter extends core_1.PlatformAdapter {
     }
     _createLogCreator(logger, logExtra) {
         return ({ namespace, level, log }) => {
-            const { message, ...extra } = log;
+            const { message, error, ...extra } = log;
             delete extra.namespace;
             delete extra.timestamp;
             delete extra.logger;
@@ -278,8 +318,8 @@ class KafkaAdapter extends core_1.PlatformAdapter {
             if (!fn)
                 return;
             if (!logExtra)
-                return fn.call(logger, message);
-            return fn.call(logger, message, {
+                return fn.call(logger, error || message);
+            return fn.call(logger, error || message, {
                 ...extra,
                 namespace,
             });

package/cjs/kafka-context.js

@@ -18,6 +18,7 @@ class KafkaContext extends core_1.ExecutionContext {
             this.operationHandler = init.operationHandler;
         this.partition = init.partition;
         this.headers = init.headers || {};
+        this.topic = init.topic;
         this.key = init.key;
         this.payload = init.payload;
         this.heartbeat = init.heartbeat;

package/esm/kafka-adapter.js

@@ -7,6 +7,7 @@ import { KafkaContext } from './kafka-context.js';
 import { RequestParser } from './request-parser.js';
 const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
 const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+const kGroupId = Symbol('kGroupId');
 /**
  *
  * @class KafkaAdapter
@@ -21,6 +22,7 @@ export class KafkaAdapter extends PlatformAdapter {
         super(config.document, config);
         this._controllerInstances = new Map();
         this._consumers = new Map();
+        this._handlerArgs = [];
         this.protocol = 'rpc';
         this.platform = KafkaAdapter.PlatformName;
         if (!(config.document.api instanceof RpcApi && config.document.api.platform === KafkaAdapter.PlatformName)) {
@@ -53,24 +55,71 @@ export class KafkaAdapter extends PlatformAdapter {
         /* istanbul ignore next */
         if (this._consumers.size > 0)
             return;
-        await this._initConsumers();
-        return this._start();
+        /* istanbul ignore next */
+        if (this._consumers.size > 0)
+            return;
+        await this._createAllConsumers();
+        /** Connect all consumers */
+        for (const consumer of this._consumers.values()) {
+            await consumer.connect().catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
+        /** Subscribe to channels */
+        for (const args of this._handlerArgs) {
+            const { consumer, operation, operationOptions } = args;
+            args.topics = Array.isArray(operation.channel) ? operation.channel : [operation.channel];
+            await consumer.subscribe({ topics: args.topics, fromBeginning: operationOptions.fromBeginning }).catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+            this.logger?.info?.(`Subscribed to topic${args.topics.length > 1 ? 's' : ''} "${args.topics}"`);
+        }
+        /** Start consumer listeners */
+        const topicMap = new Map();
+        for (const consumer of this._consumers.values()) {
+            const groupId = consumer[kGroupId];
+            await consumer
+                .run({
+                eachMessage: async (payload) => {
+                    await this.emitAsync('message', payload).catch(() => undefined);
+                    const { topic } = payload;
+                    const topicCacheKey = groupId + ':' + topic;
+                    let handlerArgsArray = topicMap.get(topicCacheKey);
+                    if (!handlerArgsArray) {
+                        handlerArgsArray = this._handlerArgs.filter(args => args.consumer === consumer &&
+                            args.topics.find(t => (t instanceof RegExp ? t.test(topic) : t === topic)));
+                        /* istanbul ignore next */
+                        if (!handlerArgsArray) {
+                            this._emitError(new Error(`Unhandled topic (${topic})`));
+                            return;
+                        }
+                        topicMap.set(topicCacheKey, handlerArgsArray);
+                    }
+                    /** Iterate and call all matching handlers */
+                    for (const args of handlerArgsArray) {
+                        try {
+                            await args.handler(payload);
+                        }
+                        catch (e) {
+                            this._emitError(e);
+                        }
+                    }
+                    await this.emitAsync('message-finish', payload);
+                },
+            })
+                .catch(e => {
+                this._emitError(e);
+                throw e;
+            });
+        }
     }
     /**
      * 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.values()).map(c => c.consumer.disconnect()));
+        await Promise.allSettled(Array.from(this._consumers.values()).map(c => c.disconnect()));
         this._consumers.clear();
         this._controllerInstances.clear();
     }
@@ -79,82 +128,98 @@ export class KafkaAdapter extends PlatformAdapter {
         return controller && this._controllerInstances.get(controller);
     }
     /**
-     * Creates and initializes all consumers
      *
+     * @param controller
+     * @param instance
+     * @param operation
      * @protected
      */
-    async _initConsumers() {
-        /* istanbul ignore next */
-        if (this._consumers.size > 0)
+    async _getOperationOptions(controller, instance, operation) {
+        if (typeof instance[operation.name] !== 'function')
             return;
-        /** Create consumers */
+        const proto = controller.ctor?.prototype || Object.getPrototypeOf(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 };
+        }
+        return operationOptions;
+    }
+    /**
+     *
+     * @protected
+     */
+    async _createAllConsumers() {
         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()) {
-                await this._initConsumer(controller, instance, operation);
+                const operationOptions = await this._getOperationOptions(controller, instance, operation);
+                if (!operationOptions)
+                    continue;
+                // const consumerConfig = this._getConsumerConfig(operationOptions);
+                const args = {
+                    consumer: null,
+                    controller,
+                    instance,
+                    operation,
+                    operationOptions,
+                    handler: null,
+                    topics: null,
+                };
+                this._createHandler(args);
+                this._handlerArgs.push(args);
             }
-            this._controllerInstances.set(controller, instance);
+        }
+        /** Initialize consumers */
+        for (const args of this._handlerArgs) {
+            await this._createConsumer(args);
         }
     }
     /**
-     * Creates and initializes a consumer for given operation
      *
+     * @param args
      * @protected
      */
-    async _initConsumer(controller, instance, operation) {
-        if (typeof instance[operation.name] !== 'function')
-            return;
-        const proto = controller.ctor?.prototype || Object.getPrototypeOf(controller.instance);
-        // this._config.consumers
-        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 };
-        }
+    async _createConsumer(args) {
+        const { operationOptions } = args;
         const consumerConfig = {
             groupId: KAFKA_DEFAULT_GROUP,
         };
-        if (typeof operationOptions?.consumer === 'object') {
-            if (this._consumers.has(operationOptions.consumer.groupId)) {
+        let consumer;
+        if (typeof operationOptions.consumer === 'object') {
+            consumer = this._consumers.get(operationOptions.consumer.groupId);
+            if (consumer) {
                 throw new Error(`Operation consumer for groupId (${operationOptions.consumer.groupId}) already exists`);
             }
-            Object.assign(consumerConfig, operationOptions?.consumer);
+            Object.assign(consumerConfig, operationOptions.consumer);
         }
-        else if (operationOptions?.consumer) {
+        else if (operationOptions.consumer) {
             const x = this._config.consumers?.[operationOptions.consumer];
             Object.assign(consumerConfig, { ...x, groupId: operationOptions.consumer });
         }
-        const consumer = this.kafka.consumer(consumerConfig);
-        this._consumers.set(consumerConfig.groupId, {
-            consumer,
-            controller,
-            instance,
-            operation,
-            options: { ...operationOptions },
-        });
-        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)));
+        consumer = this._consumers.get(consumerConfig.groupId);
+        /** Create consumers */
+        if (!consumer) {
+            consumer = this.kafka.consumer(consumerConfig);
+            consumer[kGroupId] = consumerConfig.groupId;
+            this._consumers.set(consumerConfig.groupId, consumer);
+        }
+        args.consumer = consumer;
     }
     /**
-     * Starts all consumers
+     *
+     * @param args
      * @protected
      */
-    async _startConsumer(args) {
-        const { consumer, controller, instance, operation, options } = args;
+    _createHandler(args) {
+        const { controller, instance, operation } = args;
         /** Prepare parsers */
         const parseKey = RequestParser.STRING;
         const parsePayload = RequestParser.STRING;
@@ -168,81 +233,56 @@ export class KafkaAdapter extends PlatformAdapter {
                 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);
-                        }
-                    }
+        args.handler = 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);
                 }
-                catch (e) {
-                    this._emitError(e);
-                    return;
+                /** Parse and decode `payload` */
+                if (message.value != null) {
+                    const s = parsePayload(message.value);
+                    payload = decodePayload(s);
                 }
-                /** 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;
-        });
+                /** 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('before-execute', ctx);
+            const result = await operationHandler.call(instance, ctx);
+            await this.emitAsync('after-execute', ctx, result);
+        };
     }
     _emitError(e) {
         this._logger?.error(e);
@@ -251,7 +291,7 @@ export class KafkaAdapter extends PlatformAdapter {
     }
     _createLogCreator(logger, logExtra) {
         return ({ namespace, level, log }) => {
-            const { message, ...extra } = log;
+            const { message, error, ...extra } = log;
             delete extra.namespace;
             delete extra.timestamp;
             delete extra.logger;
@@ -275,8 +315,8 @@ export class KafkaAdapter extends PlatformAdapter {
             if (!fn)
                 return;
             if (!logExtra)
-                return fn.call(logger, message);
-            return fn.call(logger, message, {
+                return fn.call(logger, error || message);
+            return fn.call(logger, error || message, {
                 ...extra,
                 namespace,
             });

package/esm/kafka-context.js

@@ -15,6 +15,7 @@ export class KafkaContext extends ExecutionContext {
             this.operationHandler = init.operationHandler;
         this.partition = init.partition;
         this.headers = init.headers || {};
+        this.topic = init.topic;
         this.key = init.key;
         this.payload = init.payload;
         this.heartbeat = init.heartbeat;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@opra/kafka",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.1",
   "description": "Opra Kafka package",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
-    "@opra/common": "^1.0.0-beta.5",
-    "@opra/core": "^1.0.0-beta.5",
+    "@opra/common": "^1.0.1",
+    "@opra/core": "^1.0.1",
     "node-events-async": "^1.0.0",
     "tslib": "^2.7.0",
     "valgen": "^5.10.0"

package/types/kafka-adapter.d.ts

@@ -1,6 +1,6 @@
 import { ApiDocument, OpraSchema, RpcApi, RpcController, RpcOperation } from '@opra/common';
 import { type ILogger, PlatformAdapter } from '@opra/core';
-import { type Consumer, ConsumerConfig, Kafka, type KafkaConfig } from 'kafkajs';
+import { type Consumer, ConsumerConfig, EachMessageHandler, Kafka, type KafkaConfig } from 'kafkajs';
 import type { StrictOmit } from 'ts-gems';
 import { KafkaContext } from './kafka-context.js';
 /**
@@ -34,6 +34,15 @@ export declare namespace KafkaAdapter {
         intercept(context: KafkaContext, next: NextCallback): Promise<any>;
     };
 }
+interface HandlerArguments {
+    consumer: Consumer;
+    controller: RpcController;
+    instance: any;
+    operation: RpcOperation;
+    operationOptions: KafkaAdapter.OperationOptions;
+    handler: EachMessageHandler;
+    topics: (string | RegExp)[];
+}
 /**
  *
  * @class KafkaAdapter
@@ -42,13 +51,8 @@ export declare class KafkaAdapter extends PlatformAdapter {
     static readonly PlatformName = "kafka";
     protected _config: KafkaAdapter.Config;
     protected _controllerInstances: Map<RpcController, any>;
-    protected _consumers: Map<string, {
-        consumer: Consumer;
-        controller: RpcController;
-        instance: any;
-        operation: RpcOperation;
-        options: KafkaAdapter.OperationOptions;
-    }>;
+    protected _consumers: Map<string, Consumer>;
+    protected _handlerArgs: HandlerArguments[];
     protected _logger?: ILogger;
     readonly kafka: Kafka;
     readonly protocol: OpraSchema.Transport;
@@ -71,29 +75,30 @@ export declare class KafkaAdapter extends PlatformAdapter {
     close(): Promise<void>;
     getControllerInstance<T>(controllerPath: string): T | undefined;
     /**
-     * Creates and initializes all consumers
+     *
+     * @param controller
+     * @param instance
+     * @param operation
+     * @protected
+     */
+    protected _getOperationOptions(controller: RpcController, instance: any, operation: RpcOperation): Promise<KafkaAdapter.OperationOptions | undefined>;
+    /**
      *
      * @protected
      */
-    protected _initConsumers(): Promise<void>;
+    protected _createAllConsumers(): Promise<void>;
     /**
-     * Creates and initializes a consumer for given operation
      *
+     * @param args
      * @protected
      */
-    protected _initConsumer(controller: RpcController, instance: any, operation: RpcOperation): Promise<void>;
-    protected _start(): Promise<void>;
+    protected _createConsumer(args: HandlerArguments): Promise<void>;
     /**
-     * Starts all consumers
+     *
+     * @param args
      * @protected
      */
-    protected _startConsumer(args: {
-        consumer: Consumer;
-        controller: RpcController;
-        instance: any;
-        operation: RpcOperation;
-        options: KafkaAdapter.OperationOptions;
-    }): Promise<void>;
+    protected _createHandler(args: HandlerArguments): void;
     protected _emitError(e: any): void;
     protected _createLogCreator(logger: ILogger, logExtra?: boolean): ({ namespace, level, log }: {
         namespace: any;
@@ -101,3 +106,4 @@ export declare class KafkaAdapter extends PlatformAdapter {
         log: any;
     }) => any;
 }
+export {};

package/types/kafka-context.d.ts

@@ -28,6 +28,7 @@ export declare class KafkaContext extends ExecutionContext implements AsyncEvent
     readonly controllerInstance?: any;
     readonly operation?: RpcOperation;
     readonly operationHandler?: Function;
+    readonly topic: string;
     readonly key: any;
     readonly payload: any;
     readonly partition: number;