cluster close & destroy

Author: leibale

packages/client/lib/cluster/cluster-slots.ts

@@ -259,7 +259,7 @@ export default class RedisClusterSlots<
       // switch to `CLUSTER SHARDS` when Redis 7.0 will be the minimum supported version
       return await client.clusterSlots();
     } finally {
-      await client.disconnect();
+      client.destroy();
     }
   }
 
@@ -377,41 +377,67 @@ export default class RedisClusterSlots<
     return this._discoverWithRootNodes();
   }
 
+  /**
+   * @deprecated Use `close` instead.
+   */
   quit(): Promise<void> {
     return this._destroy(client => client.quit());
   }
 
+  /**
+   * @deprecated Use `destroy` instead.
+   */
   disconnect(): Promise<void> {
     return this._destroy(client => client.disconnect());
   }
 
-  private async _destroy(fn: (client: RedisClientType<M, F, S, RESP>) => Promise<unknown>): Promise<void> {
+  close() {
+    return this._destroy(client => client.close());
+  }
+
+  destroy() {
     this._isOpen = false;
 
-    const promises = [];
+    for (const client of this._clients()) {
+      this._execOnNodeClient(client, client => client.destroy());
+    }
+
+    if (this.pubSubNode) {
+      this._execOnNodeClient(this.pubSubNode.client, client => client.destroy());
+      this.pubSubNode = undefined;
+    }
+
+    this._resetSlots();
+    this.nodeByAddress.clear();
+  }
+
+  private *_clients() {
     for (const { master, replicas } of this.shards) {
       if (master.client) {
-        promises.push(
-          this._execOnNodeClient(master.client, fn)
-        );
+        yield master.client;
       }
 
       if (master.pubSubClient) {
-        promises.push(
-          this._execOnNodeClient(master.pubSubClient, fn)
-        );
+        yield master.pubSubClient;
       }
 
       if (replicas) {
         for (const { client } of replicas) {
           if (client) {
-            promises.push(
-              this._execOnNodeClient(client, fn)
-            );
+            yield client;
           }
         }
       }
     }
+  }
+
+  private async _destroy(fn: (client: RedisClientType<M, F, S, RESP>) => Promise<unknown>): Promise<void> {
+    this._isOpen = false;
+
+    const promises = [];
+    for (const client of this._clients()) {
+      promises.push(this._execOnNodeClient(client, fn));
+    }
 
     if (this.pubSubNode) {
       promises.push(this._execOnNodeClient(this.pubSubNode.client, fn));
@@ -424,10 +450,10 @@ export default class RedisClusterSlots<
     await Promise.allSettled(promises);
   }
 
-  private _execOnNodeClient(
+  private _execOnNodeClient<T>(
     client: ClientOrPromise<M, F, S, RESP>,
-    fn: (client: RedisClientType<M, F, S, RESP>) => Promise<unknown>
-  ) {
+    fn: (client: RedisClientType<M, F, S, RESP>) => T
+  ): T | Promise<T> {
     return types.isPromise(client) ?
       client.then(fn) :
       fn(client);

packages/client/lib/cluster/index.ts

@@ -503,14 +503,28 @@ export default class RedisCluster<
 
   sUnsubscribe = this.SUNSUBSCRIBE;
 
-  // quit(): Promise<void> {
-  //   return this.#slots.quit();
-  // }
+  /**
+   * @deprecated Use `close` instead.
+   */
+  quit() {
+    return this._slots.quit();
+  }
 
-  disconnect(): Promise<void> {
+  /**
+   * @deprecated Use `destroy` instead.
+   */
+  disconnect() {
     return this._slots.disconnect();
   }
 
+  close() {
+    return this._slots.close();
+  }
+
+  destroy() {
+    return this._slots.destroy();
+  }
+
   nodeClient(node: ShardNode<M, F, S, RESP>) {
     return this._slots.nodeClient(node);
   }