@platformatic/kafka 0.1.0

package/dist/clients/callbacks.js

@@ -0,0 +1,42 @@
+import { MultipleErrors } from "../errors.js";
+export const kCallbackPromise = Symbol('plt.kafka.callbackPromise');
+/* c8 ignore next 3 */
+export const noopCallback = () => {
+    return Promise.resolve();
+};
+export function createPromisifiedCallback() {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    function callback(error, payload) {
+        if (error) {
+            reject(error);
+        }
+        else {
+            resolve(payload);
+        }
+    }
+    callback[kCallbackPromise] = promise;
+    return callback;
+}
+export function runConcurrentCallbacks(errorMessage, collection, operation, callback) {
+    let remaining = Array.isArray(collection) ? collection.length : collection.size;
+    let hasErrors = false;
+    const errors = Array.from(Array(remaining));
+    const results = Array.from(Array(remaining));
+    let i = 0;
+    function operationCallback(index, e, result) {
+        if (e) {
+            hasErrors = true;
+            errors[index] = e;
+        }
+        else {
+            results[index] = result;
+        }
+        remaining--;
+        if (remaining === 0) {
+            callback(hasErrors ? new MultipleErrors(errorMessage, errors) : null, results);
+        }
+    }
+    for (const item of collection) {
+        operation(item, operationCallback.bind(null, i++));
+    }
+}

package/dist/clients/consumer/consumer.d.ts

@@ -0,0 +1,33 @@
+import { type FetchResponse } from '../../apis/consumer/fetch.ts';
+import { Base } from '../base/base.ts';
+import { type CallbackWithPromise } from '../callbacks.ts';
+import { MessagesStream } from './messages-stream.ts';
+import { TopicsMap } from './topics-map.ts';
+import { type CommitOptions, type ConsumeOptions, type ConsumerOptions, type FetchOptions, type GroupAssignment, type GroupOptions, type ListCommitsOptions, type ListOffsetsOptions, type Offsets } from './types.ts';
+export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ConsumerOptions<Key, Value, HeaderKey, HeaderValue>> {
+    #private;
+    groupId: string;
+    generationId: number;
+    memberId: string | null;
+    topics: TopicsMap;
+    assignments: GroupAssignment[] | null;
+    constructor(options: ConsumerOptions<Key, Value, HeaderKey, HeaderValue>);
+    close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
+    close(force?: boolean): Promise<void>;
+    consume(options: ConsumeOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<MessagesStream<Key, Value, HeaderKey, HeaderValue>>): void;
+    consume(options: ConsumeOptions<Key, Value, HeaderKey, HeaderValue>): Promise<MessagesStream<Key, Value, HeaderKey, HeaderValue>>;
+    fetch(options: FetchOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<FetchResponse>): void;
+    fetch(options: FetchOptions<Key, Value, HeaderKey, HeaderValue>): Promise<FetchResponse>;
+    commit(options: CommitOptions, callback: CallbackWithPromise<void>): void;
+    commit(options: CommitOptions): Promise<void>;
+    listOffsets(options: ListOffsetsOptions, callback: CallbackWithPromise<Offsets>): void;
+    listOffsets(options: ListOffsetsOptions): Promise<Offsets>;
+    listCommittedOffsets(options: ListCommitsOptions, callback: CallbackWithPromise<Offsets>): void;
+    listCommittedOffsets(options: ListCommitsOptions): Promise<Offsets>;
+    findGroupCoordinator(callback: CallbackWithPromise<number>): void;
+    findGroupCoordinator(): Promise<number>;
+    joinGroup(options: GroupOptions, callback: CallbackWithPromise<string>): void;
+    joinGroup(options: GroupOptions): Promise<string>;
+    leaveGroup(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
+    leaveGroup(force?: boolean): Promise<void>;
+}