move from TypeScript privates to "#"

Author: leibale

packages/client/lib/client/commands-queue.ts

@@ -44,18 +44,18 @@ const RESP2_PUSH_TYPE_MAPPING = {
 };
 
 export default class RedisCommandsQueue {
-  private readonly _maxLength: number | null | undefined;
-  private readonly _toWrite = new DoublyLinkedList<CommandToWrite>();
-  private readonly _waitingForReply = new SinglyLinkedList<CommandWaitingForReply>();
-  private readonly _onShardedChannelMoved: OnShardedChannelMoved;
+  readonly #maxLength: number | null | undefined;
+  readonly #toWrite = new DoublyLinkedList<CommandToWrite>();
+  readonly #waitingForReply = new SinglyLinkedList<CommandWaitingForReply>();
+  readonly #onShardedChannelMoved: OnShardedChannelMoved;
 
-  private readonly _pubSub = new PubSub();
+  readonly #pubSub = new PubSub();
 
   get isPubSubActive() {
-    return this._pubSub.isActive;
+    return this.#pubSub.isActive;
   }
 
-  private _chainInExecution: symbol | undefined;
+  #chainInExecution: symbol | undefined;
 
   decoder: Decoder;
 
@@ -64,92 +64,92 @@ export default class RedisCommandsQueue {
     maxLength: number | null | undefined,
     onShardedChannelMoved: EventEmitter['emit']
   ) {
-    this.decoder = this._initiateDecoder(respVersion);
-    this._maxLength = maxLength;
-    this._onShardedChannelMoved = onShardedChannelMoved;
+    this.decoder = this.#initiateDecoder(respVersion);
+    this.#maxLength = maxLength;
+    this.#onShardedChannelMoved = onShardedChannelMoved;
   }
 
-  private _initiateDecoder(respVersion: RespVersions | null | undefined) {
+  #initiateDecoder(respVersion: RespVersions | null | undefined) {
     return respVersion === 3 ?
-      this._initiateResp3Decoder() :
-      this._initiateResp2Decoder();
+      this.#initiateResp3Decoder() :
+      this.#initiateResp2Decoder();
   }
 
-  private _onReply(reply: ReplyUnion) {
-    this._waitingForReply.shift()!.resolve(reply);
+  #onReply(reply: ReplyUnion) {
+    this.#waitingForReply.shift()!.resolve(reply);
   }
 
-  private _onErrorReply(err: ErrorReply) {
-    this._waitingForReply.shift()!.reject(err);
+  #onErrorReply(err: ErrorReply) {
+    this.#waitingForReply.shift()!.reject(err);
   }
 
-  private _onPush(push: Array<any>) {
+  #onPush(push: Array<any>) {
     // TODO: type
-    if (this._pubSub.handleMessageReply(push)) return true;
+    if (this.#pubSub.handleMessageReply(push)) return true;
 
     const isShardedUnsubscribe = PubSub.isShardedUnsubscribe(push);
-    if (isShardedUnsubscribe && !this._waitingForReply.length) {
+    if (isShardedUnsubscribe && !this.#waitingForReply.length) {
       const channel = push[1].toString();
-      this._onShardedChannelMoved(
+      this.#onShardedChannelMoved(
         channel,
-        this._pubSub.removeShardedListeners(channel)
+        this.#pubSub.removeShardedListeners(channel)
       );
       return true;
     } else if (isShardedUnsubscribe || PubSub.isStatusReply(push)) {
-      const head = this._waitingForReply.head!.value;
+      const head = this.#waitingForReply.head!.value;
       if (
         (Number.isNaN(head.channelsCounter!) && push[2] === 0) ||
         --head.channelsCounter! === 0
       ) {
-        this._waitingForReply.shift()!.resolve();
+        this.#waitingForReply.shift()!.resolve();
       }
       return true;
     }
   }
 
-  private _getTypeMapping() {
-    return this._waitingForReply.head!.value.typeMapping ?? {};
+  #getTypeMapping() {
+    return this.#waitingForReply.head!.value.typeMapping ?? {};
   }
 
-  private _initiateResp3Decoder() {
+  #initiateResp3Decoder() {
     return new Decoder({
-      onReply: reply => this._onReply(reply),
-      onErrorReply: err => this._onErrorReply(err),
+      onReply: reply => this.#onReply(reply),
+      onErrorReply: err => this.#onErrorReply(err),
       onPush: push => {
-        if (!this._onPush(push)) {
+        if (!this.#onPush(push)) {
 
         }
       },
-      getTypeMapping: () => this._getTypeMapping()
+      getTypeMapping: () => this.#getTypeMapping()
     });
   }
 
-  private _initiateResp2Decoder() {
+  #initiateResp2Decoder() {
     return new Decoder({
       onReply: reply => {
-        if (this._pubSub.isActive && Array.isArray(reply)) {
-          if (this._onPush(reply)) return;
+        if (this.#pubSub.isActive && Array.isArray(reply)) {
+          if (this.#onPush(reply)) return;
 
           if (PONG.equals(reply[0] as Buffer)) {
-            const { resolve, typeMapping } = this._waitingForReply.shift()!,
+            const { resolve, typeMapping } = this.#waitingForReply.shift()!,
               buffer = ((reply[1] as Buffer).length === 0 ? reply[0] : reply[1]) as Buffer;
             resolve(typeMapping?.[RESP_TYPES.SIMPLE_STRING] === Buffer ? buffer : buffer.toString());
             return;
           }
         }
 
-        this._onReply(reply);
+        this.#onReply(reply);
       },
-      onErrorReply: err => this._onErrorReply(err),
+      onErrorReply: err => this.#onErrorReply(err),
       // PUSH type does not exist in RESP2
       // PubSub is handled in onReply  
       // @ts-expect-error
       onPush: undefined,
       getTypeMapping: () => {
         // PubSub push is an Array in RESP2
-        return this._pubSub.isActive ?
+        return this.#pubSub.isActive ?
           RESP2_PUSH_TYPE_MAPPING :
-          this._getTypeMapping();
+          this.#getTypeMapping();
       }
     });
   }
@@ -180,7 +180,7 @@ export default class RedisCommandsQueue {
     options?: CommandOptions,
     resolveOnWrite?: boolean
   ): Promise<T> {
-    if (this._maxLength && this._toWrite.length + this._waitingForReply.length >= this._maxLength) {
+    if (this.#maxLength && this.#toWrite.length + this.#waitingForReply.length >= this.#maxLength) {
       return Promise.reject(new Error('The queue is full'));
     } else if (options?.abortSignal?.aborted) {
       return Promise.reject(new AbortError());
@@ -204,14 +204,14 @@ export default class RedisCommandsQueue {
         value.abort = {
           signal,
           listener: () => {
-            this._toWrite.remove(node);
+            this.#toWrite.remove(node);
             value.reject(new AbortError());
           }
         };
         signal.addEventListener('abort', value.abort.listener, { once: true });
       }
 
-      node = this._toWrite.add(value, options?.asap);
+      node = this.#toWrite.add(value, options?.asap);
     });
   }
 
@@ -221,8 +221,8 @@ export default class RedisCommandsQueue {
     listener: PubSubListener<T>,
     returnBuffers?: T
   ) {
-    return this._addPubSubCommand(
-      this._pubSub.subscribe(type, channels, listener, returnBuffers)
+    return this.#addPubSubCommand(
+      this.#pubSub.subscribe(type, channels, listener, returnBuffers)
     );
   }
 
@@ -232,17 +232,17 @@ export default class RedisCommandsQueue {
     listener?: PubSubListener<T>,
     returnBuffers?: T
   ) {
-    return this._addPubSubCommand(
-      this._pubSub.unsubscribe(type, channels, listener, returnBuffers)
+    return this.#addPubSubCommand(
+      this.#pubSub.unsubscribe(type, channels, listener, returnBuffers)
     );
   }
 
   resubscribe(): Promise<any> | undefined {
-    const commands = this._pubSub.resubscribe();
+    const commands = this.#pubSub.resubscribe();
     if (!commands.length) return;
 
     return Promise.all(
-      commands.map(command => this._addPubSubCommand(command, true))
+      commands.map(command => this.#addPubSubCommand(command, true))
     );
   }
 
@@ -251,26 +251,26 @@ export default class RedisCommandsQueue {
     channel: string,
     listeners: ChannelListeners
   ) {
-    return this._addPubSubCommand(
-      this._pubSub.extendChannelListeners(type, channel, listeners)
+    return this.#addPubSubCommand(
+      this.#pubSub.extendChannelListeners(type, channel, listeners)
     );
   }
 
   extendPubSubListeners(type: PubSubType, listeners: PubSubTypeListeners) {
-    return this._addPubSubCommand(
-      this._pubSub.extendTypeListeners(type, listeners)
+    return this.#addPubSubCommand(
+      this.#pubSub.extendTypeListeners(type, listeners)
     );
   }
 
   getPubSubListeners(type: PubSubType) {
-    return this._pubSub.getTypeListeners(type);
+    return this.#pubSub.getTypeListeners(type);
   }
 
-  private _addPubSubCommand(command: PubSubCommand, asap = false) {
+  #addPubSubCommand(command: PubSubCommand, asap = false) {
     if (command === undefined) return;
 
     return new Promise<void>((resolve, reject) => {
-      this._toWrite.add({
+      this.#toWrite.add({
         args: command.args,
         chainId: undefined,
         abort: undefined,
@@ -290,23 +290,23 @@ export default class RedisCommandsQueue {
   }
 
   isWaitingToWrite() {
-    return this._toWrite.length > 0;
+    return this.#toWrite.length > 0;
   }
 
   *commandsToWrite() {
-    let toSend = this._toWrite.shift();
+    let toSend = this.#toWrite.shift();
     while (toSend) {
       let encoded: CommandArguments;
       try {
         encoded = encodeCommand(toSend.args);
       } catch (err) {
         toSend.reject(err);
-        toSend = this._toWrite.shift();
+        toSend = this.#toWrite.shift();
         continue;
       }
 
       if (toSend.abort) {
-        RedisCommandsQueue._removeAbortListener(toSend);
+        RedisCommandsQueue.#removeAbortListener(toSend);
         toSend.abort = undefined;
       }
 
@@ -316,68 +316,68 @@ export default class RedisCommandsQueue {
         // TODO reuse `toSend` or create new object? 
         (toSend as any).args = undefined;
 
-        this._chainInExecution = toSend.chainId;
+        this.#chainInExecution = toSend.chainId;
         toSend.chainId = undefined;
 
-        this._waitingForReply.push(toSend);
+        this.#waitingForReply.push(toSend);
       }
 
       yield encoded;
-      toSend = this._toWrite.shift();
+      toSend = this.#toWrite.shift();
     }
   }
 
-  private _flushWaitingForReply(err: Error): void {
-    for (const node of this._waitingForReply) {
+  #flushWaitingForReply(err: Error): void {
+    for (const node of this.#waitingForReply) {
       node.reject(err);
     }
-    this._waitingForReply.reset();
+    this.#waitingForReply.reset();
   }
 
-  private static _removeAbortListener(command: CommandToWrite) {
+  static #removeAbortListener(command: CommandToWrite) {
     command.abort!.signal.removeEventListener('abort', command.abort!.listener);
   }
 
-  private static _flushToWrite(toBeSent: CommandToWrite, err: Error) {
+  static #flushToWrite(toBeSent: CommandToWrite, err: Error) {
     if (toBeSent.abort) {
-      RedisCommandsQueue._removeAbortListener(toBeSent);
+      RedisCommandsQueue.#removeAbortListener(toBeSent);
     }
 
     toBeSent.reject(err);
   }
 
   flushWaitingForReply(err: Error): void {
     this.decoder.reset();
-    this._pubSub.reset();
+    this.#pubSub.reset();
 
-    this._flushWaitingForReply(err);
+    this.#flushWaitingForReply(err);
 
-    if (!this._chainInExecution) return;
+    if (!this.#chainInExecution) return;
 
-    while (this._toWrite.head?.value.chainId === this._chainInExecution) {
-      RedisCommandsQueue._flushToWrite(
-        this._toWrite.shift()!,
+    while (this.#toWrite.head?.value.chainId === this.#chainInExecution) {
+      RedisCommandsQueue.#flushToWrite(
+        this.#toWrite.shift()!,
         err
       );
     }
 
-    this._chainInExecution = undefined;
+    this.#chainInExecution = undefined;
   }
 
   flushAll(err: Error): void {
     this.decoder.reset();
-    this._pubSub.reset();
-    this._flushWaitingForReply(err);
-    for (const node of this._toWrite) {
-      RedisCommandsQueue._flushToWrite(node, err);
+    this.#pubSub.reset();
+    this.#flushWaitingForReply(err);
+    for (const node of this.#toWrite) {
+      RedisCommandsQueue.#flushToWrite(node, err);
     }
-    this._toWrite.reset();
+    this.#toWrite.reset();
   }
 
   isEmpty() {
     return (
-      this._toWrite.length === 0 &&
-      this._waitingForReply.length === 0
+      this.#toWrite.length === 0 &&
+      this.#waitingForReply.length === 0
     );
   }
 }