@platformatic/kafka 2.2.3 → 2.3.1

package/dist/clients/admin/admin.js

@@ -374,7 +374,7 @@ export class Admin extends Base {
     }
     #handleNotControllerError(error, value, callback) {
         if (error && error?.findBy?.('apiCode', 41)) {
-            this.metadata({ topics: [] }, (metadataError, metadata) => {
+            this[kMetadata]({ topics: [], forceUpdate: true }, (metadataError, metadata) => {
                 /* c8 ignore next 4 - Hard to test */
                 if (metadataError) {
                     callback(metadataError);
@@ -407,7 +407,7 @@ export class Admin extends Base {
                 });
             }, (error, metadata) => {
                 if (error) {
-                    deduplicateCallback(error);
+                    deduplicateCallback(new MultipleErrors('Listing topics failed.', [error]));
                     return;
                 }
                 const topics = new Set();
@@ -460,7 +460,7 @@ export class Admin extends Base {
                 });
             }, (error, response) => {
                 if (error) {
-                    deduplicateCallback(error);
+                    deduplicateCallback(new MultipleErrors('Creating topics failed.', [error]));
                     return;
                 }
                 const created = [];
@@ -497,7 +497,13 @@ export class Admin extends Base {
                         });
                     });
                 });
-            }, deduplicateCallback, 0);
+            }, (error, response) => {
+                if (error) {
+                    callback(new MultipleErrors('Deleting topics failed.', [error]));
+                    return;
+                }
+                deduplicateCallback(null, response);
+            }, 0);
         }, error => callback(error));
     }
     #createPartitions(options, callback) {
@@ -529,13 +535,14 @@ export class Admin extends Base {
         });
     }
     #listGroups(options, callback) {
-        // Find all the brokers in the cluster
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
+        this[kMetadata]({ topics: [], forceUpdate: true }, (error, metadata) => {
             if (error) {
                 callback(error);
                 return;
             }
-            runConcurrentCallbacks('Listing groups failed.', metadata.brokers, ([, broker], concurrentCallback) => {
+            runConcurrentCallbacks('Listing groups failed.', 
+            // metadata must be defined as error was undefined
+            metadata.brokers, ([, broker], concurrentCallback) => {
                 this[kGetConnection](broker, (error, connection) => {
                     if (error) {
                         concurrentCallback(error);
@@ -573,45 +580,42 @@ export class Admin extends Base {
         });
     }
     #describeGroups(options, callback) {
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
+        this[kPerformWithRetry]('describeGroups', retryCallback => {
             this.#findCoordinator({ keyType: FindCoordinatorKeyTypes.GROUP, keys: options.groups }, (error, coordinators) => {
                 if (error) {
-                    callback(error);
+                    // FindCoordinator already retried some times so no retry again
+                    callback(new MultipleErrors('Describing groups failed.', error instanceof MultipleErrors ? error.errors : [error]));
                     return;
                 }
-                // Group the groups by coordinator
                 const coordinatorsMap = new Map();
-                for (const { key: group, nodeId: node } of coordinators) {
-                    let coordinator = coordinatorsMap.get(node);
-                    if (!coordinator) {
-                        coordinator = [];
-                        coordinatorsMap.set(node, coordinator);
+                // coordinators must be defined as error was undefined
+                for (const coordinator of coordinators) {
+                    let coordinatorAggregate = coordinatorsMap.get(coordinator.nodeId);
+                    if (!coordinatorAggregate) {
+                        coordinatorAggregate = { host: coordinator.host, port: coordinator.port, groups: [] };
+                        coordinatorsMap.set(coordinator.nodeId, coordinatorAggregate);
                     }
-                    coordinator.push(group);
+                    coordinatorAggregate.groups.push(coordinator.key);
                 }
-                runConcurrentCallbacks('Describing groups failed.', coordinatorsMap, ([node, groups], concurrentCallback) => {
-                    this[kGetConnection](metadata.brokers.get(node), (error, connection) => {
-                        if (error) {
-                            concurrentCallback(error);
-                            return;
-                        }
-                        this[kPerformWithRetry]('describeGroups', retryCallback => {
+                runConcurrentCallbacks('Describing groups failed.', coordinatorsMap.values(), (coordinator, concurrentCallback) => {
+                    this[kPerformWithRetry]('describeGroupsOnCoordinator', retryCallback => {
+                        this[kGetConnection](coordinator, (error, connection) => {
+                            if (error) {
+                                retryCallback(error);
+                                return;
+                            }
                             this[kGetApi]('DescribeGroups', (error, api) => {
                                 if (error) {
                                     retryCallback(error);
                                     return;
                                 }
-                                api(connection, groups, options.includeAuthorizedOperations ?? false, retryCallback);
+                                api(connection, coordinator.groups, options.includeAuthorizedOperations ?? false, retryCallback);
                             });
-                        }, concurrentCallback, 0);
-                    });
+                        });
+                    }, concurrentCallback, 0);
                 }, (error, results) => {
                     if (error) {
-                        callback(error);
+                        retryCallback(error);
                         return;
                     }
                     const groups = new Map();
@@ -655,59 +659,58 @@ export class Admin extends Base {
                             groups.set(group.id, group);
                         }
                     }
-                    callback(null, groups);
+                    retryCallback(null, groups);
                 });
             });
-        });
+        }, callback, 0);
     }
     #deleteGroups(options, callback) {
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
+        this[kPerformWithRetry]('deleteGroups', retryCallback => {
             this.#findCoordinator({ keyType: FindCoordinatorKeyTypes.GROUP, keys: options.groups }, (error, coordinators) => {
                 if (error) {
-                    callback(error);
+                    // FindCoordinator already retried some times so no retry again
+                    callback(new MultipleErrors('Deleting groups failed.', error instanceof MultipleErrors ? error.errors : [error]));
                     return;
                 }
-                // Group the groups by coordinator
                 const coordinatorsMap = new Map();
-                for (const { key: group, nodeId: node } of coordinators) {
-                    let coordinator = coordinatorsMap.get(node);
-                    if (!coordinator) {
-                        coordinator = [];
-                        coordinatorsMap.set(node, coordinator);
+                // coordinators must be defined as error was undefined
+                for (const coordinator of coordinators) {
+                    let coordinatorAggregate = coordinatorsMap.get(coordinator.nodeId);
+                    if (!coordinatorAggregate) {
+                        coordinatorAggregate = { host: coordinator.host, port: coordinator.port, groups: [] };
+                        coordinatorsMap.set(coordinator.nodeId, coordinatorAggregate);
                     }
-                    coordinator.push(group);
+                    coordinatorAggregate.groups.push(coordinator.key);
                 }
-                runConcurrentCallbacks('Deleting groups failed.', coordinatorsMap, ([node, groups], concurrentCallback) => {
-                    this[kGetConnection](metadata.brokers.get(node), (error, connection) => {
-                        if (error) {
-                            concurrentCallback(error);
-                            return;
-                        }
-                        this[kPerformWithRetry]('deleteGroups', retryCallback => {
+                runConcurrentCallbacks('Deleting groups failed.', coordinatorsMap.values(), (coordinator, concurrentCallback) => {
+                    this[kPerformWithRetry]('deleteGroupsOnCoordinator', retryCallback => {
+                        this[kGetConnection](coordinator, (error, connection) => {
+                            if (error) {
+                                retryCallback(error);
+                                return;
+                            }
                             this[kGetApi]('DeleteGroups', (error, api) => {
                                 if (error) {
                                     retryCallback(error);
                                     return;
                                 }
-                                api(connection, groups, retryCallback);
+                                api(connection, coordinator.groups, retryCallback);
                             });
-                        }, concurrentCallback, 0);
-                    });
-                }, error => callback(error));
+                        });
+                    }, concurrentCallback, 0);
+                }, retryCallback);
             });
-        });
+        }, callback, 0);
     }
     #removeMembersFromConsumerGroup(options, callback) {
         if (!options.members || options.members.length === 0) {
+            // Remove all members if none are specified
             this.#describeGroups({ groups: [options.groupId] }, (error, groupsMap) => {
                 if (error) {
                     callback(new MultipleErrors('Removing members from consumer group failed.', [error]));
                     return;
                 }
+                // groupsMap must be defined as error was undefined
                 const group = groupsMap.get(options.groupId);
                 /* c8 ignore next 4 - Hard to test */
                 if (!group) {
@@ -724,61 +727,46 @@ export class Admin extends Base {
             });
             return;
         }
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
-            if (error) {
-                callback(error, undefined);
-                return;
-            }
+        this[kPerformWithRetry]('removeMembersFromConsumerGroup', retryCallback => {
             this.#findCoordinator({ keyType: FindCoordinatorKeyTypes.GROUP, keys: [options.groupId] }, (error, coordinators) => {
                 if (error) {
-                    callback(new MultipleErrors('Removing members from consumer group failed.', [error]));
+                    // FindCoordinator already retried some times so no retry again
+                    callback(new MultipleErrors('Removing members from consumer group failed.', error instanceof MultipleErrors ? error.errors : [error]));
                     return;
                 }
                 const coordinator = coordinators.find(c => c.key === options.groupId);
                 /* c8 ignore next 8 - Hard to test */
                 if (!coordinator) {
-                    callback(new MultipleErrors('Removing members from consumer group failed.', [
-                        new Error(`No coordinator found for group ${options.groupId}`)
-                    ]));
+                    retryCallback(new Error('Group coordinator not found'));
                     return;
                 }
-                const broker = metadata.brokers.get(coordinator.nodeId);
-                /* c8 ignore next 8 - Hard to test */
-                if (!broker) {
-                    callback(new MultipleErrors('Removing members from consumer group failed.', [
-                        new Error(`Broker ${coordinator.nodeId} not found`)
-                    ]));
-                    return;
-                }
-                this[kGetConnection](broker, (error, connection) => {
+                this[kGetConnection](coordinator, (error, connection) => {
                     if (error) {
-                        callback(new MultipleErrors('Removing members from consumer group failed.', [error]));
+                        retryCallback(error);
                         return;
                     }
-                    this[kPerformWithRetry]('removeMembersFromConsumerGroup', retryCallback => {
-                        this[kGetApi]('LeaveGroup', (error, api) => {
-                            if (error) {
-                                retryCallback(error);
-                                return;
-                            }
-                            /* c8 ignore next 5 - Hard to test */
-                            const members = options.members.map(member => ({
-                                memberId: typeof member === 'string' ? member : member.memberId,
-                                groupInstanceId: null,
-                                reason: typeof member === 'string' ? 'Not specified' : member.reason
-                            }));
-                            api(connection, options.groupId, members, retryCallback);
-                        });
-                    }, error => {
+                    this[kGetApi]('LeaveGroup', (error, api) => {
                         if (error) {
-                            callback(new MultipleErrors('Removing members from consumer group failed.', [error]));
+                            retryCallback(error);
                             return;
                         }
-                        callback(null);
-                    }, 0);
+                        /* c8 ignore next 5 - Hard to test */
+                        const members = options.members.map(member => ({
+                            memberId: typeof member === 'string' ? member : member.memberId,
+                            groupInstanceId: null,
+                            reason: typeof member === 'string' ? 'Not specified' : member.reason
+                        }));
+                        api(connection, options.groupId, members, retryCallback);
+                    });
                 });
             });
-        });
+        }, error => {
+            if (error) {
+                callback(new MultipleErrors('Removing members from consumer group failed.', [error]));
+                return;
+            }
+            callback(null);
+        }, 0);
     }
     #findCoordinator(options, callback) {
         this[kPerformWithRetry]('findCoordinator', retryCallback => {
@@ -797,7 +785,7 @@ export class Admin extends Base {
             });
         }, (error, response) => {
             if (error) {
-                callback(error);
+                callback(new MultipleErrors('Finding coordinator failed.', [error]));
                 return;
             }
             callback(null, response.coordinators.map(coordinator => ({
@@ -855,19 +843,21 @@ export class Admin extends Base {
         }, 0);
     }
     #describeLogDirs(options, callback) {
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
+        this[kMetadata]({ topics: [], forceUpdate: true }, (error, metadata) => {
             /* c8 ignore next 4 - Hard to test */
             if (error) {
                 callback(error);
                 return;
             }
-            runConcurrentCallbacks('Describing log dirs failed.', metadata.brokers, ([id, broker], concurrentCallback) => {
-                this[kGetConnection](broker, (error, connection) => {
-                    if (error) {
-                        concurrentCallback(error);
-                        return;
-                    }
-                    this[kPerformWithRetry]('describeLogDirs', retryCallback => {
+            runConcurrentCallbacks('Describing log dirs failed.', 
+            // metadata must be defined as error was undefined
+            metadata.brokers, ([id, broker], concurrentCallback) => {
+                this[kPerformWithRetry]('describeLogDirs', retryCallback => {
+                    this[kGetConnection](broker, (error, connection) => {
+                        if (error) {
+                            retryCallback(error);
+                            return;
+                        }
                         this[kGetApi]('DescribeLogDirs', (error, api) => {
                             if (error) {
                                 retryCallback(error);
@@ -875,82 +865,84 @@ export class Admin extends Base {
                             }
                             api(connection, options.topics, retryCallback);
                         });
-                    }, (error, response) => {
-                        if (error) {
-                            concurrentCallback(error);
-                            return;
-                        }
-                        concurrentCallback(null, {
-                            broker: id,
-                            throttleTimeMs: response.throttleTimeMs,
-                            results: response.results.map(result => ({
-                                logDir: result.logDir,
-                                topics: result.topics,
-                                totalBytes: result.totalBytes,
-                                usableBytes: result.usableBytes
-                            }))
-                        });
-                    }, 0);
-                });
+                    });
+                }, (error, response) => {
+                    if (error) {
+                        concurrentCallback(error);
+                        return;
+                    }
+                    concurrentCallback(null, {
+                        broker: id,
+                        throttleTimeMs: response.throttleTimeMs,
+                        results: response.results.map(result => ({
+                            logDir: result.logDir,
+                            topics: result.topics,
+                            totalBytes: result.totalBytes,
+                            usableBytes: result.usableBytes
+                        }))
+                    });
+                }, 0);
             }, callback);
         });
     }
     #listConsumerGroupOffsets(options, callback) {
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
+        this[kPerformWithRetry]('listConsumerGroupOffsets', retryCallback => {
             /* c8 ignore next - Hard to test */
             const groupIds = options.groups.map(group => (typeof group === 'string' ? group : group.groupId));
             this.#findCoordinator({ keyType: FindCoordinatorKeyTypes.GROUP, keys: groupIds }, (error, coordinators) => {
                 if (error) {
-                    callback(new MultipleErrors('Listing consumer group offsets failed.', [error]));
+                    // FindCoordinator already retried some times so no retry again
+                    callback(new MultipleErrors('Listing consumer group offsets failed.', error instanceof MultipleErrors ? error.errors : [error]));
                     return;
                 }
                 const coordinatorsMap = new Map();
-                for (const { key: groupId, nodeId: node } of coordinators) {
+                for (const coordinator of coordinators) {
                     const groupRequest = {
-                        groupId,
+                        groupId: coordinator.key,
                         memberId: null,
                         memberEpoch: -1
                     };
                     for (const group of options.groups) {
-                        if (typeof group !== 'string' && group.groupId === groupId && !!group.topics && group.topics.length > 0) {
+                        if (typeof group !== 'string' &&
+                            group.groupId === coordinator.key &&
+                            !!group.topics &&
+                            group.topics.length > 0) {
                             groupRequest.topics = group.topics;
                             break;
                         }
                     }
-                    let coordinator = coordinatorsMap.get(node);
-                    if (!coordinator) {
-                        coordinator = [];
-                        coordinatorsMap.set(node, coordinator);
+                    let offsetFetchRequestGroups = coordinatorsMap.get(coordinator.nodeId);
+                    if (!offsetFetchRequestGroups) {
+                        offsetFetchRequestGroups = { coordinator, groupRequests: [] };
+                        coordinatorsMap.set(coordinator.nodeId, offsetFetchRequestGroups);
                     }
-                    coordinator.push(groupRequest);
+                    offsetFetchRequestGroups.groupRequests.push(groupRequest);
                 }
-                runConcurrentCallbacks('Listing consumer group offsets failed.', coordinatorsMap, ([node, groups], concurrentCallback) => {
-                    this[kGetConnection](metadata.brokers.get(node), (error, connection) => {
-                        if (error) {
-                            concurrentCallback(error);
-                            return;
-                        }
-                        this[kPerformWithRetry]('offsetFetch', retryCallback => {
+                runConcurrentCallbacks('Listing consumer group offsets failed.', coordinatorsMap.values(), ({ coordinator, groupRequests }, concurrentCallback) => {
+                    this[kPerformWithRetry]('offsetFetch', retryCallback => {
+                        this[kGetConnection](coordinator, (error, connection) => {
+                            if (error) {
+                                retryCallback(error);
+                                return;
+                            }
                             this[kGetApi]('OffsetFetch', (error, api) => {
                                 if (error) {
                                     retryCallback(error);
                                     return;
                                 }
                                 /* c8 ignore next - Hard to test */
-                                api(connection, groups, options.requireStable ?? false, retryCallback);
+                                api(connection, groupRequests, options.requireStable ?? false, retryCallback);
                             });
-                        }, concurrentCallback, 0);
-                    });
+                        });
+                    }, concurrentCallback, 0);
                 }, (error, responses) => {
                     if (error) {
-                        callback(error);
+                        retryCallback(error);
                         return;
                     }
-                    callback(null, responses.flatMap(r => r.groups.map(group => ({
+                    retryCallback(null, 
+                    // responses must be defined as error was undefined
+                    responses.flatMap(r => r.groups.map(group => ({
                         groupId: group.groupId,
                         topics: group.topics.map(topic => ({
                             name: topic.name,
@@ -964,125 +956,101 @@ export class Admin extends Base {
                     }))));
                 });
             });
-        });
+        }, callback, 0);
     }
     #alterConsumerGroupOffsets(options, callback) {
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
-            if (error) {
-                callback(error, undefined);
-                return;
-            }
+        this[kPerformWithRetry]('alterConsumerGroupOffsets', retryCallback => {
             this.#findCoordinator({ keyType: FindCoordinatorKeyTypes.GROUP, keys: [options.groupId] }, (error, coordinators) => {
                 if (error) {
-                    callback(new MultipleErrors('Altering consumer group offsets failed.', [error]));
+                    // FindCoordinator already retried some times so no retry again
+                    callback(new MultipleErrors('Altering consumer group offsets failed.', error instanceof MultipleErrors ? error.errors : [error]));
                     return;
                 }
                 const coordinator = coordinators.find(c => c.key === options.groupId);
                 /* c8 ignore next 9 - Hard to test */
                 if (!coordinator) {
-                    callback(new MultipleErrors('Altering consumer group offsets failed.', [
-                        new Error(`No coordinator found for group ${options.groupId}`)
-                    ]));
-                    return;
-                }
-                const broker = metadata.brokers.get(coordinator.nodeId);
-                /* c8 ignore next 9 - Hard to test */
-                if (!broker) {
-                    callback(new MultipleErrors('Altering consumer group offsets failed.', [
-                        new Error(`Broker ${coordinator.nodeId} not found`)
-                    ]));
+                    retryCallback(new Error('Group coordinator not found'));
                     return;
                 }
-                this[kGetConnection](broker, (error, connection) => {
+                this[kGetConnection](coordinator, (error, connection) => {
                     if (error) {
-                        callback(new MultipleErrors('Altering consumer group offsets failed.', [error]));
+                        retryCallback(error);
                         return;
                     }
-                    this[kPerformWithRetry]('alterConsumerGroupOffsets', retryCallback => {
-                        this[kGetApi]('OffsetCommit', (error, api) => {
-                            if (error) {
-                                retryCallback(error);
-                                return;
-                            }
-                            const topics = [];
-                            for (const topic of options.topics) {
-                                const partitions = topic.partitionOffsets.map(p => ({
-                                    partitionIndex: p.partition,
-                                    committedOffset: p.offset,
-                                    committedLeaderEpoch: -1,
-                                    committedMetadata: null
-                                }));
-                                topics.push({ name: topic.name, partitions });
-                            }
-                            api(connection, options.groupId, -1, '', null, topics, retryCallback);
-                        });
-                    }, error => {
+                    this[kGetApi]('OffsetCommit', (error, api) => {
                         if (error) {
-                            callback(new MultipleErrors('Altering consumer group offsets failed.', [error]));
+                            retryCallback(error);
                             return;
                         }
-                        callback(null);
-                    }, 0);
+                        const topics = [];
+                        for (const topic of options.topics) {
+                            const partitions = topic.partitionOffsets.map(p => ({
+                                partitionIndex: p.partition,
+                                committedOffset: p.offset,
+                                committedLeaderEpoch: -1,
+                                committedMetadata: null
+                            }));
+                            topics.push({ name: topic.name, partitions });
+                        }
+                        api(connection, options.groupId, -1, '', null, topics, retryCallback);
+                    });
                 });
             });
-        });
-    }
-    #deleteConsumerGroupOffsets(options, callback) {
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
+        }, error => {
             if (error) {
-                callback(error);
+                callback(new MultipleErrors('Altering consumer group offsets failed.', [error]));
                 return;
             }
+            callback(null);
+        }, 0);
+    }
+    #deleteConsumerGroupOffsets(options, callback) {
+        this[kPerformWithRetry]('deleteConsumerGroupOffsets', retryCallback => {
             this.#findCoordinator({ keyType: FindCoordinatorKeyTypes.GROUP, keys: [options.groupId] }, (error, coordinators) => {
                 if (error) {
-                    callback(new MultipleErrors('Deleting consumer group offsets failed.', [error]));
+                    // FindCoordinator already retried some times so no retry again
+                    callback(new MultipleErrors('Deleting consumer group offsets failed.', error instanceof MultipleErrors ? error.errors : [error]));
                     return;
                 }
                 const coordinator = coordinators.find(c => c.key === options.groupId);
                 /* c8 ignore next 9 - Hard to test */
                 if (!coordinator) {
-                    callback(new MultipleErrors('Deleting consumer group offsets failed.', [
-                        new Error(`No coordinator found for group ${options.groupId}`)
-                    ]));
-                    return;
-                }
-                const broker = metadata.brokers.get(coordinator.nodeId);
-                /* c8 ignore next 9 - Hard to test */
-                if (!broker) {
-                    callback(new MultipleErrors('Deleting consumer group offsets failed.', [
-                        new Error(`Broker ${coordinator.nodeId} not found`)
-                    ]));
+                    retryCallback(new Error('Group coordinator not found'));
                     return;
                 }
-                this[kGetConnection](broker, (error, connection) => {
+                this[kGetConnection](coordinator, (error, connection) => {
                     if (error) {
-                        callback(new MultipleErrors('Deleting consumer group offsets failed.', [error]));
+                        retryCallback(error);
                         return;
                     }
-                    this[kPerformWithRetry]('deleteOffset', retryCallback => {
-                        this[kGetApi]('OffsetDelete', (error, api) => {
+                    this[kGetApi]('OffsetDelete', (error, api) => {
+                        if (error) {
+                            retryCallback(error);
+                            return;
+                        }
+                        api(connection, options.groupId, options.topics.map(t => ({
+                            name: t.name,
+                            partitions: t.partitionIndexes.map(p => ({ partitionIndex: p }))
+                        })), (error, response) => {
                             if (error) {
                                 retryCallback(error);
                                 return;
                             }
-                            api(connection, options.groupId, options.topics.map(t => ({
-                                name: t.name,
-                                partitions: t.partitionIndexes.map(p => ({ partitionIndex: p }))
-                            })), retryCallback);
+                            retryCallback(null, response.topics.map(topic => ({
+                                name: topic.name,
+                                partitionIndexes: topic.partitions.map(p => p.partitionIndex)
+                            })));
                         });
-                    }, (error, response) => {
-                        if (error) {
-                            callback(new MultipleErrors('Deleting consumer group offsets failed.', [error]));
-                            return;
-                        }
-                        callback(null, response.topics.map(topic => ({
-                            name: topic.name,
-                            partitionIndexes: topic.partitions.map(p => p.partitionIndex)
-                        })));
-                    }, 0);
+                    });
                 });
             });
-        });
+        }, (error, results) => {
+            if (error) {
+                callback(new MultipleErrors('Deleting consumer group offsets failed.', [error]));
+                return;
+            }
+            callback(null, results);
+        }, 0);
     }
     #getConfigRequestsDistributedToBrokers(resources) {
         const brokerConfigResourceMap = new Map();
@@ -1108,7 +1076,7 @@ export class Admin extends Base {
             this[kGetBootstrapConnection](callback);
             return;
         }
-        this[kMetadata]({ topics: [] }, (error, metadata) => {
+        this[kMetadata]({ topics: [], forceUpdate: true }, (error, metadata) => {
             /* c8 ignore next 4 - Hard to test */
             if (error) {
                 callback(error);
@@ -1125,13 +1093,7 @@ export class Admin extends Base {
     }
     #describeConfigs(options, callback) {
         runConcurrentCallbacks('Describing configs failed.', this.#getConfigRequestsDistributedToBrokers(options.resources), ([brokerId, resources], concurrentCallback) => {
-            this.#describeConfigsOnBroker({ ...options, resources }, brokerId, (error, response) => {
-                if (error) {
-                    concurrentCallback(error);
-                    return;
-                }
-                concurrentCallback(null, response);
-            });
+            this.#describeConfigsOnBroker({ ...options, resources }, brokerId, concurrentCallback);
         }, (error, results) => {
             callback(error, results?.flat());
         });
@@ -1307,154 +1269,166 @@ export class Admin extends Base {
         }, 0);
     }
     #deleteRecords(options, callback) {
-        this[kMetadata]({ topics: options.topics.map(topic => topic.name) }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
-            const requestsByLeader = new Map();
-            for (const topic of options.topics) {
-                for (const partition of topic.partitions) {
-                    const { leader } = metadata.topics.get(topic.name).partitions[partition.partition];
-                    let leaderRequests = requestsByLeader.get(leader);
-                    if (!leaderRequests) {
-                        leaderRequests = new Map();
-                        requestsByLeader.set(leader, leaderRequests);
-                    }
-                    let topicRequest = leaderRequests.get(topic.name);
-                    if (!topicRequest) {
-                        topicRequest = { name: topic.name, partitions: [] };
-                        leaderRequests.set(topic.name, topicRequest);
-                    }
-                    topicRequest.partitions.push({
-                        partitionIndex: partition.partition,
-                        offset: partition.offset
-                    });
+        this[kPerformWithRetry]('deleteRecords', retryCallback => {
+            this[kMetadata]({ topics: options.topics.map(topic => topic.name), forceUpdate: true }, (error, metadata) => {
+                if (error) {
+                    // Metadata request already retried some times so no retry again
+                    callback(error);
+                    return;
                 }
-            }
-            const requests = new Map();
-            for (const [leader, topics] of requestsByLeader) {
-                requests.set(leader, Array.from(topics.values()));
-            }
-            runConcurrentCallbacks('Deleting records failed.', requests, ([leader, requests], concurrentCallback) => {
-                this[kGetConnection](metadata.brokers.get(leader), (error, connection) => {
-                    if (error) {
-                        concurrentCallback(error);
-                        return;
+                const requests = new Map();
+                for (const topic of options.topics) {
+                    for (const partition of topic.partitions) {
+                        // metadata!.topics.get(topic.name) must be defined as the metadata request was successful
+                        const topicData = metadata.topics.get(topic.name);
+                        const targetPartitionData = topicData.partitions[partition.partition];
+                        /* c8 ignore next 4 - Hard to test */
+                        if (!targetPartitionData) {
+                            retryCallback(new UserError('Unknown partition.'));
+                            return;
+                        }
+                        const broker = metadata.brokers.get(targetPartitionData.leader);
+                        let leaderRequests = requests.get(broker);
+                        if (!leaderRequests) {
+                            leaderRequests = [];
+                            requests.set(broker, leaderRequests);
+                        }
+                        let topicRequest = leaderRequests.find(tr => tr.name === topic.name);
+                        if (!topicRequest) {
+                            topicRequest = { name: topic.name, partitions: [] };
+                            leaderRequests.push(topicRequest);
+                        }
+                        topicRequest.partitions.push({
+                            partitionIndex: partition.partition,
+                            offset: partition.offset
+                        });
                     }
-                    this[kPerformWithRetry]('deleteRecords', retryCallback => {
-                        this[kGetApi]('DeleteRecords', (error, api) => {
+                }
+                runConcurrentCallbacks('Deleting records failed.', requests, ([leader, requests], concurrentCallback) => {
+                    this[kPerformWithRetry]('deleteRecordsOnLeader', retryCallback => {
+                        this[kGetConnection](leader, (error, connection) => {
                             if (error) {
                                 retryCallback(error);
                                 return;
                             }
-                            api(connection, Array.from(requests.values()), this[kOptions].timeout, retryCallback);
+                            this[kGetApi]('DeleteRecords', (error, api) => {
+                                if (error) {
+                                    retryCallback(error);
+                                    return;
+                                }
+                                api(connection, requests, this[kOptions].timeout, retryCallback);
+                            });
                         });
                     }, concurrentCallback, 0);
+                }, (error, responses) => {
+                    if (error) {
+                        // Do not retry failed deletion requests
+                        callback(error);
+                        return;
+                    }
+                    const deletedRecordsByTopic = new Map();
+                    for (const response of responses) {
+                        for (const topic of response.topics) {
+                            let topicDeletedRecords = deletedRecordsByTopic.get(topic.name);
+                            if (!topicDeletedRecords) {
+                                topicDeletedRecords = { name: topic.name, partitions: [] };
+                                deletedRecordsByTopic.set(topic.name, topicDeletedRecords);
+                            }
+                            for (const partition of topic.partitions) {
+                                topicDeletedRecords.partitions.push({
+                                    partition: partition.partitionIndex,
+                                    lowWatermark: partition.lowWatermark
+                                });
+                            }
+                        }
+                    }
+                    retryCallback(null, Array.from(deletedRecordsByTopic.values()));
                 });
-            }, (error, responses) => {
+            });
+        }, callback, 0);
+    }
+    #listOffsets(options, callback) {
+        this[kPerformWithRetry]('listOffsets', retryCallback => {
+            this[kMetadata]({ topics: options.topics.map(topic => topic.name), forceUpdate: true }, (error, metadata) => {
                 if (error) {
+                    // Metadata request already retried some times so no retry again
                     callback(error);
                     return;
                 }
-                const deletedRecordsByTopic = new Map();
-                for (const response of responses) {
-                    for (const topic of response.topics) {
-                        let topicDeletedRecords = deletedRecordsByTopic.get(topic.name);
-                        if (!topicDeletedRecords) {
-                            topicDeletedRecords = { name: topic.name, partitions: [] };
-                            deletedRecordsByTopic.set(topic.name, topicDeletedRecords);
+                // metadata must be defined at this point
+                const { topics, brokers } = metadata;
+                const requests = new Map();
+                for (const topic of options.topics) {
+                    for (const partition of topic.partitions) {
+                        // topics.get(topic.name) must be defined as the metadata request was successful
+                        const topicData = topics.get(topic.name);
+                        const targetPartitionData = topicData.partitions[partition.partitionIndex];
+                        /* c8 ignore next 4 - Hard to test */
+                        if (!targetPartitionData) {
+                            retryCallback(new UserError('Unknown partition.'));
+                            return;
                         }
-                        for (const partition of topic.partitions) {
-                            topicDeletedRecords.partitions.push({
-                                partition: partition.partitionIndex,
-                                lowWatermark: partition.lowWatermark
-                            });
+                        const broker = brokers.get(targetPartitionData.leader);
+                        let leaderRequests = requests.get(broker);
+                        if (!leaderRequests) {
+                            leaderRequests = [];
+                            requests.set(broker, leaderRequests);
                         }
+                        let topicRequest = leaderRequests.find(t => t.name === topic.name);
+                        if (!topicRequest) {
+                            topicRequest = { name: topic.name, partitions: [] };
+                            leaderRequests.push(topicRequest);
+                        }
+                        topicRequest.partitions.push({
+                            partitionIndex: partition.partitionIndex,
+                            currentLeaderEpoch: targetPartitionData.leaderEpoch,
+                            /* c8 ignore next - Hard to test */
+                            timestamp: partition.timestamp ?? -1n
+                        });
                     }
                 }
-                callback(null, Array.from(deletedRecordsByTopic.values()));
-            });
-        });
-    }
-    #listOffsets(options, callback) {
-        this[kMetadata]({ topics: options.topics.map(topic => topic.name) }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
-            // metadata must be defined at this point
-            const { topics, brokers } = metadata;
-            const requests = new Map();
-            for (const topic of options.topics) {
-                for (const partition of topic.partitions) {
-                    // topics.get(topic.name) must be defined as the metadata request was successful
-                    const topicData = topics.get(topic.name);
-                    const targetPartitionData = topicData.partitions[partition.partitionIndex];
-                    /* c8 ignore next 4 - Hard to test */
-                    if (!targetPartitionData) {
-                        callback(new UserError(`Unknown partition ${partition.partitionIndex} for topic ${topic.name}.`));
-                        return;
-                    }
-                    let leaderRequests = requests.get(targetPartitionData.leader);
-                    if (!leaderRequests) {
-                        leaderRequests = [];
-                        requests.set(targetPartitionData.leader, leaderRequests);
-                    }
-                    let topicRequest = leaderRequests.find(t => t.name === topic.name);
-                    if (!topicRequest) {
-                        topicRequest = { name: topic.name, partitions: [] };
-                        leaderRequests.push(topicRequest);
-                    }
-                    topicRequest.partitions.push({
-                        partitionIndex: partition.partitionIndex,
-                        currentLeaderEpoch: targetPartitionData.leaderEpoch,
-                        /* c8 ignore next - Hard to test */
-                        timestamp: partition.timestamp ?? -1n
-                    });
-                }
-            }
-            runConcurrentCallbacks('Listing offsets failed.', requests, ([leader, requests], concurrentCallback) => {
-                this[kGetConnection](brokers.get(leader), (error, connection) => {
-                    if (error) {
-                        concurrentCallback(error);
-                        return;
-                    }
+                runConcurrentCallbacks('Listing offsets failed.', requests, ([leader, requests], concurrentCallback) => {
                     this[kPerformWithRetry]('listOffsets', retryCallback => {
-                        this[kGetApi]('ListOffsets', (error, api) => {
+                        this[kGetConnection](leader, (error, connection) => {
                             if (error) {
                                 retryCallback(error);
                                 return;
                             }
-                            api(connection, -1, options.isolationLevel ?? FetchIsolationLevels.READ_UNCOMMITTED, Array.from(requests.values()), retryCallback);
+                            this[kGetApi]('ListOffsets', (error, api) => {
+                                if (error) {
+                                    retryCallback(error);
+                                    return;
+                                }
+                                api(connection, -1, options.isolationLevel ?? FetchIsolationLevels.READ_UNCOMMITTED, requests, retryCallback);
+                            });
                         });
                     }, concurrentCallback, 0);
-                });
-            }, (error, responses) => {
-                if (error) {
-                    callback(error);
-                    return;
-                }
-                const ret = [];
-                for (const response of responses) {
-                    for (const topic of response.topics) {
-                        let topicOffsets = ret.find(t => t.name === topic.name);
-                        if (!topicOffsets) {
-                            topicOffsets = { name: topic.name, partitions: [] };
-                            ret.push(topicOffsets);
-                        }
-                        for (const partition of topic.partitions) {
-                            topicOffsets.partitions.push({
-                                offset: partition.offset,
-                                timestamp: partition.timestamp,
-                                partitionIndex: partition.partitionIndex,
-                                leaderEpoch: partition.leaderEpoch
-                            });
+                }, (error, responses) => {
+                    if (error) {
+                        retryCallback(error);
+                        return;
+                    }
+                    const ret = [];
+                    for (const response of responses) {
+                        for (const topic of response.topics) {
+                            let topicOffsets = ret.find(t => t.name === topic.name);
+                            if (!topicOffsets) {
+                                topicOffsets = { name: topic.name, partitions: [] };
+                                ret.push(topicOffsets);
+                            }
+                            for (const partition of topic.partitions) {
+                                topicOffsets.partitions.push({
+                                    offset: partition.offset,
+                                    timestamp: partition.timestamp,
+                                    partitionIndex: partition.partitionIndex,
+                                    leaderEpoch: partition.leaderEpoch
+                                });
+                            }
                         }
                     }
-                }
-                callback(null, ret);
+                    retryCallback(null, ret);
+                });
             });
-        });
+        }, callback, 0);
     }
 }