@drarzter/kafka-client 0.2.2 → 0.3.0

package/dist/core.d.ts

@@ -0,0 +1,338 @@
+/**
+ * Any validation library with a `.parse()` method.
+ * Works with Zod, Valibot, ArkType, or any custom validator.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * const schema: SchemaLike<{ id: string }> = z.object({ id: z.string() });
+ * ```
+ */
+interface SchemaLike<T = any> {
+    parse(data: unknown): T;
+}
+/** Infer the output type from a SchemaLike. */
+type InferSchema<S extends SchemaLike> = S extends SchemaLike<infer T> ? T : never;
+/**
+ * A typed topic descriptor that pairs a topic name with its message type.
+ * Created via the `topic()` factory function.
+ *
+ * @typeParam N - The literal topic name string.
+ * @typeParam M - The message payload type for this topic.
+ */
+interface TopicDescriptor<N extends string = string, M extends Record<string, any> = Record<string, any>> {
+    readonly __topic: N;
+    /** @internal Phantom type — never has a real value at runtime. */
+    readonly __type: M;
+    /** Runtime schema validator. Present only when created via `topic().schema()`. */
+    readonly __schema?: SchemaLike<M>;
+}
+/**
+ * Define a typed topic descriptor.
+ *
+ * @example
+ * ```ts
+ * // Without schema — type provided explicitly:
+ * const OrderCreated = topic('order.created')<{ orderId: string; amount: number }>();
+ *
+ * // With schema — type inferred from schema:
+ * const OrderCreated = topic('order.created').schema(z.object({
+ *   orderId: z.string(),
+ *   amount: z.number(),
+ * }));
+ *
+ * // Use with KafkaClient:
+ * await kafka.sendMessage(OrderCreated, { orderId: '123', amount: 100 });
+ *
+ * // Use with @SubscribeTo:
+ * @SubscribeTo(OrderCreated)
+ * async handleOrder(msg) { ... }
+ * ```
+ */
+declare function topic<N extends string>(name: N): {
+    <M extends Record<string, any>>(): TopicDescriptor<N, M>;
+    schema<S extends SchemaLike<Record<string, any>>>(schema: S): TopicDescriptor<N, InferSchema<S>>;
+};
+/**
+ * Build a topic-message map type from a union of TopicDescriptors.
+ *
+ * @example
+ * ```ts
+ * const OrderCreated = topic('order.created')<{ orderId: string }>();
+ * const OrderCompleted = topic('order.completed')<{ completedAt: string }>();
+ *
+ * type MyTopics = TopicsFrom<typeof OrderCreated | typeof OrderCompleted>;
+ * // { 'order.created': { orderId: string }; 'order.completed': { completedAt: string } }
+ * ```
+ */
+type TopicsFrom<D extends TopicDescriptor<any, any>> = {
+    [K in D as K["__topic"]]: K["__type"];
+};
+
+/**
+ * Mapping of topic names to their message types.
+ * Define this interface to get type-safe publish/subscribe across your app.
+ *
+ * @example
+ * ```ts
+ * // with explicit extends (IDE hints for values)
+ * interface MyTopics extends TTopicMessageMap {
+ *   "orders.created": { orderId: string; amount: number };
+ *   "users.updated": { userId: string; name: string };
+ * }
+ *
+ * // or plain interface / type — works the same
+ * interface MyTopics {
+ *   "orders.created": { orderId: string; amount: number };
+ * }
+ * ```
+ */
+type TTopicMessageMap = {
+    [topic: string]: Record<string, any>;
+};
+/**
+ * Generic constraint for topic-message maps.
+ * Works with both `type` aliases and `interface` declarations.
+ */
+type TopicMapConstraint<T> = {
+    [K in keyof T]: Record<string, any>;
+};
+type ClientId = string;
+type GroupId = string;
+type MessageHeaders = Record<string, string>;
+/** Options for sending a single message. */
+interface SendOptions {
+    /** Partition key for message routing. */
+    key?: string;
+    /** Custom headers attached to the message. */
+    headers?: MessageHeaders;
+}
+/** Metadata exposed to batch consumer handlers. */
+interface BatchMeta {
+    /** Partition number for this batch. */
+    partition: number;
+    /** Highest offset available on the broker for this partition. */
+    highWatermark: string;
+    /** Send a heartbeat to the broker to prevent session timeout. */
+    heartbeat(): Promise<void>;
+    /** Mark an offset as processed (for manual offset management). */
+    resolveOffset(offset: string): void;
+    /** Commit offsets if the auto-commit threshold has been reached. */
+    commitOffsetsIfNecessary(): Promise<void>;
+}
+/** Options for configuring a Kafka consumer. */
+interface ConsumerOptions<T extends TopicMapConstraint<T> = TTopicMessageMap> {
+    /** Override the default consumer group ID from the constructor. */
+    groupId?: string;
+    /** Start reading from earliest offset. Default: `false`. */
+    fromBeginning?: boolean;
+    /** Automatically commit offsets. Default: `true`. */
+    autoCommit?: boolean;
+    /** Retry policy for failed message processing. */
+    retry?: RetryOptions;
+    /** Send failed messages to a Dead Letter Queue (`<topic>.dlq`). */
+    dlq?: boolean;
+    /** Interceptors called before/after each message. */
+    interceptors?: ConsumerInterceptor<T>[];
+    /** @internal Schema map populated by @SubscribeTo when descriptors have schemas. */
+    schemas?: Map<string, SchemaLike>;
+    /** Retry config for `consumer.subscribe()` when the topic doesn't exist yet. */
+    subscribeRetry?: SubscribeRetryOptions;
+}
+/** Configuration for consumer retry behavior. */
+interface RetryOptions {
+    /** Maximum number of retry attempts before giving up. */
+    maxRetries: number;
+    /** Base delay between retries in ms (multiplied by attempt number). Default: `1000`. */
+    backoffMs?: number;
+}
+/**
+ * Interceptor hooks for consumer message processing.
+ * All methods are optional — implement only what you need.
+ */
+interface ConsumerInterceptor<T extends TopicMapConstraint<T> = TTopicMessageMap> {
+    /** Called before the message handler. */
+    before?(message: T[keyof T], topic: string): Promise<void> | void;
+    /** Called after the message handler succeeds. */
+    after?(message: T[keyof T], topic: string): Promise<void> | void;
+    /** Called when the message handler throws. */
+    onError?(message: T[keyof T], topic: string, error: Error): Promise<void> | void;
+}
+/** Context passed to the `transaction()` callback with type-safe send methods. */
+interface TransactionContext<T extends TopicMapConstraint<T>> {
+    send<K extends keyof T>(topic: K, message: T[K], options?: SendOptions): Promise<void>;
+    send<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(descriptor: D, message: D["__type"], options?: SendOptions): Promise<void>;
+    sendBatch<K extends keyof T>(topic: K, messages: Array<{
+        value: T[K];
+        key?: string;
+        headers?: MessageHeaders;
+    }>): Promise<void>;
+    sendBatch<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(descriptor: D, messages: Array<{
+        value: D["__type"];
+        key?: string;
+        headers?: MessageHeaders;
+    }>): Promise<void>;
+}
+/** Interface describing all public methods of the Kafka client. */
+interface IKafkaClient<T extends TopicMapConstraint<T>> {
+    checkStatus(): Promise<{
+        topics: string[];
+    }>;
+    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (message: T[K[number]], topic: K[number]) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (message: D["__type"], topic: D["__topic"]) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (messages: T[K[number]][], topic: K[number], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (messages: D["__type"][], topic: D["__topic"], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    stopConsumer(): Promise<void>;
+    sendMessage<K extends keyof T>(topic: K, message: T[K], options?: SendOptions): Promise<void>;
+    sendBatch<K extends keyof T>(topic: K, messages: Array<{
+        value: T[K];
+        key?: string;
+        headers?: MessageHeaders;
+    }>): Promise<void>;
+    transaction(fn: (ctx: TransactionContext<T>) => Promise<void>): Promise<void>;
+    getClientId: () => ClientId;
+    disconnect(): Promise<void>;
+}
+/**
+ * Logger interface for KafkaClient.
+ * Compatible with NestJS Logger, console, winston, pino, or any custom logger.
+ */
+interface KafkaLogger {
+    log(message: string): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+/** Options for `KafkaClient` constructor. */
+interface KafkaClientOptions {
+    /** Auto-create topics via admin before the first `sendMessage`, `sendBatch`, or `transaction` for each topic. Useful for development — not recommended in production. */
+    autoCreateTopics?: boolean;
+    /** When `true`, string topic keys are validated against any schema previously registered via a TopicDescriptor. Default: `true`. */
+    strictSchemas?: boolean;
+    /** Custom logger. Defaults to console with `[KafkaClient:<clientId>]` prefix. */
+    logger?: KafkaLogger;
+    /** Number of partitions for auto-created topics. Default: `1`. */
+    numPartitions?: number;
+}
+/** Options for consumer subscribe retry when topic doesn't exist yet. */
+interface SubscribeRetryOptions {
+    /** Maximum number of subscribe attempts. Default: `5`. */
+    retries?: number;
+    /** Delay between retries in ms. Default: `5000`. */
+    backoffMs?: number;
+}
+
+/**
+ * Type-safe Kafka client.
+ * Wraps kafkajs with JSON serialization, retries, DLQ, transactions, and interceptors.
+ *
+ * @typeParam T - Topic-to-message type mapping for compile-time safety.
+ */
+declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClient<T> {
+    private readonly kafka;
+    private readonly producer;
+    private readonly consumers;
+    private readonly admin;
+    private readonly logger;
+    private readonly autoCreateTopicsEnabled;
+    private readonly strictSchemasEnabled;
+    private readonly numPartitions;
+    private readonly ensuredTopics;
+    private readonly defaultGroupId;
+    private readonly schemaRegistry;
+    private readonly runningConsumers;
+    private isAdminConnected;
+    readonly clientId: ClientId;
+    constructor(clientId: ClientId, groupId: GroupId, brokers: string[], options?: KafkaClientOptions);
+    /** Send a single typed message. Accepts a topic key or a TopicDescriptor. */
+    sendMessage<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(descriptor: D, message: D["__type"], options?: SendOptions): Promise<void>;
+    sendMessage<K extends keyof T>(topic: K, message: T[K], options?: SendOptions): Promise<void>;
+    /** Send multiple typed messages in one call. Accepts a topic key or a TopicDescriptor. */
+    sendBatch<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(descriptor: D, messages: Array<{
+        value: D["__type"];
+        key?: string;
+        headers?: MessageHeaders;
+    }>): Promise<void>;
+    sendBatch<K extends keyof T>(topic: K, messages: Array<{
+        value: T[K];
+        key?: string;
+        headers?: MessageHeaders;
+    }>): Promise<void>;
+    /** Execute multiple sends atomically. Commits on success, aborts on error. */
+    transaction(fn: (ctx: TransactionContext<T>) => Promise<void>): Promise<void>;
+    /** Connect the idempotent producer. Called automatically by `KafkaModule.register()`. */
+    connectProducer(): Promise<void>;
+    disconnectProducer(): Promise<void>;
+    /** Subscribe to topics and start consuming messages with the given handler. */
+    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (message: T[K[number]], topic: K[number]) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (message: D["__type"], topic: D["__topic"]) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    /** Subscribe to topics and consume messages in batches. */
+    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (messages: T[K[number]][], topic: K[number], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (messages: D["__type"][], topic: D["__topic"], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    stopConsumer(): Promise<void>;
+    /** Check broker connectivity and return available topics. */
+    checkStatus(): Promise<{
+        topics: string[];
+    }>;
+    getClientId(): ClientId;
+    /** Gracefully disconnect producer, all consumers, and admin. */
+    disconnect(): Promise<void>;
+    private getOrCreateConsumer;
+    private resolveTopicName;
+    private ensureTopic;
+    /** Register schema from descriptor into global registry (side-effect). */
+    private registerSchema;
+    /** Validate message against schema. Pure — no side-effects on registry. */
+    private validateMessage;
+    /**
+     * Build a kafkajs-ready send payload.
+     * Handles: topic resolution, schema registration, validation, JSON serialization.
+     */
+    private buildSendPayload;
+    /** Shared consumer setup: groupId check, schema map, connect, subscribe. */
+    private setupConsumer;
+    private buildSchemaMap;
+    /** Parse raw message as JSON. Returns null on failure (logs error). */
+    private parseJsonMessage;
+    /**
+     * Validate a parsed message against the schema map.
+     * On failure: logs error, sends to DLQ if enabled, calls interceptor.onError.
+     * Returns validated message or null.
+     */
+    private validateWithSchema;
+    /**
+     * Execute a handler with retry, interceptors, and DLQ support.
+     * Used by both single-message and batch consumers.
+     */
+    private executeWithRetry;
+    private sendToDlq;
+    private subscribeWithRetry;
+    private sleep;
+}
+
+/** Error thrown when a consumer message handler fails. */
+declare class KafkaProcessingError extends Error {
+    readonly topic: string;
+    readonly originalMessage: unknown;
+    readonly cause?: Error;
+    constructor(message: string, topic: string, originalMessage: unknown, options?: {
+        cause?: Error;
+    });
+}
+/** Error thrown when schema validation fails on send or consume. */
+declare class KafkaValidationError extends Error {
+    readonly topic: string;
+    readonly originalMessage: unknown;
+    readonly cause?: Error;
+    constructor(topic: string, originalMessage: unknown, options?: {
+        cause?: Error;
+    });
+}
+/** Error thrown when all retry attempts are exhausted for a message. */
+declare class KafkaRetryExhaustedError extends KafkaProcessingError {
+    readonly attempts: number;
+    constructor(topic: string, originalMessage: unknown, attempts: number, options?: {
+        cause?: Error;
+    });
+}
+
+export { type BatchMeta, type ClientId, type ConsumerInterceptor, type ConsumerOptions, type GroupId, type IKafkaClient, type InferSchema, KafkaClient, type KafkaClientOptions, type KafkaLogger, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError, type MessageHeaders, type RetryOptions, type SchemaLike, type SendOptions, type SubscribeRetryOptions, type TTopicMessageMap, type TopicDescriptor, type TopicMapConstraint, type TopicsFrom, type TransactionContext, topic };