@opra/kafka 1.20.0 → 1.22.0

package/{esm/kafka-adapter.js → kafka-adapter.js}

@@ -14,6 +14,15 @@ const noOp = () => undefined;
  * @class KafkaAdapter
  */
 export class KafkaAdapter extends PlatformAdapter {
+    static PlatformName = 'kafka';
+    _config;
+    _controllerInstances = new Map();
+    _consumers = new Map();
+    _handlerArgs = [];
+    _status = 'idle';
+    transform = 'mq';
+    platform = KafkaAdapter.PlatformName;
+    interceptors;
     /**
      *
      * @param document
@@ -22,12 +31,6 @@ export class KafkaAdapter extends PlatformAdapter {
      */
     constructor(document, config) {
         super(config);
-        this._controllerInstances = new Map();
-        this._consumers = new Map();
-        this._handlerArgs = [];
-        this._status = 'idle';
-        this.transform = 'mq';
-        this.platform = KafkaAdapter.PlatformName;
         this._document = document;
         this._config = config;
         if (!(this.document.api instanceof MQApi &&
@@ -416,4 +419,3 @@ export class KafkaAdapter extends PlatformAdapter {
         };
     }
 }
-KafkaAdapter.PlatformName = 'kafka';

package/{esm/kafka-context.js → kafka-context.js}

@@ -4,6 +4,14 @@ import { ExecutionContext } from '@opra/core';
  * It extends the ExecutionContext and implements the AsyncEventEmitter.
  */
 export class KafkaContext extends ExecutionContext {
+    topic;
+    key;
+    payload;
+    partition;
+    headers;
+    rawMessage;
+    heartbeat;
+    pause;
     /**
      * Constructor
      * @param init the context options

package/package.json

@@ -1,53 +1,37 @@
 {
   "name": "@opra/kafka",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "Opra Kafka adapter",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
-    "node-events-async": "^1.2.0",
+    "node-events-async": "^1.4.0",
     "tslib": "^2.8.1",
     "valgen": "^5.18.2"
   },
   "peerDependencies": {
-    "@opra/common": "^1.20.0",
-    "@opra/core": "^1.20.0",
+    "@opra/common": "^1.22.0",
+    "@opra/core": "^1.22.0",
     "kafkajs": ">=2.2.4 <3"
   },
-  "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"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./types/index.d.ts",
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+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",

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

@@ -1,19 +0,0 @@
-"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.MQOperationDecoratorFactory.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

@@ -1,6 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-"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("./kafka-adapter.js"), exports);
-tslib_1.__exportStar(require("./kafka-context.js"), exports);
-tslib_1.__exportStar(require("./request-parser.js"), exports);

package/cjs/kafka-adapter.js

@@ -1,423 +0,0 @@
-"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'];
-const kGroupId = Symbol('kGroupId');
-const noOp = () => undefined;
-/**
- *
- * @class KafkaAdapter
- */
-class KafkaAdapter extends core_1.PlatformAdapter {
-    /**
-     *
-     * @param document
-     * @param config
-     * @constructor
-     */
-    constructor(document, config) {
-        super(config);
-        this._controllerInstances = new Map();
-        this._consumers = new Map();
-        this._handlerArgs = [];
-        this._status = 'idle';
-        this.transform = 'mq';
-        this.platform = KafkaAdapter.PlatformName;
-        this._document = document;
-        this._config = config;
-        if (!(this.document.api instanceof common_1.MQApi &&
-            this.document.api.platform === KafkaAdapter.PlatformName)) {
-            throw new TypeError(`The document doesn't expose a Kafka 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.getMqApi();
-    }
-    get kafka() {
-        return this._kafka;
-    }
-    get scope() {
-        return this._config.scope;
-    }
-    get status() {
-        return this._status;
-    }
-    async initialize() {
-        if (this._kafka)
-            return;
-        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() {
-        if (this.status !== 'idle')
-            return;
-        await this.initialize();
-        this._status = 'starting';
-        try {
-            /** 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, operationConfig } = args;
-                args.topics = Array.isArray(operation.channel)
-                    ? operation.channel
-                    : [operation.channel];
-                await consumer
-                    .subscribe({
-                    ...operationConfig.subscribe,
-                    topics: args.topics,
-                })
-                    .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);
-                            }
-                        }
-                    },
-                })
-                    .catch(e => {
-                    this._emitError(e);
-                    throw e;
-                });
-            }
-            this._status = 'started';
-        }
-        catch (e) {
-            await this.close();
-            throw e;
-        }
-    }
-    /**
-     * Closes all connections and stops the service
-     */
-    async close() {
-        await Promise.allSettled(Array.from(this._consumers.values()).map(c => c.disconnect()));
-        this._consumers.clear();
-        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.MQ_CONTROLLER_METADATA, proto, operation.name))
-            return;
-        const operationConfig = {
-            consumer: {
-                groupId: constants_js_1.KAFKA_DEFAULT_GROUP,
-            },
-            subscribe: {},
-        };
-        if (this._config.defaults) {
-            if (this._config.defaults.subscribe) {
-                Object.assign(operationConfig.subscribe, this._config.defaults.subscribe);
-            }
-            if (this._config.defaults.consumer) {
-                Object.assign(operationConfig.consumer, this._config.defaults.consumer);
-            }
-        }
-        let kafkaMetadata = Reflect.getMetadata(constants_js_1.KAFKA_OPERATION_METADATA, proto, operation.name);
-        if (!kafkaMetadata) {
-            const configResolver = Reflect.getMetadata(constants_js_1.KAFKA_OPERATION_METADATA_RESOLVER, proto, operation.name);
-            if (configResolver) {
-                kafkaMetadata = await configResolver();
-            }
-        }
-        if (kafkaMetadata) {
-            if (kafkaMetadata.subscribe) {
-                Object.assign(operationConfig.subscribe, kafkaMetadata.subscribe);
-            }
-            if (kafkaMetadata.consumer) {
-                if (typeof kafkaMetadata.consumer === 'object') {
-                    Object.assign(operationConfig.consumer, kafkaMetadata.consumer);
-                    operationConfig.selfConsumer = true;
-                }
-                else {
-                    const x = this._config.consumers?.[kafkaMetadata.consumer];
-                    if (x) {
-                        operationConfig.consumer.groupId = kafkaMetadata.consumer;
-                        Object.assign(operationConfig.consumer, x);
-                    }
-                }
-            }
-        }
-        return operationConfig;
-    }
-    /**
-     *
-     * @protected
-     */
-    async _createAllConsumers() {
-        for (const controller of this.document.getMqApi().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: null,
-                };
-                this._createHandler(args);
-                this._handlerArgs.push(args);
-            }
-        }
-        /** Initialize consumers */
-        for (const args of this._handlerArgs) {
-            await this._createConsumer(args);
-        }
-    }
-    /**
-     *
-     * @param args
-     * @protected
-     */
-    async _createConsumer(args) {
-        const { operationConfig } = args;
-        let consumer = this._consumers.get(operationConfig.consumer.groupId);
-        if (consumer && operationConfig.selfConsumer) {
-            throw new Error(`Operation consumer for groupId (${operationConfig.consumer.groupId}) already exists`);
-        }
-        /** Create consumers */
-        if (!consumer) {
-            consumer = this.kafka.consumer(operationConfig.consumer);
-            consumer[kGroupId] = operationConfig.consumer.groupId;
-            this._consumers.set(operationConfig.consumer.groupId, consumer);
-        }
-        args.consumer = consumer;
-    }
-    /**
-     *
-     * @param args
-     * @protected
-     */
-    _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;
-        /** Prepare decoders */
-        const decodeKey = operation.generateKeyCodec('decode', {
-            scope: this.scope,
-            ignoreReadonlyFields: true,
-        });
-        const decodePayload = operation.generateCodec('decode', {
-            scope: this.scope,
-            ignoreReadonlyFields: true,
-        });
-        operation.headers.forEach(header => {
-            let decode = this[core_1.kAssetCache].get(header, 'decode');
-            if (!decode) {
-                decode = header.generateCodec('decode', {
-                    scope: this.scope,
-                    ignoreReadonlyFields: true,
-                });
-                this[core_1.kAssetCache].set(header, 'decode', decode);
-            }
-        });
-        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);
-                }
-                /** 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 context = new kafka_context_js_1.KafkaContext({
-                __adapter: this,
-                __contDef: controller,
-                __controller: instance,
-                __oprDef: operation,
-                __handler: operationHandler,
-                topic,
-                partition,
-                payload,
-                key,
-                headers,
-                rawMessage: message,
-                heartbeat,
-                pause,
-            });
-            await this.emitAsync('execute', context);
-            try {
-                /** Call operation handler */
-                const result = await operationHandler.call(instance, context);
-                await this.emitAsync('finish', context, result);
-            }
-            catch (e) {
-                this._emitError(e, context);
-            }
-        };
-    }
-    _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 context
-                        .emitAsync('error', context.errors[0], context)
-                        .catch(noOp);
-                }
-                if (logger?.error) {
-                    context.errors.forEach(err => logger.error(err));
-                }
-            }
-            else
-                logger?.error(error);
-            if (this.listenerCount('error'))
-                this._emitError(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;
-    }
-    _createLogCreator(logger, logExtra) {
-        return ({ namespace, level, log }) => {
-            const { message, error, ...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.call(logger, error || message);
-            return fn.call(logger, error || message, {
-                ...extra,
-                namespace,
-            });
-        };
-    }
-}
-exports.KafkaAdapter = KafkaAdapter;
-KafkaAdapter.PlatformName = 'kafka';

package/cjs/kafka-context.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KafkaContext = void 0;
-const core_1 = require("@opra/core");
-/**
- * KafkaContext class provides the context for handling Kafka messages.
- * It extends the ExecutionContext and implements the AsyncEventEmitter.
- */
-class KafkaContext extends core_1.ExecutionContext {
-    /**
-     * Constructor
-     * @param init the context options
-     */
-    constructor(init) {
-        super({
-            ...init,
-            __docNode: init.__oprDef?.node ||
-                init.__contDef?.node ||
-                init.__adapter.document.node,
-            transport: 'mq',
-            platform: 'kafka',
-        });
-        if (init.__contDef)
-            this.__contDef = init.__contDef;
-        if (init.__oprDef)
-            this.__oprDef = init.__oprDef;
-        if (init.__controller)
-            this.__controller = init.__controller;
-        if (init.__handler)
-            this.__handler = init.__handler;
-        this.partition = init.partition;
-        this.headers = init.headers || {};
-        this.topic = init.topic;
-        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

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

package/cjs/parsers/binary.parser.js

@@ -1,7 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-"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/esm/package.json

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

package/types/index.d.cts

@@ -1,5 +0,0 @@
-import './augmentation/opra-common.augmentation.js';
-export * from './constants.js';
-export * from './kafka-adapter.js';
-export * from './kafka-context.js';
-export * from './request-parser.js';