refactor - remove proxy, use subclass

Author: nkaradzhov

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

@@ -1,4 +1,4 @@
-import { SinglyLinkedList, DoublyLinkedNode, DoublyLinkedList, makeEmptyAware } from './linked-list';
+import { SinglyLinkedList, DoublyLinkedNode, DoublyLinkedList, EmptyAwareSinglyLinkedList } from './linked-list';
 import encodeCommand from '../RESP/encoder';
 import { Decoder, PUSH_TYPE_MAPPING, RESP_TYPES } from '../RESP/decoder';
 import { TypeMapping, ReplyUnion, RespVersions, RedisArgument } from '../RESP/types';
@@ -55,7 +55,7 @@ export default class RedisCommandsQueue {
   readonly #respVersion;
   readonly #maxLength;
   readonly #toWrite = new DoublyLinkedList<CommandToWrite>();
-  readonly #waitingForReply: SinglyLinkedList<CommandWaitingForReply>;
+  readonly #waitingForReply: EmptyAwareSinglyLinkedList<CommandWaitingForReply>;
   readonly #onShardedChannelMoved;
   #chainInExecution: symbol | undefined;
   readonly decoder;
@@ -77,9 +77,8 @@ export default class RedisCommandsQueue {
     this.#maxLength = maxLength;
     this.#onShardedChannelMoved = onShardedChannelMoved;
     this.decoder = this.#initiateDecoder();
-    const [waitingForReply, emptyEmitter] = makeEmptyAware(new SinglyLinkedList<CommandWaitingForReply>())
-    this.#waitingForReply = waitingForReply;
-    emptyEmitter.on('empty', this.events.emit.bind(this.events, 'waitingForReplyEmpty'))
+    this.#waitingForReply = new EmptyAwareSinglyLinkedList<CommandWaitingForReply>()
+    this.#waitingForReply.events.on('empty', this.events.emit.bind(this.events, 'waitingForReplyEmpty'))
   }
 
   #onReply(reply: ReplyUnion) {

packages/client/lib/client/linked-list.ts

@@ -113,33 +113,6 @@ export class DoublyLinkedList<T> {
   }
 }
 
-// This function takes an object that has a `length` property
-// and returns both a proxy and an event emitter.
-// The proxy will act the same as the original object.
-// And the event emitter will emit an `empty` event whenever the `length` becomes zero.
-export const makeEmptyAware = <T extends { length: number }>(obj: T): [T, EventEmitter] => {
-  const eventEmitter = new EventEmitter();
-  const proxy = new Proxy(obj, {
-    get(target, prop, _receiver) {
-      const original = Reflect.get(target, prop, target);
-      if (typeof original === 'function') {
-        return function (...args: any[]) {
-          const oldLength = target.length;
-          const ret = original.apply(target, args);
-          const newLength = target.length;
-          if(oldLength !== newLength && newLength === 0) {
-            eventEmitter.emit('empty')
-          }
-          return ret
-        };
-      } else {
-        return original;
-      };
-    },
-  });
-  return [ proxy, eventEmitter ];
-}
-
 export interface SinglyLinkedNode<T> {
   value: T;
   next: SinglyLinkedNode<T> | undefined;
@@ -230,3 +203,26 @@ export class SinglyLinkedList<T> {
     }
   }
 }
+
+export class EmptyAwareSinglyLinkedList<T> extends SinglyLinkedList<T> {
+  readonly events = new EventEmitter();
+  reset() {
+    super.reset();
+    this.events.emit('empty');
+  }
+  shift(): T | undefined {
+    const old = this.length;
+    const ret = super.shift();
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+    return ret;
+  }
+  remove(node: SinglyLinkedNode<T>, parent: SinglyLinkedNode<T> | undefined): T | undefined {
+    const old = this.length;
+    super.remove(node, parent);
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+  }
+}