@opra/kafka 1.0.3 → 1.0.5

package/cjs/kafka-adapter.js

@@ -11,6 +11,7 @@ const request_parser_js_1 = require("./request-parser.js");
 const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
 const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
 const kGroupId = Symbol('kGroupId');
+const noOp = () => undefined;
 /**
  *
  * @class KafkaAdapter
@@ -22,22 +23,15 @@ class KafkaAdapter extends core_1.PlatformAdapter {
      * @constructor
      */
     constructor(config) {
-        super(config.document, config);
+        super(config);
         this._controllerInstances = new Map();
         this._consumers = new Map();
         this._handlerArgs = [];
+        this._started = false;
         this.protocol = 'rpc';
         this.platform = KafkaAdapter.PlatformName;
-        if (!(config.document.api instanceof common_1.RpcApi && config.document.api.platform === KafkaAdapter.PlatformName)) {
-            throw new TypeError(`The document doesn't expose a Kafka Api`);
-        }
         this._config = config;
         this.interceptors = [...(config.interceptors || [])];
-        this.kafka = new kafkajs_1.Kafka({
-            ...config.client,
-            logCreator: config.logger ? () => this._createLogCreator(config.logger, config.logExtra) : undefined,
-        });
-        this._logger = config.logger;
         globalErrorTypes.forEach(type => {
             process.on(type, e => {
                 this._emitError(e);
@@ -51,17 +45,29 @@ class KafkaAdapter extends core_1.PlatformAdapter {
     get api() {
         return this.document.rpcApi;
     }
+    get kafka() {
+        return this._kafka;
+    }
+    async initialize(document) {
+        if (this._document)
+            throw new TypeError(`${this.constructor.name} already initialized.`);
+        if (!(document.api instanceof common_1.RpcApi && document.api.platform === KafkaAdapter.PlatformName)) {
+            throw new TypeError(`The document doesn't expose a Kafka Api`);
+        }
+        this._document = document;
+        this._kafka = new kafkajs_1.Kafka({
+            ...this._config.client,
+            logCreator: this.logger ? () => this._createLogCreator(this.logger, this._config.logExtra) : undefined,
+        });
+        await this._createAllConsumers();
+    }
     /**
      * Starts the service
      */
     async start() {
-        /* istanbul ignore next */
-        if (this._consumers.size > 0)
-            return;
-        /* istanbul ignore next */
-        if (this._consumers.size > 0)
+        if (this._started)
             return;
-        await this._createAllConsumers();
+        this._started = true;
         /** Connect all consumers */
         for (const consumer of this._consumers.values()) {
             await consumer.connect().catch(e => {
@@ -181,6 +187,7 @@ class KafkaAdapter extends core_1.PlatformAdapter {
                 else {
                     const x = this._config.consumers?.[kafkaMetadata.consumer];
                     if (x) {
+                        operationConfig.consumer.groupId = kafkaMetadata.consumer;
                         Object.assign(operationConfig.consumer, x);
                     }
                 }
@@ -292,7 +299,7 @@ class KafkaAdapter extends core_1.PlatformAdapter {
                 return;
             }
             /** Create context */
-            const ctx = new kafka_context_js_1.KafkaContext({
+            const context = new kafka_context_js_1.KafkaContext({
                 adapter: this,
                 platform: this.platform,
                 controller,
@@ -308,15 +315,42 @@ class KafkaAdapter extends core_1.PlatformAdapter {
                 heartbeat,
                 pause,
             });
-            await this.emitAsync('before-execute', ctx);
-            const result = await operationHandler.call(instance, ctx);
-            await this.emitAsync('after-execute', ctx, result);
+            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);
+            }
         };
     }
-    _emitError(e) {
-        this._logger?.error(e);
-        if (this.listenerCount('error'))
-            this.emit('error', e);
+    _emitError(e, context) {
+        Promise.resolve()
+            .then(async () => {
+            const logger = this.logger;
+            if (context) {
+                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, context));
+                }
+                return;
+            }
+            this.logger?.error(e);
+            if (this.listenerCount('error'))
+                this.emit('error', e);
+        })
+            .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;
     }
     _createLogCreator(logger, logExtra) {
         return ({ namespace, level, log }) => {

package/esm/kafka-adapter.js

@@ -1,4 +1,4 @@
-import { RPC_CONTROLLER_METADATA, RpcApi } from '@opra/common';
+import { OpraException, RPC_CONTROLLER_METADATA, RpcApi, } from '@opra/common';
 import { kAssetCache, PlatformAdapter } from '@opra/core';
 import { Kafka, logLevel } from 'kafkajs';
 import { vg } from 'valgen';
@@ -8,6 +8,7 @@ import { RequestParser } from './request-parser.js';
 const globalErrorTypes = ['unhandledRejection', 'uncaughtException'];
 const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
 const kGroupId = Symbol('kGroupId');
+const noOp = () => undefined;
 /**
  *
  * @class KafkaAdapter
@@ -19,22 +20,15 @@ export class KafkaAdapter extends PlatformAdapter {
      * @constructor
      */
     constructor(config) {
-        super(config.document, config);
+        super(config);
         this._controllerInstances = new Map();
         this._consumers = new Map();
         this._handlerArgs = [];
+        this._started = false;
         this.protocol = 'rpc';
         this.platform = KafkaAdapter.PlatformName;
-        if (!(config.document.api instanceof RpcApi && config.document.api.platform === KafkaAdapter.PlatformName)) {
-            throw new TypeError(`The document doesn't expose a Kafka Api`);
-        }
         this._config = config;
         this.interceptors = [...(config.interceptors || [])];
-        this.kafka = new Kafka({
-            ...config.client,
-            logCreator: config.logger ? () => this._createLogCreator(config.logger, config.logExtra) : undefined,
-        });
-        this._logger = config.logger;
         globalErrorTypes.forEach(type => {
             process.on(type, e => {
                 this._emitError(e);
@@ -48,17 +42,29 @@ export class KafkaAdapter extends PlatformAdapter {
     get api() {
         return this.document.rpcApi;
     }
+    get kafka() {
+        return this._kafka;
+    }
+    async initialize(document) {
+        if (this._document)
+            throw new TypeError(`${this.constructor.name} already initialized.`);
+        if (!(document.api instanceof RpcApi && document.api.platform === KafkaAdapter.PlatformName)) {
+            throw new TypeError(`The document doesn't expose a Kafka Api`);
+        }
+        this._document = document;
+        this._kafka = new Kafka({
+            ...this._config.client,
+            logCreator: this.logger ? () => this._createLogCreator(this.logger, this._config.logExtra) : undefined,
+        });
+        await this._createAllConsumers();
+    }
     /**
      * Starts the service
      */
     async start() {
-        /* istanbul ignore next */
-        if (this._consumers.size > 0)
-            return;
-        /* istanbul ignore next */
-        if (this._consumers.size > 0)
+        if (this._started)
             return;
-        await this._createAllConsumers();
+        this._started = true;
         /** Connect all consumers */
         for (const consumer of this._consumers.values()) {
             await consumer.connect().catch(e => {
@@ -178,6 +184,7 @@ export class KafkaAdapter extends PlatformAdapter {
                 else {
                     const x = this._config.consumers?.[kafkaMetadata.consumer];
                     if (x) {
+                        operationConfig.consumer.groupId = kafkaMetadata.consumer;
                         Object.assign(operationConfig.consumer, x);
                     }
                 }
@@ -289,7 +296,7 @@ export class KafkaAdapter extends PlatformAdapter {
                 return;
             }
             /** Create context */
-            const ctx = new KafkaContext({
+            const context = new KafkaContext({
                 adapter: this,
                 platform: this.platform,
                 controller,
@@ -305,15 +312,42 @@ export class KafkaAdapter extends PlatformAdapter {
                 heartbeat,
                 pause,
             });
-            await this.emitAsync('before-execute', ctx);
-            const result = await operationHandler.call(instance, ctx);
-            await this.emitAsync('after-execute', ctx, result);
+            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);
+            }
         };
     }
-    _emitError(e) {
-        this._logger?.error(e);
-        if (this.listenerCount('error'))
-            this.emit('error', e);
+    _emitError(e, context) {
+        Promise.resolve()
+            .then(async () => {
+            const logger = this.logger;
+            if (context) {
+                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, context));
+                }
+                return;
+            }
+            this.logger?.error(e);
+            if (this.listenerCount('error'))
+                this.emit('error', e);
+        })
+            .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;
     }
     _createLogCreator(logger, logExtra) {
         return ({ namespace, level, log }) => {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@opra/kafka",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Opra Kafka package",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
-    "@opra/common": "^1.0.3",
-    "@opra/core": "^1.0.3",
+    "@opra/common": "^1.0.5",
+    "@opra/core": "^1.0.5",
     "node-events-async": "^1.0.0",
-    "tslib": "^2.7.0",
+    "tslib": "^2.8.0",
     "valgen": "^5.10.0"
   },
   "peerDependencies": {

package/types/kafka-adapter.d.ts

@@ -1,4 +1,4 @@
-import { ApiDocument, OpraSchema, RpcApi, RpcController, RpcOperation } from '@opra/common';
+import { ApiDocument, OpraException, OpraSchema, RpcApi, RpcController, RpcOperation } from '@opra/common';
 import { type ILogger, PlatformAdapter } from '@opra/core';
 import { type Consumer, ConsumerConfig, EachMessageHandler, Kafka, type KafkaConfig } from 'kafkajs';
 import type { StrictOmit } from 'ts-gems';
@@ -17,9 +17,7 @@ export declare namespace KafkaAdapter {
                 fromBeginning?: boolean;
             };
         };
-        document: ApiDocument;
         interceptors?: (InterceptorFunction | IKafkaInterceptor)[];
-        logger?: ILogger;
         logExtra?: boolean;
     }
     interface OperationOptions {
@@ -66,11 +64,11 @@ export declare class KafkaAdapter extends PlatformAdapter {
     protected _controllerInstances: Map<RpcController, any>;
     protected _consumers: Map<string, Consumer>;
     protected _handlerArgs: HandlerArguments[];
-    protected _logger?: ILogger;
-    readonly kafka: Kafka;
+    protected _started: boolean;
+    protected _kafka: Kafka;
     readonly protocol: OpraSchema.Transport;
     readonly platform = "kafka";
-    interceptors: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor)[];
+    readonly interceptors: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor)[];
     /**
      *
      * @param config
@@ -78,6 +76,8 @@ export declare class KafkaAdapter extends PlatformAdapter {
      */
     constructor(config: KafkaAdapter.Config);
     get api(): RpcApi;
+    get kafka(): Kafka;
+    initialize(document: ApiDocument): Promise<void>;
     /**
      * Starts the service
      */
@@ -112,7 +112,8 @@ export declare class KafkaAdapter extends PlatformAdapter {
      * @protected
      */
     protected _createHandler(args: HandlerArguments): void;
-    protected _emitError(e: any): void;
+    protected _emitError(e: any, context?: KafkaContext): void;
+    protected _wrapExceptions(exceptions: any[]): OpraException[];
     protected _createLogCreator(logger: ILogger, logExtra?: boolean): ({ namespace, level, log }: {
         namespace: any;
         level: any;