@platformatic/kafka 2.2.3 → 2.3.1

package/README.md

@@ -16,7 +16,9 @@ A modern, high-performance, pure TypeScript/JavaScript type safe client for Apac
 
 ## Supported Kafka Version
 
-Supported Kafka version are from **3.5.0** to **4.1.0** and equivalent, edges included.
+Supported Apache Kafka versions are from **3.5.0** to **4.2.0** and equivalent, edges included.
+
+These are tested in CI against the corresponding Confluent Platform releases, from **7.5.0** to **8.2.0** (rule of thumb: Confluent Platform version = Apache Kafka version + 4.0.0).
 
 ## Supported KIPs
 

package/dist/apis/admin/create-topics-v7.js

@@ -78,6 +78,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             return topic;
         })
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

package/dist/apis/callbacks.d.ts

@@ -6,6 +6,4 @@ export type CallbackWithPromise<ReturnType> = Callback<ReturnType> & {
     [kCallbackPromise]?: Promise<ReturnType>;
 };
 export declare function createPromisifiedCallback<ReturnType>(): CallbackWithPromise<ReturnType>;
-export declare function runConcurrentCallbacks<ReturnType, K, V>(errorMessage: string, collection: Map<K, V>, operation: (item: [K, V], cb: Callback<ReturnType>) => void, callback: Callback<ReturnType[]>): void;
-export declare function runConcurrentCallbacks<ReturnType, V>(errorMessage: string, collection: Set<V>, operation: (item: V, cb: Callback<ReturnType>) => void, callback: Callback<ReturnType[]>): void;
-export declare function runConcurrentCallbacks<ReturnType, V>(errorMessage: string, collection: V[], operation: (item: V, cb: Callback<ReturnType>) => void, callback: Callback<ReturnType[]>): void;
+export declare function runConcurrentCallbacks<R, V>(errorMessage: string, collection: Iterable<V>, operation: (item: V, cb: Callback<R>) => void, callback: Callback<R[]>): void;

package/dist/apis/callbacks.js

@@ -19,28 +19,43 @@ export function createPromisifiedCallback() {
     return callback;
 }
 export function runConcurrentCallbacks(errorMessage, collection, operation, callback) {
-    let remaining = Array.isArray(collection) ? collection.length : collection.size;
+    let allScheduled = false;
+    let completed = 0;
+    let callbackCalled = false;
     let hasErrors = false;
-    const errors = Array.from(Array(remaining));
-    const results = Array.from(Array(remaining));
+    const errors = [];
+    const results = [];
     let i = 0;
     function operationCallback(index, e, result) {
         if (e) {
             hasErrors = true;
-            errors[index] = e;
+            errors.push([index, e]);
+            results.push([index, undefined]);
         }
         else {
-            results[index] = result;
+            results.push([index, result]);
         }
-        remaining--;
-        if (remaining === 0) {
-            callback(hasErrors ? new MultipleErrors(errorMessage, errors.filter(Boolean)) : null, results);
+        completed++;
+        if (allScheduled && completed === i) {
+            callbackCalled = true;
+            const e = errors.sort((a, b) => a[0] - b[0]).map(([_, error]) => error);
+            const r = results.sort((a, b) => a[0] - b[0]).map(([_, result]) => result);
+            callback(hasErrors ? new MultipleErrors(errorMessage, e) : null, r);
         }
     }
-    if (remaining === 0) {
-        callback(null, results);
-    }
     for (const item of collection) {
         operation(item, operationCallback.bind(null, i++));
     }
+    if (i === 0) {
+        callback(null, []);
+        return;
+    }
+    allScheduled = true;
+    // If all operations were synchronous, allScheduled is not set to true in time for the operation
+    // callback to pick it up. In that case, call the callback here.
+    if (completed === i && !callbackCalled) {
+        const e = errors.sort((a, b) => a[0] - b[0]).map(([_, error]) => error);
+        const r = results.sort((a, b) => a[0] - b[0]).map(([_, result]) => result);
+        callback(hasErrors ? new MultipleErrors(errorMessage, e) : null, r);
+    }
 }