@forklaunch/implementation-worker-kafka 0.1.0 → 0.1.1

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

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

package/lib/__test__/schemaEquality.test.js

@@ -3,14 +3,22 @@ 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, {
+  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();
-    });
+          }
+        )
+      )
+    ).toBeTruthy();
+  });
 });

package/lib/consumers/index.d.ts

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

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

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

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

@@ -1 +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,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,qBAAa,mBAAmB,CAAC,WAAW,SAAS,iBAAiB,CACpE,YAAW,cAAc,CAAC,WAAW,CAAC;IAQpC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM;IACpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,kBAAkB;IAC9C,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,kBAAkB,EAC3B,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"}
+{"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,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,qBAAa,mBAAmB,CAC9B,WAAW,SAAS,iBAAiB,EACrC,OAAO,SAAS,kBAAkB,CAClC,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

@@ -1,149 +1,147 @@
 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
+  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()}`
         });
-    }
-    async setupConsumer() {
-        await this.consumer.connect();
-        await this.consumer.subscribe({
+        try {
+          await peekConsumer.connect();
+          await peekConsumer.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
-                                    }
-                                ]
-                            });
-                        }
-                    }
+          });
+          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();
+                  }
                 }
-            }
-        });
-    }
-    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;
+          });
+          await Promise.race([
+            messagePromise,
+            new Promise((resolve) => setTimeout(resolve, 5000))
+          ]);
+          if (events.length >= this.options.peekCount) {
+            break;
+          }
+        } finally {
+          await peekConsumer.disconnect();
         }
-        finally {
-            await admin.disconnect();
-        }
-    }
-    async start() {
-        await this.setupConsumer();
-        await this.producer.connect();
-    }
-    async close() {
-        await this.producer.disconnect();
-        await this.consumer.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/kafkaWorker.consumer.ts

@@ -7,8 +7,10 @@ import {
 import { Consumer, Kafka, Producer } from 'kafkajs';
 import { KafkaWorkerOptions } from '../types/kafkaWorker.types';
 
-export class KafkaWorkerConsumer<EventEntity extends WorkerEventEntity>
-  implements WorkerConsumer<EventEntity>
+export class KafkaWorkerConsumer<
+  EventEntity extends WorkerEventEntity,
+  Options extends KafkaWorkerOptions
+> implements WorkerConsumer<EventEntity>
 {
   private kafka: Kafka;
   private producer: Producer;
@@ -17,7 +19,7 @@ export class KafkaWorkerConsumer<EventEntity extends WorkerEventEntity>
 
   constructor(
     protected readonly queueName: string,
-    protected readonly options: KafkaWorkerOptions,
+    protected readonly options: Options,
     protected readonly processEventsFunction: WorkerProcessFunction<EventEntity>,
     protected readonly failureHandler: WorkerFailureHandler<EventEntity>
   ) {

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

@@ -2,12 +2,15 @@ import { WorkerEventEntity } from '@forklaunch/interfaces-worker/types';
 import { Kafka } from 'kafkajs';
 import { KafkaWorkerOptions } from '../types/kafkaWorker.types';
 
-export class KafkaWorkerProducer<EventEntity extends WorkerEventEntity> {
+export class KafkaWorkerProducer<
+  EventEntity extends WorkerEventEntity,
+  Options extends KafkaWorkerOptions
+> {
   private producer;
 
   constructor(
     private readonly queueName: string,
-    private readonly options: KafkaWorkerOptions
+    private readonly options: Options
   ) {
     const kafka = new Kafka({
       clientId: this.options.clientId,

package/lib/jest.config.d.ts

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

package/lib/jest.config.js

@@ -1,19 +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/']
+  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

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

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

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

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

@@ -1 +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,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,qBAAa,mBAAmB,CAAC,WAAW,SAAS,iBAAiB;IAIlE,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC;gBAGE,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kBAAkB;IAUxC,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7C,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAM7D"}
+{"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,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,qBAAa,mBAAmB,CAC9B,WAAW,SAAS,iBAAiB,EACrC,OAAO,SAAS,kBAAkB;IAKhC,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

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

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

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

@@ -1,18 +1,64 @@
-export declare const KafkaWorkerSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(options: Record<string, unknown> & {
+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
+  }
+) => 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.js

@@ -1,4 +1,7 @@
 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);
+export const KafkaWorkerSchemas = serviceSchemaResolver(
+  () => TypeBoxSchemas,
+  () => ZodSchemas
+);