@forklaunch/implementation-worker-kafka 0.1.3 → 0.1.4

package/lib/__test__/schemaEquality.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaEquality.test.d.ts.map

package/lib/__test__/schemaEquality.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaEquality.test.d.ts","sourceRoot":"","sources":["../../__test__/schemaEquality.test.ts"],"names":[],"mappings":""}

package/lib/__test__/schemaEquality.test.js

@@ -0,0 +1,16 @@
+import { isTrue } from '@forklaunch/common';
+import { testSchemaEquality } from '@forklaunch/core/test';
+import { KafkaWorkerOptionsSchema as TypeboxKafkaWorkerOptionsSchema } from '../schemas/typebox/kafkaWorker.schema';
+import { KafkaWorkerOptionsSchema as ZodKafkaWorkerOptionsSchema } from '../schemas/zod/kafkaWorker.schema';
+describe('schema equality', () => {
+    it('should be equal for bullmq worker', () => {
+        expect(isTrue(testSchemaEquality(ZodKafkaWorkerOptionsSchema, TypeboxKafkaWorkerOptionsSchema, {
+            brokers: ['localhost:9092'],
+            clientId: 'test',
+            groupId: 'test',
+            retries: 1,
+            interval: 1000,
+            peekCount: 1
+        }))).toBeTruthy();
+    });
+});

package/lib/consumers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './kafkaWorker.consumer';
+//# sourceMappingURL=index.d.ts.map

package/lib/consumers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../consumers/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/lib/consumers/index.js

@@ -0,0 +1 @@
+export * from './kafkaWorker.consumer';

package/lib/consumers/kafkaWorker.consumer.d.ts

@@ -0,0 +1,19 @@
+import { WorkerConsumer } from '@forklaunch/interfaces-worker/interfaces';
+import { WorkerEventEntity, WorkerFailureHandler, WorkerProcessFunction } from '@forklaunch/interfaces-worker/types';
+import { WorkerOptions } from '../types/kafkaWorker.types';
+export declare class KafkaWorkerConsumer<EventEntity extends WorkerEventEntity, Options extends WorkerOptions> implements WorkerConsumer<EventEntity> {
+    protected readonly queueName: string;
+    protected readonly options: Options;
+    protected readonly processEventsFunction: WorkerProcessFunction<EventEntity>;
+    protected readonly failureHandler: WorkerFailureHandler<EventEntity>;
+    private kafka;
+    private producer;
+    private consumer;
+    private processedMessages;
+    constructor(queueName: string, options: Options, processEventsFunction: WorkerProcessFunction<EventEntity>, failureHandler: WorkerFailureHandler<EventEntity>);
+    private setupConsumer;
+    peekEvents(): Promise<EventEntity[]>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=kafkaWorker.consumer.d.ts.map

package/lib/consumers/kafkaWorker.consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafkaWorker.consumer.d.ts","sourceRoot":"","sources":["../../consumers/kafkaWorker.consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAC1E,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,qBAAa,mBAAmB,CAC9B,WAAW,SAAS,iBAAiB,EACrC,OAAO,SAAS,aAAa,CAC7B,YAAW,cAAc,CAAC,WAAW,CAAC;IAQpC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM;IACpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO;IACnC,SAAS,CAAC,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB,CAAC,WAAW,CAAC;IAC5E,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC,WAAW,CAAC;IATtE,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,iBAAiB,CAA0B;gBAG9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,qBAAqB,EAAE,qBAAqB,CAAC,WAAW,CAAC,EACzD,cAAc,EAAE,oBAAoB,CAAC,WAAW,CAAC;YAaxD,aAAa;IA4DrB,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IA4EpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B"}

package/lib/consumers/kafkaWorker.consumer.js

@@ -0,0 +1,149 @@
+import { Kafka } from 'kafkajs';
+export class KafkaWorkerConsumer {
+    queueName;
+    options;
+    processEventsFunction;
+    failureHandler;
+    kafka;
+    producer;
+    consumer;
+    processedMessages = new Set();
+    constructor(queueName, options, processEventsFunction, failureHandler) {
+        this.queueName = queueName;
+        this.options = options;
+        this.processEventsFunction = processEventsFunction;
+        this.failureHandler = failureHandler;
+        this.kafka = new Kafka({
+            clientId: this.options.clientId,
+            brokers: this.options.brokers
+        });
+        this.producer = this.kafka.producer();
+        this.consumer = this.kafka.consumer({
+            groupId: this.options.groupId
+        });
+    }
+    async setupConsumer() {
+        await this.consumer.connect();
+        await this.consumer.subscribe({
+            topic: this.queueName,
+            fromBeginning: false
+        });
+        await this.consumer.run({
+            eachMessage: async ({ topic, partition, message }) => {
+                if (!message.value)
+                    return;
+                const messageKey = `${topic}-${partition}-${message.offset}`;
+                if (this.processedMessages.has(messageKey)) {
+                    return;
+                }
+                const events = JSON.parse(message.value.toString());
+                try {
+                    await this.processEventsFunction(events);
+                    this.processedMessages.add(messageKey);
+                    await this.consumer.commitOffsets([
+                        {
+                            topic,
+                            partition,
+                            offset: (parseInt(message.offset) + 1).toString()
+                        }
+                    ]);
+                }
+                catch (error) {
+                    this.failureHandler([
+                        {
+                            value: events[0],
+                            error: error
+                        }
+                    ]);
+                    for (const event of events) {
+                        if (event.retryCount <= this.options.retries) {
+                            await this.producer.send({
+                                topic: this.queueName,
+                                messages: [
+                                    {
+                                        value: JSON.stringify([
+                                            {
+                                                ...event,
+                                                retryCount: event.retryCount + 1
+                                            }
+                                        ]),
+                                        key: event.id
+                                    }
+                                ]
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    }
+    async peekEvents() {
+        const events = [];
+        const admin = this.kafka.admin();
+        await admin.connect();
+        try {
+            // Get topic metadata to find partitions
+            const metadata = await admin.fetchTopicMetadata({
+                topics: [this.queueName]
+            });
+            const topic = metadata.topics[0];
+            if (!topic) {
+                return events;
+            }
+            // For each partition, get the latest offset
+            for (const partition of topic.partitions) {
+                const offsets = await admin.fetchTopicOffsets(this.queueName);
+                const partitionOffset = offsets.find((o) => o.partition === partition.partitionId);
+                if (!partitionOffset) {
+                    continue;
+                }
+                // Create a temporary consumer to read messages
+                const peekConsumer = this.kafka.consumer({
+                    groupId: `${this.options.groupId}-peek-${Date.now()}`
+                });
+                try {
+                    await peekConsumer.connect();
+                    await peekConsumer.subscribe({
+                        topic: this.queueName,
+                        fromBeginning: false
+                    });
+                    const messagePromise = new Promise((resolve) => {
+                        peekConsumer.run({
+                            eachMessage: async ({ message }) => {
+                                if (message.value && events.length < this.options.peekCount) {
+                                    const messageEvents = JSON.parse(message.value.toString());
+                                    events.push(...messageEvents);
+                                    if (events.length >= this.options.peekCount) {
+                                        resolve();
+                                    }
+                                }
+                            }
+                        });
+                    });
+                    await Promise.race([
+                        messagePromise,
+                        new Promise((resolve) => setTimeout(resolve, 5000))
+                    ]);
+                    if (events.length >= this.options.peekCount) {
+                        break;
+                    }
+                }
+                finally {
+                    await peekConsumer.disconnect();
+                }
+            }
+            return events;
+        }
+        finally {
+            await admin.disconnect();
+        }
+    }
+    async start() {
+        await this.setupConsumer();
+        await this.producer.connect();
+    }
+    async close() {
+        await this.producer.disconnect();
+        await this.consumer.disconnect();
+    }
+}

package/lib/eject/consumers/index.ts

@@ -0,0 +1 @@
+export * from './kafkaWorker.consumer';

package/lib/eject/consumers/kafkaWorker.consumer.ts

@@ -0,0 +1,182 @@
+import { WorkerConsumer } from '@forklaunch/interfaces-worker/interfaces';
+import {
+  WorkerEventEntity,
+  WorkerFailureHandler,
+  WorkerProcessFunction
+} from '@forklaunch/interfaces-worker/types';
+import { Consumer, Kafka, Producer } from 'kafkajs';
+import { WorkerOptions } from '../types/kafkaWorker.types';
+
+export class KafkaWorkerConsumer<
+  EventEntity extends WorkerEventEntity,
+  Options extends WorkerOptions
+> implements WorkerConsumer<EventEntity>
+{
+  private kafka: Kafka;
+  private producer: Producer;
+  private consumer: Consumer;
+  private processedMessages: Set<string> = new Set();
+
+  constructor(
+    protected readonly queueName: string,
+    protected readonly options: Options,
+    protected readonly processEventsFunction: WorkerProcessFunction<EventEntity>,
+    protected readonly failureHandler: WorkerFailureHandler<EventEntity>
+  ) {
+    this.kafka = new Kafka({
+      clientId: this.options.clientId,
+      brokers: this.options.brokers
+    });
+
+    this.producer = this.kafka.producer();
+    this.consumer = this.kafka.consumer({
+      groupId: this.options.groupId
+    });
+  }
+
+  private async setupConsumer() {
+    await this.consumer.connect();
+    await this.consumer.subscribe({
+      topic: this.queueName,
+      fromBeginning: false
+    });
+
+    await this.consumer.run({
+      eachMessage: async ({ topic, partition, message }) => {
+        if (!message.value) return;
+
+        const messageKey = `${topic}-${partition}-${message.offset}`;
+
+        if (this.processedMessages.has(messageKey)) {
+          return;
+        }
+
+        const events = JSON.parse(message.value.toString()) as EventEntity[];
+
+        try {
+          await this.processEventsFunction(events);
+          this.processedMessages.add(messageKey);
+
+          await this.consumer.commitOffsets([
+            {
+              topic,
+              partition,
+              offset: (parseInt(message.offset) + 1).toString()
+            }
+          ]);
+        } catch (error) {
+          this.failureHandler([
+            {
+              value: events[0],
+              error: error as Error
+            }
+          ]);
+          for (const event of events) {
+            if (event.retryCount <= this.options.retries) {
+              await this.producer.send({
+                topic: this.queueName,
+                messages: [
+                  {
+                    value: JSON.stringify([
+                      {
+                        ...event,
+                        retryCount: event.retryCount + 1
+                      }
+                    ]),
+                    key: event.id
+                  }
+                ]
+              });
+            }
+          }
+        }
+      }
+    });
+  }
+
+  async peekEvents(): Promise<EventEntity[]> {
+    const events: EventEntity[] = [];
+
+    const admin = this.kafka.admin();
+    await admin.connect();
+
+    try {
+      // Get topic metadata to find partitions
+      const metadata = await admin.fetchTopicMetadata({
+        topics: [this.queueName]
+      });
+      const topic = metadata.topics[0];
+
+      if (!topic) {
+        return events;
+      }
+
+      // For each partition, get the latest offset
+      for (const partition of topic.partitions) {
+        const offsets = await admin.fetchTopicOffsets(this.queueName);
+        const partitionOffset = offsets.find(
+          (o) => o.partition === partition.partitionId
+        );
+
+        if (!partitionOffset) {
+          continue;
+        }
+
+        // Create a temporary consumer to read messages
+        const peekConsumer = this.kafka.consumer({
+          groupId: `${this.options.groupId}-peek-${Date.now()}`
+        });
+
+        try {
+          await peekConsumer.connect();
+          await peekConsumer.subscribe({
+            topic: this.queueName,
+            fromBeginning: false
+          });
+
+          const messagePromise = new Promise<void>((resolve) => {
+            peekConsumer.run({
+              eachMessage: async ({ message }) => {
+                if (message.value && events.length < this.options.peekCount) {
+                  const messageEvents = JSON.parse(
+                    message.value.toString()
+                  ) as EventEntity[];
+                  events.push(...messageEvents);
+
+                  if (events.length >= this.options.peekCount) {
+                    resolve();
+                  }
+                }
+              }
+            });
+          });
+
+          await Promise.race([
+            messagePromise,
+            new Promise((resolve) => setTimeout(resolve, 5000))
+          ]);
+
+          if (events.length >= this.options.peekCount) {
+            break;
+          }
+        } finally {
+          await peekConsumer.disconnect();
+        }
+      }
+
+      return events;
+    } finally {
+      await admin.disconnect();
+    }
+  }
+
+  async start(): Promise<void> {
+    await this.setupConsumer();
+    await this.producer.connect();
+  }
+
+  async close(): Promise<void> {
+    await this.producer.disconnect();
+    await this.consumer.disconnect();
+  }
+}

package/lib/eject/domain/schemas/index.ts

@@ -0,0 +1 @@
+export * from './kafka.schema';

package/lib/eject/domain/schemas/kafkaWorker.schema.ts

@@ -0,0 +1,10 @@
+import { array, number, string } from '@{{app_name}}/core';
+
+export const KafkaWorkerOptionsSchema = {
+  brokers: array(string),
+  clientId: string,
+  groupId: string,
+  retries: number,
+  interval: number,
+  peekCount: number
+};

package/lib/eject/producers/index.ts

@@ -0,0 +1 @@
+export * from './kafkaWorker.producer';

package/lib/eject/producers/kafkaWorker.producer.ts

@@ -0,0 +1,35 @@
+import { WorkerEventEntity } from '@forklaunch/interfaces-worker/types';
+import { Kafka } from 'kafkajs';
+import { WorkerOptions } from '../types/kafkaWorker.types';
+export class KafkaWorkerProducer<
+  EventEntity extends WorkerEventEntity,
+  Options extends WorkerOptions
+> {
+  private producer;
+
+  constructor(
+    private readonly queueName: string,
+    private readonly options: Options
+  ) {
+    const kafka = new Kafka({
+      clientId: this.options.clientId,
+      brokers: this.options.brokers
+    });
+    this.producer = kafka.producer();
+    this.producer.connect();
+  }
+
+  async enqueueJob(event: EventEntity): Promise<void> {
+    await this.producer.send({
+      topic: this.queueName,
+      messages: [{ value: JSON.stringify([event]) }]
+    });
+  }
+
+  async enqueueBatchJobs(events: EventEntity[]): Promise<void> {
+    await this.producer.send({
+      topic: this.queueName,
+      messages: events.map((event) => ({ value: JSON.stringify(event) }))
+    });
+  }
+}

package/lib/eject/types/index.ts

@@ -0,0 +1 @@
+export * from './kafkaWorker.types';

package/lib/eject/types/kafkaWorker.types.ts

@@ -0,0 +1,8 @@
+export type WorkerOptions = {
+  brokers: string[];
+  clientId: string;
+  groupId: string;
+  retries: number;
+  interval: number;
+  peekCount: number;
+};

package/lib/jest.config.d.ts

@@ -0,0 +1,4 @@
+import type { JestConfigWithTsJest } from 'ts-jest';
+declare const jestConfig: JestConfigWithTsJest;
+export default jestConfig;
+//# sourceMappingURL=jest.config.d.ts.map

package/lib/jest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../jest.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,oBAiBjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/lib/jest.config.js

@@ -0,0 +1,19 @@
+const jestConfig = {
+    preset: 'ts-jest/presets/default-esm', // or other ESM presets
+    moduleNameMapper: {
+        '^(\\.{1,2}/.*)\\.js$': '$1'
+    },
+    transform: {
+        // '^.+\\.[tj]sx?$' to process ts,js,tsx,jsx with `ts-jest`
+        // '^.+\\.m?[tj]sx?$' to process ts,js,tsx,jsx,mts,mjs,mtsx,mjsx with `ts-jest`
+        '^.+\\.[tj]sx?$': [
+            'ts-jest',
+            {
+                useESM: true
+            }
+        ],
+        '^.+\\.js$': 'babel-jest'
+    },
+    testPathIgnorePatterns: ['.*dist/', '.*node_modules/']
+};
+export default jestConfig;

package/lib/producers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './kafkaWorker.producer';
+//# sourceMappingURL=index.d.ts.map

package/lib/producers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../producers/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/lib/producers/index.js

@@ -0,0 +1 @@
+export * from './kafkaWorker.producer';

package/lib/producers/kafkaWorker.producer.d.ts

@@ -0,0 +1,11 @@
+import { WorkerEventEntity } from '@forklaunch/interfaces-worker/types';
+import { WorkerOptions } from '../types/kafkaWorker.types';
+export declare class KafkaWorkerProducer<EventEntity extends WorkerEventEntity, Options extends WorkerOptions> {
+    private readonly queueName;
+    private readonly options;
+    private producer;
+    constructor(queueName: string, options: Options);
+    enqueueJob(event: EventEntity): Promise<void>;
+    enqueueBatchJobs(events: EventEntity[]): Promise<void>;
+}
+//# sourceMappingURL=kafkaWorker.producer.d.ts.map

package/lib/producers/kafkaWorker.producer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafkaWorker.producer.d.ts","sourceRoot":"","sources":["../../producers/kafkaWorker.producer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,qBAAa,mBAAmB,CAC9B,WAAW,SAAS,iBAAiB,EACrC,OAAO,SAAS,aAAa;IAK3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC;gBAGE,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO;IAU7B,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7C,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAM7D"}

package/lib/producers/kafkaWorker.producer.js

@@ -0,0 +1,28 @@
+import { Kafka } from 'kafkajs';
+export class KafkaWorkerProducer {
+    queueName;
+    options;
+    producer;
+    constructor(queueName, options) {
+        this.queueName = queueName;
+        this.options = options;
+        const kafka = new Kafka({
+            clientId: this.options.clientId,
+            brokers: this.options.brokers
+        });
+        this.producer = kafka.producer();
+        this.producer.connect();
+    }
+    async enqueueJob(event) {
+        await this.producer.send({
+            topic: this.queueName,
+            messages: [{ value: JSON.stringify([event]) }]
+        });
+    }
+    async enqueueBatchJobs(events) {
+        await this.producer.send({
+            topic: this.queueName,
+            messages: events.map((event) => ({ value: JSON.stringify(event) }))
+        });
+    }
+}

package/lib/schemas/index.d.ts

@@ -0,0 +1,2 @@
+export * from './kafka.schema';
+//# sourceMappingURL=index.d.ts.map

package/lib/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/lib/schemas/index.js

@@ -0,0 +1 @@
+export * from './kafka.schema';

package/lib/schemas/kafka.schema.d.ts

@@ -0,0 +1,18 @@
+export declare const KafkaWorkerSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(options: Record<string, unknown> & {
+    validator: SchemaValidator;
+}) => import("@forklaunch/core/mappers").SchemasByValidator<SchemaValidator, (options: Record<string, unknown>) => {
+    brokers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    clientId: import("@sinclair/typebox").TString;
+    groupId: import("@sinclair/typebox").TString;
+    retries: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    interval: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    peekCount: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+}, (options: Record<string, unknown>) => {
+    brokers: import("zod").ZodArray<import("zod").ZodString, "many">;
+    clientId: import("zod").ZodString;
+    groupId: import("zod").ZodString;
+    retries: import("zod").ZodNumber;
+    interval: import("zod").ZodNumber;
+    peekCount: import("zod").ZodNumber;
+}>;
+//# sourceMappingURL=kafka.schema.d.ts.map

package/lib/schemas/kafka.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.schema.d.ts","sourceRoot":"","sources":["../../schemas/kafka.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;EAG9B,CAAC"}

package/lib/schemas/kafka.schema.js

@@ -0,0 +1,4 @@
+import { serviceSchemaResolver } from '@forklaunch/core/mappers';
+import { KafkaWorkerOptionsSchema as TypeBoxSchemas } from './typebox/kafkaWorker.schema';
+import { KafkaWorkerOptionsSchema as ZodSchemas } from './zod/kafkaWorker.schema';
+export const KafkaWorkerSchemas = serviceSchemaResolver(() => TypeBoxSchemas, () => ZodSchemas);

package/lib/schemas/typebox/kafkaWorker.schema.d.ts

@@ -0,0 +1,9 @@
+export declare const KafkaWorkerOptionsSchema: {
+    brokers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    clientId: import("@sinclair/typebox").TString;
+    groupId: import("@sinclair/typebox").TString;
+    retries: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    interval: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    peekCount: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+};
+//# sourceMappingURL=kafkaWorker.schema.d.ts.map

package/lib/schemas/typebox/kafkaWorker.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafkaWorker.schema.d.ts","sourceRoot":"","sources":["../../../schemas/typebox/kafkaWorker.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;;;;;;CAOpC,CAAC"}

package/lib/schemas/typebox/kafkaWorker.schema.js

@@ -0,0 +1,9 @@
+import { array, number, string } from '@forklaunch/validator/typebox';
+export const KafkaWorkerOptionsSchema = {
+    brokers: array(string),
+    clientId: string,
+    groupId: string,
+    retries: number,
+    interval: number,
+    peekCount: number
+};

package/lib/schemas/zod/kafkaWorker.schema.d.ts

@@ -0,0 +1,9 @@
+export declare const KafkaWorkerOptionsSchema: {
+    brokers: import("zod").ZodArray<import("zod").ZodString, "many">;
+    clientId: import("zod").ZodString;
+    groupId: import("zod").ZodString;
+    retries: import("zod").ZodNumber;
+    interval: import("zod").ZodNumber;
+    peekCount: import("zod").ZodNumber;
+};
+//# sourceMappingURL=kafkaWorker.schema.d.ts.map

package/lib/schemas/zod/kafkaWorker.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafkaWorker.schema.d.ts","sourceRoot":"","sources":["../../../schemas/zod/kafkaWorker.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;;;;;;CAOpC,CAAC"}

package/lib/schemas/zod/kafkaWorker.schema.js

@@ -0,0 +1,9 @@
+import { array, number, string } from '@forklaunch/validator/zod';
+export const KafkaWorkerOptionsSchema = {
+    brokers: array(string),
+    clientId: string,
+    groupId: string,
+    retries: number,
+    interval: number,
+    peekCount: number
+};