@rsdk/kafka.common 4.0.0-next.0 → 4.0.0-next.10

package/dist/index.js

@@ -14,33 +14,38 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KafkaHealthcheck = exports.isEventType = exports.getTopicName = exports.createLoggerAdapter = exports.ServerKafkaExceptionFactory = exports.KafkaTopicType = exports.KAFKA_TOPIC_RSDK_METADATA_SCOPE = exports.KafkaMetadataProvider = exports.KafkaMetadataModule = exports.KafkaConfig = exports.KafkaClientModule = exports.KAFKA_CLIENT_INJECTION_TOKEN = exports.KAFKA_PRODUCER_INJECTION_TOKEN = exports.retryPolicy = void 0;
-var retry_policy_1 = require("./retry-policy");
-Object.defineProperty(exports, "retryPolicy", { enumerable: true, get: function () { return retry_policy_1.retryPolicy; } });
-var kafka_client_1 = require("./client/kafka.client");
-Object.defineProperty(exports, "KAFKA_PRODUCER_INJECTION_TOKEN", { enumerable: true, get: function () { return kafka_client_1.KAFKA_PRODUCER_INJECTION_TOKEN; } });
-Object.defineProperty(exports, "KAFKA_CLIENT_INJECTION_TOKEN", { enumerable: true, get: function () { return kafka_client_1.KAFKA_CLIENT_INJECTION_TOKEN; } });
+exports.KafkaBaseIndicator = exports.isEventType = exports.getTopicName = exports.createLoggerAdapter = exports.handleKafkaError = exports.TopicType = exports.KAFKA_TOPIC_RSDK_METADATA_SCOPE = exports.TopicsService = exports.KafkaConfig = exports.KafkaClientModule = exports.JSONEventCodec = exports.ProtoEventCodec = exports.INFINITE_RETRIES = exports.KAFKA_CLIENT_INJECTION_TOKEN = exports.KAFKA_PRODUCER_INJECTION_TOKEN = exports.InjectKafkaProducer = exports.InjectKafka = void 0;
+var inject_kafka_decorator_1 = require("./client/decorators/inject-kafka.decorator");
+Object.defineProperty(exports, "InjectKafka", { enumerable: true, get: function () { return inject_kafka_decorator_1.InjectKafka; } });
+var inject_producer_decorator_1 = require("./client/decorators/inject-producer.decorator");
+Object.defineProperty(exports, "InjectKafkaProducer", { enumerable: true, get: function () { return inject_producer_decorator_1.InjectKafkaProducer; } });
+var constants_1 = require("./client/constants");
+Object.defineProperty(exports, "KAFKA_PRODUCER_INJECTION_TOKEN", { enumerable: true, get: function () { return constants_1.KAFKA_PRODUCER_INJECTION_TOKEN; } });
+Object.defineProperty(exports, "KAFKA_CLIENT_INJECTION_TOKEN", { enumerable: true, get: function () { return constants_1.KAFKA_CLIENT_INJECTION_TOKEN; } });
+var retry_policy_infinite_1 = require("./utils/retry-policy.infinite");
+Object.defineProperty(exports, "INFINITE_RETRIES", { enumerable: true, get: function () { return retry_policy_infinite_1.INFINITE_RETRIES; } });
+var event_codec_1 = require("./utils/event.codec");
+Object.defineProperty(exports, "ProtoEventCodec", { enumerable: true, get: function () { return event_codec_1.ProtoEventCodec; } });
+Object.defineProperty(exports, "JSONEventCodec", { enumerable: true, get: function () { return event_codec_1.JSONEventCodec; } });
 var kafka_client_module_1 = require("./client/kafka-client.module");
 Object.defineProperty(exports, "KafkaClientModule", { enumerable: true, get: function () { return kafka_client_module_1.KafkaClientModule; } });
 var kafka_config_1 = require("./client/kafka.config");
 Object.defineProperty(exports, "KafkaConfig", { enumerable: true, get: function () { return kafka_config_1.KafkaConfig; } });
-var kafka_metadata_module_1 = require("./metadata/kafka-metadata.module");
-Object.defineProperty(exports, "KafkaMetadataModule", { enumerable: true, get: function () { return kafka_metadata_module_1.KafkaMetadataModule; } });
-var kafka_metadata_provider_1 = require("./metadata/kafka-metadata.provider");
-Object.defineProperty(exports, "KafkaMetadataProvider", { enumerable: true, get: function () { return kafka_metadata_provider_1.KafkaMetadataProvider; } });
-var kafka_metadata_1 = require("./metadata/kafka.metadata");
+var topics_service_1 = require("./client/providers/topics.service");
+Object.defineProperty(exports, "TopicsService", { enumerable: true, get: function () { return topics_service_1.TopicsService; } });
+var kafka_metadata_1 = require("./client/kafka.metadata");
 Object.defineProperty(exports, "KAFKA_TOPIC_RSDK_METADATA_SCOPE", { enumerable: true, get: function () { return kafka_metadata_1.KAFKA_TOPIC_RSDK_METADATA_SCOPE; } });
-Object.defineProperty(exports, "KafkaTopicType", { enumerable: true, get: function () { return kafka_metadata_1.KafkaTopicType; } });
-var exception_1 = require("./exception");
-Object.defineProperty(exports, "ServerKafkaExceptionFactory", { enumerable: true, get: function () { return exception_1.ServerKafkaExceptionFactory; } });
-var create_logger_adapter_fn_1 = require("./create-logger-adapter.fn");
+Object.defineProperty(exports, "TopicType", { enumerable: true, get: function () { return kafka_metadata_1.TopicType; } });
+var handle_kafka_error_fn_1 = require("./utils/handle-kafka.error.fn");
+Object.defineProperty(exports, "handleKafkaError", { enumerable: true, get: function () { return handle_kafka_error_fn_1.handleKafkaError; } });
+var create_logger_adapter_fn_1 = require("./utils/create-logger-adapter.fn");
 Object.defineProperty(exports, "createLoggerAdapter", { enumerable: true, get: function () { return create_logger_adapter_fn_1.createLoggerAdapter; } });
 var event_type_1 = require("./event.type");
 Object.defineProperty(exports, "getTopicName", { enumerable: true, get: function () { return event_type_1.getTopicName; } });
 Object.defineProperty(exports, "isEventType", { enumerable: true, get: function () { return event_type_1.isEventType; } });
-var kafka_healthcheck_1 = require("./client/kafka.healthcheck");
-Object.defineProperty(exports, "KafkaHealthcheck", { enumerable: true, get: function () { return kafka_healthcheck_1.KafkaHealthcheck; } });
+var kafka_base_indicator_1 = require("./client/kafka.base-indicator");
+Object.defineProperty(exports, "KafkaBaseIndicator", { enumerable: true, get: function () { return kafka_base_indicator_1.KafkaBaseIndicator; } });
 __exportStar(require("./payload-format"), exports);
-__exportStar(require("./exceptions/payload-format-validator.exception"), exports);
-__exportStar(require("./validators/payload-format.validator"), exports);
+__exportStar(require("./exceptions/payload-format.exception"), exports);
+__exportStar(require("./exceptions/missing-topics.exception"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AAEpB,sDAG+B;AAF7B,8HAAA,8BAA8B,OAAA;AAC9B,4HAAA,4BAA4B,OAAA;AAG9B,oEAAiE;AAAxD,wHAAA,iBAAiB,OAAA;AAE1B,sDAAoD;AAA3C,2GAAA,WAAW,OAAA;AAEpB,0EAAuE;AAA9D,4HAAA,mBAAmB,OAAA;AAE5B,8EAA2E;AAAlE,gIAAA,qBAAqB,OAAA;AAC9B,4DAImC;AAHjC,iIAAA,+BAA+B,OAAA;AAE/B,gHAAA,cAAc,OAAA;AAGhB,yCAA0D;AAAjD,wHAAA,2BAA2B,OAAA;AAEpC,uEAAiE;AAAxD,+HAAA,mBAAmB,OAAA;AAE5B,2CAAoE;AAA3D,0GAAA,YAAY,OAAA;AAAE,yGAAA,WAAW,OAAA;AAElC,gEAA8D;AAArD,qHAAA,gBAAgB,OAAA;AAEzB,mDAAiC;AACjC,kFAAgE;AAChE,wEAAsD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAEA,qFAAyE;AAAhE,qHAAA,WAAW,OAAA;AACpB,2FAAoF;AAA3E,gIAAA,mBAAmB,OAAA;AAC5B,gDAG4B;AAF1B,2HAAA,8BAA8B,OAAA;AAC9B,yHAAA,4BAA4B,OAAA;AAE9B,uEAAiE;AAAxD,yHAAA,gBAAgB,OAAA;AAGzB,mDAI6B;AAH3B,8GAAA,eAAe,OAAA;AAEf,6GAAA,cAAc,OAAA;AAGhB,oEAAiE;AAAxD,wHAAA,iBAAiB,OAAA;AAE1B,sDAAoD;AAA3C,2GAAA,WAAW,OAAA;AAEpB,oEAAkE;AAAzD,+GAAA,aAAa,OAAA;AACtB,0DAIiC;AAH/B,iIAAA,+BAA+B,OAAA;AAE/B,2GAAA,SAAS,OAAA;AAGX,uEAAiE;AAAxD,yHAAA,gBAAgB,OAAA;AAEzB,6EAAuE;AAA9D,+HAAA,mBAAmB,OAAA;AAE5B,2CAAoE;AAA3D,0GAAA,YAAY,OAAA;AAAE,yGAAA,WAAW,OAAA;AAElC,sEAAmE;AAA1D,0HAAA,kBAAkB,OAAA;AAE3B,mDAAiC;AACjC,wEAAsD;AACtD,wEAAsD"}

package/dist/payload-format.d.ts

@@ -1,6 +1,27 @@
+/**
+ * Способ сериализации данных события
+ */
 export declare enum PayloadFormat {
     PROTOBUF = "protobuf",
     JSON = "json"
 }
+/**
+ * Проверяет, является ли переданная строка - одним
+ * из значений перечисления PayloadFormat
+ */
+export declare const isPayloadFormat: (value: string) => value is PayloadFormat;
+/**
+ * Проверяет, является ли переданная строка - одним
+ * из значений перечисления PayloadFormat. В случае,
+ * если передано неверное значение - бросает ошибку
+ */
+export declare const assertIsPayloadFormat: (value: string) => asserts value is PayloadFormat;
+/**
+ * Заголовок в kafka, через который передаётся способ
+ * сериализации
+ */
 export declare const X_FORMAT_HEADER = "X-Format";
+/**
+ * Сериализация по умолчанию (protobuf)
+ */
 export declare const DEFAULT_PAYLOAD_FORMAT = PayloadFormat.PROTOBUF;

package/dist/payload-format.js

@@ -1,11 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PAYLOAD_FORMAT = exports.X_FORMAT_HEADER = exports.PayloadFormat = void 0;
+exports.DEFAULT_PAYLOAD_FORMAT = exports.X_FORMAT_HEADER = exports.assertIsPayloadFormat = exports.isPayloadFormat = exports.PayloadFormat = void 0;
+const common_1 = require("@rsdk/common");
+const payload_format_exception_1 = require("./exceptions/payload-format.exception");
+/**
+ * Способ сериализации данных события
+ */
 var PayloadFormat;
 (function (PayloadFormat) {
     PayloadFormat["PROTOBUF"] = "protobuf";
     PayloadFormat["JSON"] = "json";
 })(PayloadFormat || (exports.PayloadFormat = PayloadFormat = {}));
+const allowed = common_1.Enum.values(PayloadFormat);
+/**
+ * Проверяет, является ли переданная строка - одним
+ * из значений перечисления PayloadFormat
+ */
+const isPayloadFormat = (value) => allowed.includes(value);
+exports.isPayloadFormat = isPayloadFormat;
+/**
+ * Проверяет, является ли переданная строка - одним
+ * из значений перечисления PayloadFormat. В случае,
+ * если передано неверное значение - бросает ошибку
+ */
+const assertIsPayloadFormat = (value) => {
+    if ((0, exports.isPayloadFormat)(value)) {
+        return;
+    }
+    throw new payload_format_exception_1.PayloadFormatException(value, allowed);
+};
+exports.assertIsPayloadFormat = assertIsPayloadFormat;
+/**
+ * Заголовок в kafka, через который передаётся способ
+ * сериализации
+ */
 exports.X_FORMAT_HEADER = 'X-Format';
+/**
+ * Сериализация по умолчанию (protobuf)
+ */
 exports.DEFAULT_PAYLOAD_FORMAT = PayloadFormat.PROTOBUF;
 //# sourceMappingURL=payload-format.js.map

package/dist/payload-format.js.map

@@ -1 +1 @@
-{"version":3,"file":"payload-format.js","sourceRoot":"","sources":["../src/payload-format.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,sCAAqB,CAAA;IACrB,8BAAa,CAAA;AACf,CAAC,EAHW,aAAa,6BAAb,aAAa,QAGxB;AAEY,QAAA,eAAe,GAAG,UAAU,CAAC;AAE7B,QAAA,sBAAsB,GAAG,aAAa,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"payload-format.js","sourceRoot":"","sources":["../src/payload-format.ts"],"names":[],"mappings":";;;AAAA,yCAAoC;AAEpC,oFAA+E;AAE/E;;GAEG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,sCAAqB,CAAA;IACrB,8BAAa,CAAA;AACf,CAAC,EAHW,aAAa,6BAAb,aAAa,QAGxB;AAED,MAAM,OAAO,GAAG,aAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AAE3C;;;GAGG;AACI,MAAM,eAAe,GAAG,CAAC,KAAa,EAA0B,EAAE,CACvE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AADb,QAAA,eAAe,mBACF;AAE1B;;;;GAIG;AACI,MAAM,qBAAqB,GAAG,CACnC,KAAa,EACmB,EAAE;IAClC,IAAI,IAAA,uBAAe,EAAC,KAAK,CAAC,EAAE;QAC1B,OAAO;KACR;IAED,MAAM,IAAI,iDAAsB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACnD,CAAC,CAAC;AARW,QAAA,qBAAqB,yBAQhC;AAEF;;;GAGG;AACU,QAAA,eAAe,GAAG,UAAU,CAAC;AAE1C;;GAEG;AACU,QAAA,sBAAsB,GAAG,aAAa,CAAC,QAAQ,CAAC"}

package/dist/{create-logger-adapter.fn.d.ts → utils/create-logger-adapter.fn.d.ts}

@@ -1,3 +1,6 @@
 import type { ILogger } from '@rsdk/logging';
 import type { logCreator } from 'kafkajs';
+/**
+ * Creates adapter for injecting rsdk logger to kafkajs
+ */
 export declare const createLoggerAdapter: (logger: ILogger) => logCreator;

package/dist/{create-logger-adapter.fn.js → utils/create-logger-adapter.fn.js}

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLoggerAdapter = void 0;
 const common_1 = require("@rsdk/common");
 const kafkajs_1 = require("kafkajs");
+/**
+ * Creates adapter for injecting rsdk logger to kafkajs
+ */
 const createLoggerAdapter = (logger) => (_logLevel) => (entry) => {
     const { message, ...log } = entry.log;
     const params = {

package/dist/utils/create-logger-adapter.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-logger-adapter.fn.js","sourceRoot":"","sources":["../../src/utils/create-logger-adapter.fn.ts"],"names":[],"mappings":";;;AAAA,yCAA2C;AAG3C,qCAAmC;AAEnC;;GAEG;AACI,MAAM,mBAAmB,GAC9B,CAAC,MAAe,EAAc,EAAE,CAChC,CAAC,SAAmB,EAAE,EAAE,CACxB,CAAC,KAAe,EAAQ,EAAE;IACxB,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC;IACtC,MAAM,MAAM,GAAG;QACb,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,GAAG,GAAG;KACP,CAAC;IAEF,QAAQ,KAAK,CAAC,KAAK,EAAE;QACnB,KAAK,kBAAQ,CAAC,KAAK;YACjB,sFAAsF;YACtF,OAAO,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvC,KAAK,kBAAQ,CAAC,KAAK;YACjB,OAAO,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvC,KAAK,kBAAQ,CAAC,IAAI;YAChB,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACtC,KAAK,kBAAQ,CAAC,IAAI;YAChB,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACtC,KAAK,kBAAQ,CAAC,OAAO;YACnB,OAAO;QACT;YACE,IAAA,oBAAW,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;KAC5B;AACH,CAAC,CAAC;AAzBS,QAAA,mBAAmB,uBAyB5B"}

package/dist/utils/event.codec.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { EventPayload, EventType } from '../event.type';
+export interface EventCodec<E extends EventType> {
+    decode<P extends EventPayload<E> = EventPayload<E>>(buffer: Buffer): P;
+    encode<P extends EventPayload<E> = EventPayload<E>>(payload: P): Buffer;
+}
+/**
+ * Protobuf-encoding strategy
+ */
+export declare class ProtoEventCodec<E extends EventType> implements EventCodec<E> {
+    readonly eventType: E;
+    constructor(eventType: E);
+    decode<P extends EventPayload<E>>(buffer: Buffer): P;
+    encode<P extends EventPayload<E>>(payload: P): Buffer;
+}
+/**
+ * JSON-encoding strategy
+ */
+export declare class JSONEventCodec<E extends EventType> implements EventCodec<E> {
+    decode<P extends EventPayload<E>>(buffer: Buffer): P;
+    encode<P extends EventPayload<E>>(payload: P): Buffer;
+}

package/dist/utils/event.codec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONEventCodec = exports.ProtoEventCodec = void 0;
+/**
+ * Protobuf-encoding strategy
+ */
+class ProtoEventCodec {
+    eventType;
+    constructor(eventType) {
+        this.eventType = eventType;
+    }
+    decode(buffer) {
+        return this.eventType.decode(buffer);
+    }
+    encode(payload) {
+        return Buffer.from(this.eventType.encode(payload).finish());
+    }
+}
+exports.ProtoEventCodec = ProtoEventCodec;
+/**
+ * JSON-encoding strategy
+ */
+class JSONEventCodec {
+    decode(buffer) {
+        return JSON.parse(buffer.toString());
+    }
+    encode(payload) {
+        return Buffer.from(JSON.stringify(payload));
+    }
+}
+exports.JSONEventCodec = JSONEventCodec;
+//# sourceMappingURL=event.codec.js.map

package/dist/utils/event.codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.codec.js","sourceRoot":"","sources":["../../src/utils/event.codec.ts"],"names":[],"mappings":";;;AAOA;;GAEG;AACH,MAAa,eAAe;IACL;IAArB,YAAqB,SAAY;QAAZ,cAAS,GAAT,SAAS,CAAG;IAAG,CAAC;IAErC,MAAM,CAA4B,MAAc;QAC9C,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,MAAM,CAA4B,OAAU;QAC1C,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9D,CAAC;CACF;AAVD,0CAUC;AAED;;GAEG;AACH,MAAa,cAAc;IACzB,MAAM,CAA4B,MAAc;QAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;IACvC,CAAC;IAED,MAAM,CAA4B,OAAU;QAC1C,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9C,CAAC;CACF;AARD,wCAQC"}

package/dist/utils/handle-kafka.error.fn.d.ts

@@ -0,0 +1 @@
+export declare const handleKafkaError: (error: unknown, pattern: string, details?: unknown) => never;

package/dist/utils/handle-kafka.error.fn.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleKafkaError = void 0;
+const kafkajs_1 = require("kafkajs");
+const missing_topics_exception_1 = require("../exceptions/missing-topics.exception");
+const unknown_kafka_exception_1 = require("../exceptions/unknown-kafka.exception");
+const handleKafkaError = (error, pattern, details) => {
+    // https://github.com/tulios/kafkajs/blob/master/src/protocol/error.js#L26
+    if (!(error instanceof kafkajs_1.KafkaJSProtocolError) || error.code !== 3) {
+        throw new unknown_kafka_exception_1.UnknownKafkaException(error, pattern, details);
+    }
+    throw new missing_topics_exception_1.MissingTopicsException([pattern], { cause: error, details });
+};
+exports.handleKafkaError = handleKafkaError;
+//# sourceMappingURL=handle-kafka.error.fn.js.map

package/dist/utils/handle-kafka.error.fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-kafka.error.fn.js","sourceRoot":"","sources":["../../src/utils/handle-kafka.error.fn.ts"],"names":[],"mappings":";;;AAAA,qCAA+C;AAE/C,qFAAgF;AAChF,mFAA8E;AAEvE,MAAM,gBAAgB,GAAG,CAC9B,KAAc,EACd,OAAe,EACf,OAAiB,EACV,EAAE;IACT,0EAA0E;IAC1E,IAAI,CAAC,CAAC,KAAK,YAAY,8BAAoB,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE;QAChE,MAAM,IAAI,+CAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;KAC1D;IAED,MAAM,IAAI,iDAAsB,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;AACzE,CAAC,CAAC;AAXW,QAAA,gBAAgB,oBAW3B"}

package/dist/utils/retry-policy.infinite.d.ts

@@ -0,0 +1,2 @@
+import type { RetryOptions } from 'kafkajs';
+export declare const INFINITE_RETRIES: RetryOptions;

package/dist/{retry-policy.js → utils/retry-policy.infinite.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryPolicy = void 0;
-exports.retryPolicy = {
+exports.INFINITE_RETRIES = void 0;
+exports.INFINITE_RETRIES = {
     maxRetryTime: 1e3,
     retries: Number.POSITIVE_INFINITY,
     factor: 0,
     multiplier: 10,
 };
-//# sourceMappingURL=retry-policy.js.map
+//# sourceMappingURL=retry-policy.infinite.js.map

package/dist/utils/retry-policy.infinite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-policy.infinite.js","sourceRoot":"","sources":["../../src/utils/retry-policy.infinite.ts"],"names":[],"mappings":";;;AAEa,QAAA,gBAAgB,GAAiB;IAC5C,YAAY,EAAE,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC,iBAAiB;IACjC,MAAM,EAAE,CAAC;IACT,UAAU,EAAE,EAAE;CACf,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdk/kafka.common",
-  "version": "4.0.0-next.0",
+  "version": "4.0.0-next.10",
   "description": "Common functionality for kafka consumers and producers",
   "license": "Apache License 2.0",
   "publishConfig": {
@@ -11,18 +11,20 @@
   },
   "main": "dist/index.js",
   "peerDependencies": {
-    "@nestjs/common": "^10.1.3",
-    "@nestjs/microservices": "^10.1.3",
-    "@rsdk/common": "^3.5.0",
-    "@rsdk/core": "^4.0.0-next.0",
-    "@rsdk/logging": "^3.6.0",
-    "@rsdk/metadata": "^3.6.0",
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/microservices": "^10.0.0",
+    "@rsdk/common": "^4.0.0-next.10",
+    "@rsdk/core": "^4.0.0-next.10",
+    "@rsdk/logging": "^4.0.0-next.10",
+    "@rsdk/metadata": "^4.0.0-next.10",
     "kafkajs": "^2.2.4",
     "lodash": "^4.17.21",
+    "reflect-metadata": "^0.1.13",
     "rxjs": "^7.0.0"
   },
   "dependencies": {
     "protobufjs": "^7.2.3"
   },
-  "gitHead": "2d50b44d35be75f6768d4b1d57ccc6b7641bf146"
+  "gitHead": "c41d4da9aa0318d5e6417514c763618ce924f9b7"
 }

package/src/client/constants.ts

@@ -0,0 +1,2 @@
+export const KAFKA_CLIENT_INJECTION_TOKEN = Symbol('KafkaClient');
+export const KAFKA_PRODUCER_INJECTION_TOKEN = Symbol('KafkaProducer');

package/src/client/decorators/inject-kafka.decorator.ts

@@ -0,0 +1,6 @@
+import { Inject } from '@nestjs/common';
+
+import { KAFKA_CLIENT_INJECTION_TOKEN } from '../constants';
+
+export const InjectKafka = (): ParameterDecorator =>
+  Inject(KAFKA_CLIENT_INJECTION_TOKEN);

package/src/client/decorators/inject-producer.decorator.ts

@@ -0,0 +1,6 @@
+import { Inject } from '@nestjs/common';
+
+import { KAFKA_PRODUCER_INJECTION_TOKEN } from '../constants';
+
+export const InjectKafkaProducer = (): ParameterDecorator =>
+  Inject(KAFKA_PRODUCER_INJECTION_TOKEN);

package/src/client/kafka-client.module.ts

@@ -1,13 +1,12 @@
 import { Global, Module } from '@nestjs/common';
 
-import { KafkaMetadataModule } from '../metadata/kafka-metadata.module';
-
-import { KafkaClient, KafkaProducer } from './kafka.client';
+import { kafkaProvider } from './providers/kafka.provider';
+import { kafkaProducerProvider } from './providers/kafka-producer.provider';
+import { TopicsService } from './providers/topics.service';
 
 @Global()
 @Module({
-  imports: [KafkaMetadataModule],
-  providers: [KafkaClient, KafkaProducer],
-  exports: [KafkaClient, KafkaProducer, KafkaMetadataModule],
+  providers: [kafkaProducerProvider, kafkaProvider, TopicsService],
+  exports: [kafkaProducerProvider, kafkaProvider, TopicsService],
 })
 export class KafkaClientModule {}

package/src/client/{kafka.healthcheck.ts → kafka.base-indicator.ts}

@@ -1,27 +1,13 @@
+import type { HealthIndicator } from '@rsdk/core';
 import { CheckResult } from '@rsdk/core';
 import type { Kafka } from 'kafkajs';
 
-export class KafkaHealthcheck {
+export class KafkaBaseIndicator implements HealthIndicator {
   constructor(
-    readonly kafkaClient: Kafka,
-    readonly neededTopics: string[],
+    readonly client: Kafka,
+    readonly topics: string[],
   ) {}
 
-  async getMissingTopics(): Promise<string[]> {
-    const admin = this.kafkaClient.admin({
-      retry: { retries: 1 },
-    });
-
-    await admin.connect();
-
-    const topics = await admin.listTopics();
-
-    await admin.disconnect();
-    return this.neededTopics.filter(
-      (neededTopic) => !topics.includes(neededTopic),
-    );
-  }
-
   async check(): Promise<CheckResult> {
     try {
       const missingTopics = await this.getMissingTopics();
@@ -37,4 +23,17 @@ export class KafkaHealthcheck {
       });
     }
   }
+
+  private async getMissingTopics(): Promise<string[]> {
+    const admin = this.client.admin({
+      retry: { retries: 1 },
+    });
+
+    await admin.connect();
+
+    const topics = await admin.listTopics();
+
+    await admin.disconnect();
+    return this.topics.filter((neededTopic) => !topics.includes(neededTopic));
+  }
 }

package/src/{metadata → client}/kafka.metadata.ts

@@ -1,21 +1,28 @@
 import type { EventType } from '../event.type';
 
-export enum KafkaTopicType {
-  Consume,
-  Produce,
+export enum TopicType {
+  CONSUME,
+  PRODUCE,
 }
 
+/**
+ * TODO: Здесь надо разбираться с неймингом. Потому что хрен
+ * поймёшь сейчас, что это за типы
+ */
+
 export type KafkaTopicMetadataByTopic = {
-  type: KafkaTopicType;
+  type: TopicType;
   topicName: string;
 };
+
 export type KafkaTopicMetadataByEventType = {
-  type: KafkaTopicType;
+  type: TopicType;
   topicName: string;
   group: string;
   partitionKeyField: string | null;
   eventType?: Pick<EventType, '$type' | '$group' | '$partitionKeyField'>;
 };
+
 export type KafkaTopicMetadata =
   | KafkaTopicMetadataByEventType
   | KafkaTopicMetadataByTopic;

package/src/client/providers/kafka-producer.provider.ts

@@ -0,0 +1,23 @@
+import type { FactoryProvider, OnModuleDestroy } from '@nestjs/common';
+import type { Kafka, Producer } from 'kafkajs';
+import { Partitioners } from 'kafkajs';
+
+import {
+  KAFKA_CLIENT_INJECTION_TOKEN,
+  KAFKA_PRODUCER_INJECTION_TOKEN,
+} from '../constants';
+
+export const kafkaProducerProvider: FactoryProvider = {
+  inject: [KAFKA_CLIENT_INJECTION_TOKEN],
+  provide: KAFKA_PRODUCER_INJECTION_TOKEN,
+  async useFactory(kafka: Kafka): Promise<Producer & OnModuleDestroy> {
+    const producer = kafka.producer({
+      allowAutoTopicCreation: false,
+      createPartitioner: Partitioners.DefaultPartitioner,
+      retry: { retries: 1 },
+    });
+
+    await producer.connect();
+    return { ...producer, onModuleDestroy: () => producer.disconnect() };
+  },
+};

package/src/client/providers/kafka.provider.ts

@@ -0,0 +1,24 @@
+import type { FactoryProvider } from '@nestjs/common';
+import { APP_NAME } from '@rsdk/core';
+import { LoggerFactory } from '@rsdk/logging';
+import { Kafka } from 'kafkajs';
+
+import { createLoggerAdapter } from '../../utils/create-logger-adapter.fn';
+import { INFINITE_RETRIES } from '../../utils/retry-policy.infinite';
+import { KAFKA_CLIENT_INJECTION_TOKEN } from '../constants';
+import { KafkaConfig } from '../kafka.config';
+
+export const kafkaProvider: FactoryProvider = {
+  inject: [KafkaConfig, APP_NAME],
+  provide: KAFKA_CLIENT_INJECTION_TOKEN,
+  useFactory(config: KafkaConfig, name: string): Kafka {
+    const logger = LoggerFactory.create('NativeKafkaProducer');
+
+    return new Kafka({
+      clientId: `${name}-${process.pid}`,
+      brokers: config.brokers,
+      logCreator: createLoggerAdapter(logger),
+      retry: INFINITE_RETRIES,
+    });
+  },
+};

package/src/client/providers/topics.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import type { Resource } from '@rsdk/metadata';
+import { RsdkMetadataProvider } from '@rsdk/metadata';
+
+import type { KafkaTopicMetadata, TopicType } from '../kafka.metadata';
+import { KAFKA_TOPIC_RSDK_METADATA_SCOPE } from '../kafka.metadata';
+
+@Injectable()
+export class TopicsService {
+  constructor(private readonly provider: RsdkMetadataProvider) {}
+
+  getTopics(type: TopicType): string[] {
+    return this.getResources()
+      .filter(({ value }) => value.type === type)
+      .map(({ value }) => value.topicName);
+  }
+
+  private getResources(): Resource<KafkaTopicMetadata>[] {
+    return this.provider.get<KafkaTopicMetadata>(
+      KAFKA_TOPIC_RSDK_METADATA_SCOPE,
+    );
+  }
+}

package/src/event.type.ts

@@ -1,5 +1,8 @@
 import type { Reader, Writer } from 'protobufjs/minimal';
 
+/**
+ * Генерируется при компиляции proto-файлов
+ */
 export interface EventType<T = any> {
   $group: string;
   $partitionKeyField: string | null;
@@ -8,11 +11,24 @@ export interface EventType<T = any> {
   decode(data: Uint8Array | Reader): T;
 }
 
+/**
+ * Выводит тип payload из EventType
+ */
+export type EventPayload<E extends EventType> = E extends EventType<infer P>
+  ? P
+  : never;
+
+/**
+ * Проверяет, является ли переданный тип EventType
+ */
 export const isEventType = <T = any>(x: any): x is EventType<T> =>
   typeof x === 'object' &&
   typeof x.$type === 'string' &&
   typeof x.$group === 'string';
 
+/**
+ * Генерирует имя топика из EventType
+ */
 export const getTopicName = (eventType: EventType): string => {
   return `events.${eventType.$group}`;
 };

package/src/exceptions/missing-topics.exception.ts

@@ -0,0 +1,19 @@
+import { InternalException } from '@rsdk/core';
+
+export class MissingTopicsException extends InternalException {
+  constructor(
+    readonly topics: string[],
+    readonly props?: {
+      details?: unknown;
+      cause?: unknown;
+    },
+  ) {
+    super('Expected topics or partitions are missing!', {
+      details: {
+        topics,
+        details: props?.details,
+      },
+      cause: props?.cause,
+    });
+  }
+}

package/src/exceptions/payload-format.exception.ts

@@ -0,0 +1,10 @@
+import type { EnumValue } from '@rsdk/common';
+import { BootstrapException } from '@rsdk/core';
+
+export class PayloadFormatException extends BootstrapException {
+  constructor(value: string, allowed: EnumValue[]) {
+    super(
+      `PayloadFormat has wrong value: ${value}, allowed: ${allowed.join(',')}`,
+    );
+  }
+}

package/src/exceptions/unknown-kafka.exception.ts

@@ -0,0 +1,13 @@
+import { InternalException } from '@rsdk/core';
+
+export class UnknownKafkaException extends InternalException {
+  constructor(cause: unknown, pattern: string, details?: unknown) {
+    super('Unknown exception from ServerKafka!', {
+      details: {
+        pattern,
+        details: details,
+      },
+      cause,
+    });
+  }
+}