kafka-ts 0.0.1-beta.3 → 0.0.1-beta.6

package/src/consumer/consumer.ts

@@ -1,17 +1,21 @@
+import EventEmitter from 'events';
 import { API, API_ERROR } from '../api';
 import { IsolationLevel } from '../api/fetch';
 import { Assignment } from '../api/sync-group';
 import { Cluster } from '../cluster';
-import { distributeAssignmentsToNodes } from '../distributors/assignments-to-replicas';
+import { distributeMessagesToTopicPartitionLeaders } from '../distributors/messages-to-topic-partition-leaders';
 import { Message } from '../types';
 import { delay } from '../utils/delay';
 import { ConnectionError, KafkaTSApiError } from '../utils/error';
-import { defaultRetrier, Retrier } from '../utils/retrier';
+import { log } from '../utils/logger';
+import { createTracer } from '../utils/tracer';
 import { ConsumerGroup } from './consumer-group';
 import { ConsumerMetadata } from './consumer-metadata';
-import { FetchManager, BatchGranularity } from './fetch-manager';
+import { BatchGranularity, FetchManager } from './fetch-manager';
 import { OffsetManager } from './offset-manager';
 
+const trace = createTracer('Consumer');
+
 export type ConsumerOptions = {
     topics: string[];
     groupId?: string | null;
@@ -26,12 +30,11 @@ export type ConsumerOptions = {
     partitionMaxBytes?: number;
     allowTopicAutoCreation?: boolean;
     fromBeginning?: boolean;
-    retrier?: Retrier;
     batchGranularity?: BatchGranularity;
     concurrency?: number;
 } & ({ onBatch: (messages: Required<Message>[]) => unknown } | { onMessage: (message: Required<Message>) => unknown });
 
-export class Consumer {
+export class Consumer extends EventEmitter<{ offsetCommit: [] }> {
     private options: Required<ConsumerOptions>;
     private metadata: ConsumerMetadata;
     private consumerGroup: ConsumerGroup | undefined;
@@ -43,6 +46,8 @@ export class Consumer {
         private cluster: Cluster,
         options: ConsumerOptions,
     ) {
+        super();
+
         this.options = {
             ...options,
             groupId: options.groupId ?? null,
@@ -57,7 +62,6 @@ export class Consumer {
             isolationLevel: options.isolationLevel ?? IsolationLevel.READ_UNCOMMITTED,
             allowTopicAutoCreation: options.allowTopicAutoCreation ?? false,
             fromBeginning: options.fromBeginning ?? false,
-            retrier: options.retrier ?? defaultRetrier,
             batchGranularity: options.batchGranularity ?? 'partition',
             concurrency: options.concurrency ?? 1,
         };
@@ -80,8 +84,10 @@ export class Consumer {
                   offsetManager: this.offsetManager,
               })
             : undefined;
+        this.consumerGroup?.on('offsetCommit', () => this.emit('offsetCommit'));
     }
 
+    @trace()
     public async start(): Promise<void> {
         const { topics, allowTopicAutoCreation, fromBeginning } = this.options;
 
@@ -94,16 +100,17 @@ export class Consumer {
             await this.offsetManager.fetchOffsets({ fromBeginning });
             await this.consumerGroup?.join();
         } catch (error) {
-            console.error(error);
-            console.debug(`Restarting consumer in 1 second...`);
+            log.warn('Failed to start consumer', error);
+            log.debug(`Restarting consumer in 1 second...`);
             await delay(1000);
 
             if (this.stopHook) return (this.stopHook as () => void)();
             return this.close(true).then(() => this.start());
         }
-        setImmediate(() => this.startFetchManager());
+        this.startFetchManager();
     }
 
+    @trace()
     public async close(force = false): Promise<void> {
         if (!force) {
             await new Promise<void>(async (resolve) => {
@@ -111,22 +118,33 @@ export class Consumer {
                 await this.fetchManager?.stop();
             });
         }
-        await this.consumerGroup
-            ?.leaveGroup()
-            .catch((error) => console.warn(`Failed to leave group: ${error.message}`));
-        await this.cluster.disconnect().catch((error) => console.warn(`Failed to disconnect: ${error.message}`));
+        await this.consumerGroup?.leaveGroup().catch((error) => log.debug(`Failed to leave group: ${error.message}`));
+        await this.cluster.disconnect().catch((error) => log.debug(`Failed to disconnect: ${error.message}`));
     }
 
-    private startFetchManager = async () => {
+    private async startFetchManager() {
         const { batchGranularity, concurrency } = this.options;
 
         while (!this.stopHook) {
+            this.consumerGroup?.resetHeartbeat();
+
+            // TODO: If leader is not available, find another read replica
             const nodeAssignments = Object.entries(
-                distributeAssignmentsToNodes(
-                    this.metadata.getAssignment(),
-                    this.metadata.getTopicPartitionReplicaIds(),
+                distributeMessagesToTopicPartitionLeaders(
+                    Object.entries(this.metadata.getAssignment()).flatMap(([topic, partitions]) =>
+                        partitions.map((partition) => ({ topic, partition })),
+                    ),
+                    this.metadata.getTopicPartitionLeaderIds(),
                 ),
-            ).map(([nodeId, assignment]) => ({ nodeId: parseInt(nodeId), assignment }));
+            ).map(([nodeId, assignment]) => ({
+                nodeId: parseInt(nodeId),
+                assignment: Object.fromEntries(
+                    Object.entries(assignment).map(([topic, partitions]) => [
+                        topic,
+                        Object.keys(partitions).map(Number),
+                    ]),
+                ),
+            }));
 
             const numPartitions = Object.values(this.metadata.getAssignment()).flat().length;
             const numProcessors = Math.min(concurrency, numPartitions);
@@ -145,19 +163,19 @@ export class Consumer {
                 await this.fetchManager.start();
 
                 if (!nodeAssignments.length) {
-                    console.debug('No partitions assigned. Waiting for reassignment...');
+                    log.debug('No partitions assigned. Waiting for reassignment...');
                     await delay(this.options.maxWaitMs);
-                    await this.consumerGroup?.handleLastHeartbeat();
+                    this.consumerGroup?.handleLastHeartbeat();
                 }
             } catch (error) {
                 await this.fetchManager.stop();
 
                 if ((error as KafkaTSApiError).errorCode === API_ERROR.REBALANCE_IN_PROGRESS) {
-                    console.debug('Rebalance in progress...');
+                    log.debug('Rebalance in progress...');
                     continue;
                 }
                 if ((error as KafkaTSApiError).errorCode === API_ERROR.FENCED_INSTANCE_ID) {
-                    console.debug('New consumer with the same groupInstanceId joined. Exiting the consumer...');
+                    log.debug('New consumer with the same groupInstanceId joined. Exiting the consumer...');
                     this.close();
                     break;
                 }
@@ -165,42 +183,45 @@ export class Consumer {
                     error instanceof ConnectionError ||
                     (error instanceof KafkaTSApiError && error.errorCode === API_ERROR.NOT_COORDINATOR)
                 ) {
-                    console.debug(`${error.message}. Restarting consumer...`);
+                    log.debug(`${error.message}. Restarting consumer...`);
                     this.close().then(() => this.start());
                     break;
                 }
-                console.error(error);
+                log.error((error as Error).message, error);
                 this.close();
                 break;
             }
         }
         this.stopHook?.();
-    };
+    }
 
+    @trace((messages) => ({ count: messages.length }))
     private async process(messages: Required<Message>[]) {
         const { options } = this;
-        const { retrier } = options;
+
+        const topicPartitions: Record<string, Set<number>> = {};
+        for (const { topic, partition } of messages) {
+            topicPartitions[topic] ??= new Set();
+            topicPartitions[topic].add(partition);
+        }
 
         if ('onBatch' in options) {
-            await retrier(() => options.onBatch(messages));
+            await options.onBatch(messages);
 
             messages.forEach(({ topic, partition, offset }) =>
                 this.offsetManager.resolve(topic, partition, offset + 1n),
             );
         } else if ('onMessage' in options) {
-            try {
-                for (const message of messages) {
-                    await retrier(() => options.onMessage(message));
+            for (const message of messages) {
+                await options.onMessage(message);
 
-                    const { topic, partition, offset } = message;
-                    this.offsetManager.resolve(topic, partition, offset + 1n);
-                }
-            } catch (error) {
-                await this.consumerGroup?.offsetCommit().catch(() => {});
-                throw error;
+                const { topic, partition, offset } = message;
+                this.offsetManager.resolve(topic, partition, offset + 1n);
             }
         }
-        await this.consumerGroup?.offsetCommit();
+
+        await this.consumerGroup?.offsetCommit(topicPartitions);
+        this.offsetManager.flush(topicPartitions);
     }
 
     private fetch(nodeId: number, assignment: Assignment) {

package/src/consumer/fetch-manager.ts

@@ -1,5 +1,4 @@
-import EventEmitter from 'events';
-import { API } from '../api';
+import { FetchResponse } from '../api/fetch';
 import { Assignment } from '../api/sync-group';
 import { Metadata } from '../metadata';
 import { Batch, Message } from '../types';
@@ -14,7 +13,7 @@ const trace = createTracer('FetchManager');
 export type BatchGranularity = 'partition' | 'topic' | 'broker';
 
 type FetchManagerOptions = {
-    fetch: (nodeId: number, assignment: Assignment) => Promise<ReturnType<(typeof API.FETCH)['response']>>;
+    fetch: (nodeId: number, assignment: Assignment) => Promise<FetchResponse>;
     process: (batch: Batch) => Promise<void>;
     metadata: Metadata;
     consumerGroup?: ConsumerGroup;
@@ -26,15 +25,15 @@ type FetchManagerOptions = {
 type Checkpoint = { kind: 'checkpoint'; fetcherId: number };
 type Entry = Batch | Checkpoint;
 
-export class FetchManager extends EventEmitter<{ data: []; checkpoint: [number]; stop: [] }> {
+export class FetchManager {
     private queue: Entry[] = [];
     private isRunning = false;
     private fetchers: Fetcher[];
     private processors: Processor[];
+    private pollQueue: (() => void)[] = [];
+    private fetcherCallbacks: Record<number, () => void> = {};
 
     constructor(private options: FetchManagerOptions) {
-        super();
-
         const { fetch, process, consumerGroup, nodeAssignments, concurrency } = this.options;
 
         this.fetchers = nodeAssignments.map(
@@ -52,6 +51,7 @@ export class FetchManager extends EventEmitter<{ data: []; checkpoint: [number];
         );
     }
 
+    @trace(() => ({ root: true }))
     public async start() {
         this.queue = [];
         this.isRunning = true;
@@ -62,20 +62,25 @@ export class FetchManager extends EventEmitter<{ data: []; checkpoint: [number];
                 ...this.processors.map((processor) => processor.loop()),
             ]);
         } finally {
-            this.isRunning = false;
-            this.emit('stop');
+            await this.stop();
         }
     }
 
-    @trace()
     public async stop() {
         this.isRunning = false;
-        this.emit('stop');
 
-        await Promise.all([
+        const stopPromise = Promise.all([
             ...this.fetchers.map((fetcher) => fetcher.stop()),
             ...this.processors.map((processor) => processor.stop()),
         ]);
+
+        this.pollQueue.forEach((resolve) => resolve());
+        this.pollQueue = [];
+
+        Object.values(this.fetcherCallbacks).forEach((callback) => callback());
+        this.fetcherCallbacks = {};
+
+        await stopPromise;
     }
 
     @trace()
@@ -86,58 +91,43 @@ export class FetchManager extends EventEmitter<{ data: []; checkpoint: [number];
 
         const batch = this.queue.shift();
         if (!batch) {
+            // wait until new data is available or fetch manager is requested to stop
             await new Promise<void>((resolve) => {
-                const onData = () => {
-                    this.removeListener('stop', onStop);
-                    resolve();
-                };
-                const onStop = () => {
-                    this.removeListener('data', onData);
-                    resolve();
-                };
-                this.once('data', onData);
-                this.once('stop', onStop);
+                this.pollQueue.push(resolve);
             });
             return this.poll();
         }
 
         if ('kind' in batch && batch.kind === 'checkpoint') {
-            this.emit('checkpoint', batch.fetcherId);
+            this.fetcherCallbacks[batch.fetcherId]?.();
             return this.poll();
         }
 
+        this.pollQueue?.shift()?.();
+
         return batch as Exclude<Entry, Checkpoint>;
     }
 
-    private async onResponse(fetcherId: number, response: ReturnType<(typeof API.FETCH)['response']>) {
+    @trace()
+    private async onResponse(fetcherId: number, response: FetchResponse) {
         const { metadata, batchGranularity } = this.options;
 
         const batches = fetchResponseToBatches(response, batchGranularity, metadata);
-        if (batches.length) {
-            this.queue.push(...batches);
-            this.queue.push({ kind: 'checkpoint', fetcherId });
-
-            this.emit('data');
-            await new Promise<void>((resolve) => {
-                const onCheckpoint = (id: number) => {
-                    if (id === fetcherId) {
-                        this.removeListener('stop', onStop);
-                        resolve();
-                    }
-                };
-                const onStop = () => {
-                    this.removeListener('checkpoint', onCheckpoint);
-                    resolve();
-                };
-                this.once('checkpoint', onCheckpoint);
-                this.once('stop', onStop);
-            });
+        if (!batches.length) {
+            return;
         }
+
+        // wait until all broker batches have been processed or fetch manager is requested to stop
+        await new Promise<void>((resolve) => {
+            this.fetcherCallbacks[fetcherId] = resolve;
+            this.queue.push(...batches, { kind: 'checkpoint', fetcherId });
+            this.pollQueue?.shift()?.();
+        });
     }
 }
 
 const fetchResponseToBatches = (
-    batch: ReturnType<typeof API.FETCH.response>,
+    batch: FetchResponse,
     batchGranularity: BatchGranularity,
     metadata: Metadata,
 ): Batch[] => {
@@ -170,9 +160,9 @@ const fetchResponseToBatches = (
                 .map((topicPartition) => topicPartition.flatMap((partitionMessages) => partitionMessages))
                 .filter((messages) => messages.length);
         case 'partition':
-            return brokerTopics.flatMap((topicPartition) =>
-                topicPartition.map((partitionMessages) => partitionMessages),
-            );
+            return brokerTopics
+                .flatMap((topicPartition) => topicPartition.map((partitionMessages) => partitionMessages))
+                .filter((messages) => messages.length);
         default:
             throw new KafkaTSError(`Unhandled batch granularity: ${batchGranularity}`);
     }

package/src/consumer/fetcher.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'stream';
-import { API } from '../api';
+import { FetchResponse } from '../api/fetch';
 import { Assignment } from '../api/sync-group';
 import { createTracer } from '../utils/tracer';
 import { ConsumerGroup } from './consumer-group';
@@ -10,11 +10,11 @@ type FetcherOptions = {
     nodeId: number;
     assignment: Assignment;
     consumerGroup?: ConsumerGroup;
-    fetch: (nodeId: number, assignment: Assignment) => Promise<ReturnType<(typeof API.FETCH)['response']>>;
-    onResponse: (fetcherId: number, response: ReturnType<(typeof API.FETCH)['response']>) => Promise<void>;
+    fetch: (nodeId: number, assignment: Assignment) => Promise<FetchResponse>;
+    onResponse: (fetcherId: number, response: FetchResponse) => Promise<void>;
 };
 
-export class Fetcher extends EventEmitter<{ stop: []; stopped: []; data: []; drain: [] }> {
+export class Fetcher extends EventEmitter<{ stopped: [] }> {
     private isRunning = false;
 
     constructor(
@@ -25,17 +25,11 @@ export class Fetcher extends EventEmitter<{ stop: []; stopped: []; data: []; dra
     }
 
     public async loop() {
-        const { nodeId, assignment, consumerGroup, fetch, onResponse } = this.options;
-
         this.isRunning = true;
-        this.once('stop', () => (this.isRunning = false));
 
         try {
             while (this.isRunning) {
-                const response = await fetch(nodeId, assignment);
-                await consumerGroup?.handleLastHeartbeat();
-                await onResponse(this.fetcherId, response);
-                await consumerGroup?.handleLastHeartbeat();
+                await this.step();
             }
         } finally {
             this.isRunning = false;
@@ -44,14 +38,27 @@ export class Fetcher extends EventEmitter<{ stop: []; stopped: []; data: []; dra
     }
 
     @trace()
+    private async step() {
+        const { nodeId, assignment, consumerGroup, fetch, onResponse } = this.options;
+
+        const response = await fetch(nodeId, assignment);
+        if (!this.isRunning) {
+            return;
+        }
+        consumerGroup?.handleLastHeartbeat();
+        await onResponse(this.fetcherId, response);
+        consumerGroup?.handleLastHeartbeat();
+    }
+
     public async stop() {
         if (!this.isRunning) {
             return;
         }
 
-        this.emit('stop');
-        return new Promise<void>((resolve) => {
+        const stopPromise = new Promise<void>((resolve) => {
             this.once('stopped', resolve);
         });
+        this.isRunning = false;
+        return stopPromise;
     }
 }

package/src/consumer/offset-manager.ts

@@ -3,8 +3,11 @@ import { IsolationLevel } from '../api/fetch';
 import { Assignment } from '../api/sync-group';
 import { Cluster } from '../cluster';
 import { distributeMessagesToTopicPartitionLeaders } from '../distributors/messages-to-topic-partition-leaders';
+import { createTracer } from '../utils/tracer';
 import { ConsumerMetadata } from './consumer-metadata';
 
+const trace = createTracer('OffsetManager');
+
 type OffsetManagerOptions = {
     cluster: Cluster;
     metadata: ConsumerMetadata;
@@ -24,13 +27,18 @@ export class OffsetManager {
     public resolve(topic: string, partition: number, offset: bigint) {
         this.pendingOffsets[topic] ??= {};
         this.pendingOffsets[topic][partition] = offset;
-
-        this.currentOffsets[topic] ??= {};
-        this.currentOffsets[topic][partition] = offset;
     }
 
-    public flush() {
-        this.pendingOffsets = {};
+    public flush(topicPartitions: Record<string, Set<number>>) {
+        Object.entries(topicPartitions).forEach(([topic, partitions]) => {
+            this.currentOffsets[topic] ??= {};
+            partitions.forEach((partition) => {
+                if (this.pendingOffsets[topic]?.[partition]) {
+                    this.currentOffsets[topic][partition] = this.pendingOffsets[topic][partition];
+                    delete this.pendingOffsets[topic][partition];
+                }
+            });
+        });
     }
 
     public async fetchOffsets(options: { fromBeginning: boolean }) {
@@ -58,7 +66,6 @@ export class OffsetManager {
                 }),
             ),
         );
-        this.flush();
     }
 
     private async listOffsets({
@@ -83,11 +90,15 @@ export class OffsetManager {
                 })),
         });
 
+        const topicPartitions: Record<string, Set<number>> = {};
         offsets.topics.forEach(({ name, partitions }) => {
+            topicPartitions[name] ??= new Set();
             partitions.forEach(({ partitionIndex, offset }) => {
+                topicPartitions[name].add(partitionIndex);
                 this.resolve(name, partitionIndex, fromBeginning ? 0n : offset);
             });
         });
-        this.flush();
+
+        this.flush(topicPartitions);
     }
 }

package/src/consumer/processor.ts

@@ -9,7 +9,7 @@ type ProcessorOptions = {
     process: (batch: Batch) => Promise<void>;
 };
 
-export class Processor extends EventEmitter<{ stop: []; stopped: [] }> {
+export class Processor extends EventEmitter<{ stopped: [] }> {
     private isRunning = false;
 
     constructor(private options: ProcessorOptions) {
@@ -17,15 +17,11 @@ export class Processor extends EventEmitter<{ stop: []; stopped: [] }> {
     }
 
     public async loop() {
-        const { poll, process } = this.options;
-
         this.isRunning = true;
-        this.once('stop', () => (this.isRunning = false));
 
         try {
             while (this.isRunning) {
-                const batch = await poll();
-                await process(batch);
+                await this.step();
             }
         } finally {
             this.isRunning = false;
@@ -34,14 +30,24 @@ export class Processor extends EventEmitter<{ stop: []; stopped: [] }> {
     }
 
     @trace()
+    private async step() {
+        const { poll, process } = this.options;
+
+        const batch = await poll();
+        if (batch.length) {
+            await process(batch);
+        }
+    }
+
     public async stop() {
         if (!this.isRunning) {
             return;
         }
 
-        return new Promise<void>((resolve) => {
+        const stopPromise = new Promise<void>((resolve) => {
             this.once('stopped', resolve);
-            this.emit('stop');
         });
+        this.isRunning = false;
+        return stopPromise;
     }
 }

package/src/distributors/assignments-to-replicas.ts

@@ -1,6 +1,6 @@
 type Assignment = { [topicName: string]: number[] };
 type TopicPartitionReplicaIds = { [topicName: string]: { [partition: number]: number[] } };
-export type NodeAssignment = { [replicaId: number]: Assignment };
+type NodeAssignment = { [replicaId: number]: Assignment };
 
 /** From replica ids pick the one with fewest assignments to balance the load across brokers */
 export const distributeAssignmentsToNodesBalanced = (
@@ -81,5 +81,3 @@ const getPartitionsByReplica = (assignment: Assignment, topicPartitionReplicaIds
     }
     return Object.entries(partitionsByReplicaId);
 };
-
-export const distributeAssignmentsToNodes = distributeAssignmentsToNodesBalanced;

package/src/index.ts

@@ -5,3 +5,5 @@ export * from './client';
 export * from './distributors/partitioner';
 export * from './types';
 export * from './utils/error';
+export * from './utils/logger';
+export { Tracer, setTracer } from './utils/tracer';

package/src/metadata.ts

@@ -2,6 +2,9 @@ import { API, API_ERROR } from './api';
 import { Cluster } from './cluster';
 import { delay } from './utils/delay';
 import { KafkaTSApiError } from './utils/error';
+import { createTracer } from './utils/tracer';
+
+const trace = createTracer('Metadata');
 
 type MetadataOptions = {
     cluster: Cluster;
@@ -36,6 +39,7 @@ export class Metadata {
         return this.topicNameById[id];
     }
 
+    @trace()
     public async fetchMetadataIfNecessary({
         topics,
         allowTopicAutoCreation,

package/src/producer/producer.ts

@@ -7,6 +7,9 @@ import { Message } from '../types';
 import { delay } from '../utils/delay';
 import { KafkaTSApiError } from '../utils/error';
 import { memo } from '../utils/memo';
+import { createTracer } from '../utils/tracer';
+
+const trace = createTracer('Producer');
 
 export type ProducerOptions = {
     allowTopicAutoCreation?: boolean;
@@ -34,7 +37,8 @@ export class Producer {
         this.partition = this.options.partitioner({ metadata: this.metadata });
     }
 
-    public async send(messages: Message[]) {
+    @trace(() => ({ root: true }))
+    public async send(messages: Message[], { acks = -1 }: { acks?: -1 | 1 } = {}) {
         await this.ensureConnected();
 
         const { allowTopicAutoCreation } = this.options;
@@ -44,19 +48,20 @@ export class Producer {
         await this.metadata.fetchMetadataIfNecessary({ topics, allowTopicAutoCreation });
 
         const nodeTopicPartitionMessages = distributeMessagesToTopicPartitionLeaders(
-            messages.map(message => ({ ...message, partition: this.partition(message) })),
+            messages.map((message) => ({ ...message, partition: this.partition(message) })),
             this.metadata.getTopicPartitionLeaderIds(),
         );
 
         await Promise.all(
-            Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
-                await this.cluster.sendRequestToNode(parseInt(nodeId))(API.PRODUCE, {
+            Object.entries(nodeTopicPartitionMessages).map(([nodeId, topicPartitionMessages]) =>
+                this.cluster.sendRequestToNode(parseInt(nodeId))(API.PRODUCE, {
                     transactionalId: null,
-                    acks: 1,
+                    acks,
                     timeoutMs: 5000,
                     topicData: Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
                         name: topic,
                         partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
+                            const partitionIndex = parseInt(partition);
                             let baseTimestamp: bigint | undefined;
                             let maxTimestamp: bigint | undefined;
 
@@ -69,9 +74,9 @@ export class Producer {
                                 }
                             });
 
-                            const baseSequence = this.nextSequence(topic, parseInt(partition), messages.length);
+                            const baseSequence = this.nextSequence(topic, partitionIndex, messages.length);
                             return {
-                                index: parseInt(partition),
+                                index: partitionIndex,
                                 baseOffset: 0n,
                                 partitionLeaderEpoch: -1,
                                 attributes: 0,
@@ -95,8 +100,8 @@ export class Producer {
                             };
                         }),
                     })),
-                });
-            }),
+                }),
+            ),
         );
     }
 

package/src/utils/api.ts

@@ -5,7 +5,7 @@ export type Api<Request, Response> = {
     apiKey: number;
     apiVersion: number;
     request: (encoder: Encoder, body: Request) => Encoder;
-    response: (buffer: Decoder) => Response;
+    response: (buffer: Decoder) => Promise<Response> | Response;
 };
 
 export const createApi = <Request, Response>(api: Api<Request, Response>) => api;