@rsdk/kafka.common 4.0.0-next.6 → 4.0.0-next.8

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.6",
+  "version": "4.0.0-next.8",
   "description": "Common functionality for kafka consumers and producers",
   "license": "Apache License 2.0",
   "publishConfig": {
@@ -15,9 +15,9 @@
     "@nestjs/core": "^10.0.0",
     "@nestjs/microservices": "^10.0.0",
     "@rsdk/common": "^4.0.0-next.6",
-    "@rsdk/core": "^4.0.0-next.6",
+    "@rsdk/core": "^4.0.0-next.8",
     "@rsdk/logging": "^4.0.0-next.6",
-    "@rsdk/metadata": "^4.0.0-next.6",
+    "@rsdk/metadata": "^4.0.0-next.8",
     "kafkajs": "^2.2.4",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
@@ -26,5 +26,5 @@
   "dependencies": {
     "protobufjs": "^7.2.3"
   },
-  "gitHead": "85bfc2419a92579e4d8ebf57068735b4999788a9"
+  "gitHead": "bae7c74fc8be068b8bd66b403d19e2b32cf092ec"
 }

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,
+    });
+  }
+}

package/src/index.ts

@@ -1,31 +1,39 @@
-export { retryPolicy } from './retry-policy';
+export { KafkaTopicMetadataByEventType } from './client/kafka.metadata';
 
+export { InjectKafka } from './client/decorators/inject-kafka.decorator';
+export { InjectKafkaProducer } from './client/decorators/inject-producer.decorator';
 export {
   KAFKA_PRODUCER_INJECTION_TOKEN,
   KAFKA_CLIENT_INJECTION_TOKEN,
-} from './client/kafka.client';
+} from './client/constants';
+export { INFINITE_RETRIES } from './utils/retry-policy.infinite';
+export { EventPayload } from './event.type';
+
+export {
+  ProtoEventCodec,
+  EventCodec,
+  JSONEventCodec,
+} from './utils/event.codec';
 
 export { KafkaClientModule } from './client/kafka-client.module';
 
 export { KafkaConfig } from './client/kafka.config';
 
-export { KafkaMetadataModule } from './metadata/kafka-metadata.module';
-
-export { KafkaMetadataProvider } from './metadata/kafka-metadata.provider';
+export { TopicsService } from './client/providers/topics.service';
 export {
   KAFKA_TOPIC_RSDK_METADATA_SCOPE,
   KafkaTopicMetadata,
-  KafkaTopicType,
-} from './metadata/kafka.metadata';
+  TopicType,
+} from './client/kafka.metadata';
 
-export { ServerKafkaExceptionFactory } from './exception';
+export { handleKafkaError } from './utils/handle-kafka.error.fn';
 
-export { createLoggerAdapter } from './create-logger-adapter.fn';
+export { createLoggerAdapter } from './utils/create-logger-adapter.fn';
 
 export { getTopicName, isEventType, EventType } from './event.type';
 
-export { KafkaHealthcheck } from './client/kafka.healthcheck';
+export { KafkaBaseIndicator } from './client/kafka.base-indicator';
 
 export * from './payload-format';
-export * from './exceptions/payload-format-validator.exception';
-export * from './validators/payload-format.validator';
+export * from './exceptions/payload-format.exception';
+export * from './exceptions/missing-topics.exception';

package/src/payload-format.ts

@@ -1,8 +1,46 @@
+import { Enum } from '@rsdk/common';
+
+import { PayloadFormatException } from './exceptions/payload-format.exception';
+
+/**
+ * Способ сериализации данных события
+ */
 export enum PayloadFormat {
   PROTOBUF = 'protobuf',
   JSON = 'json',
 }
 
+const allowed = Enum.values(PayloadFormat);
+
+/**
+ * Проверяет, является ли переданная строка - одним
+ * из значений перечисления PayloadFormat
+ */
+export const isPayloadFormat = (value: string): value is PayloadFormat =>
+  allowed.includes(value);
+
+/**
+ * Проверяет, является ли переданная строка - одним
+ * из значений перечисления PayloadFormat. В случае,
+ * если передано неверное значение - бросает ошибку
+ */
+export const assertIsPayloadFormat = (
+  value: string,
+): asserts value is PayloadFormat => {
+  if (isPayloadFormat(value)) {
+    return;
+  }
+
+  throw new PayloadFormatException(value, allowed);
+};
+
+/**
+ * Заголовок в kafka, через который передаётся способ
+ * сериализации
+ */
 export const X_FORMAT_HEADER = 'X-Format';
 
+/**
+ * Сериализация по умолчанию (protobuf)
+ */
 export const DEFAULT_PAYLOAD_FORMAT = PayloadFormat.PROTOBUF;

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

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

package/src/utils/event.codec.ts

@@ -0,0 +1,34 @@
+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 class ProtoEventCodec<E extends EventType> implements EventCodec<E> {
+  constructor(readonly eventType: E) {}
+
+  decode<P extends EventPayload<E>>(buffer: Buffer): P {
+    return this.eventType.decode(buffer);
+  }
+
+  encode<P extends EventPayload<E>>(payload: P): Buffer {
+    return Buffer.from(this.eventType.encode(payload).finish());
+  }
+}
+
+/**
+ * JSON-encoding strategy
+ */
+export class JSONEventCodec<E extends EventType> implements EventCodec<E> {
+  decode<P extends EventPayload<E>>(buffer: Buffer): P {
+    return JSON.parse(buffer.toString());
+  }
+
+  encode<P extends EventPayload<E>>(payload: P): Buffer {
+    return Buffer.from(JSON.stringify(payload));
+  }
+}

package/src/utils/handle-kafka.error.fn.ts

@@ -0,0 +1,17 @@
+import { KafkaJSProtocolError } from 'kafkajs';
+
+import { MissingTopicsException } from '../exceptions/missing-topics.exception';
+import { UnknownKafkaException } from '../exceptions/unknown-kafka.exception';
+
+export const handleKafkaError = (
+  error: unknown,
+  pattern: string,
+  details?: unknown,
+): never => {
+  // https://github.com/tulios/kafkajs/blob/master/src/protocol/error.js#L26
+  if (!(error instanceof KafkaJSProtocolError) || error.code !== 3) {
+    throw new UnknownKafkaException(error, pattern, details);
+  }
+
+  throw new MissingTopicsException([pattern], { cause: error, details });
+};