Method execute

packages/client/lib/client/pool.ts:446–488

(fn: PoolTask<M, F, S, RESP, TYPE_MAPPING, T>)

  }

  execute<T>(fn: PoolTask<M, F, S, RESP, TYPE_MAPPING, T>) {
    return new Promise<Awaited<T>>((resolve, reject) => {
      if (this._self.#isClosing || !this._self.#isOpen) {
        return reject(new ClientClosedError());
      }

      const waitStartTimestamp = performance.now();
      const client = this._self.#idleClients.shift(),
        { tail } = this._self.#tasksQueue;
      if (!client) {
        let timeout;
        if (this._self.#options.acquireTimeout > 0) {
          timeout = setTimeout(
            () => {
              this._self.#tasksQueue.remove(task, tail);
              reject(new TimeoutError('Timeout waiting for a client')); // TODO: message
            },
            this._self.#options.acquireTimeout
          );
        }

        const task = this._self.#tasksQueue.push({
          timeout,
          // @ts-expect-error -- resolve generic variance
          resolve,
          reject,
          fn,
          waitStartTimestamp,
        });

        if (this.totalClients < this._self.#options.maximum) {
          this._self.#create();
        }

        return;
      }

      const node = this._self.#clientsInUse.push(client);
      publish(CHANNELS.POOL_CONNECTION_WAIT, () => ({ clientId: client._clientId, waitStartTimestamp }));
      // @ts-expect-error -- resolve generic variance
      this._self.#executeTask(node, resolve, reject, fn);
    });
  }

  #executeTask(
    node: DoublyLinkedNode<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>,