Method _executeMulti

packages/client/lib/client/index.ts:1565–1632

* @internal

(
    commands: Array<RedisMultiQueuedCommand>,
    selectedDB?: number
  )

   * @internal
   */
  async _executeMulti(
    commands: Array<RedisMultiQueuedCommand>,
    selectedDB?: number
  ) {
    const dirtyWatch = this._self.#dirtyWatch;
    this._self.#dirtyWatch = undefined;
    const watchEpoch = this._self.#watchEpoch;
    this._self.#watchEpoch = undefined;

    if (!this._self.#socket.isOpen) {
      throw new ClientClosedError();
    }

    if (dirtyWatch) {
      throw new WatchError(dirtyWatch);
    }

    if (watchEpoch && watchEpoch !== this._self.socketEpoch) {
      throw new WatchError('Client reconnected after WATCH');
    }

    const batchSize = commands.length;

    return trace(CHANNELS.TRACE_BATCH,
      async () => {
        const typeMapping = this._commandOptions?.typeMapping;
        const chainId = Symbol('MULTI Chain');
        const promises: Array<Promise<unknown>> = [
          this._self.#queue.addCommand(['MULTI'], { chainId }),
        ];

        for (const { args } of commands) {
          promises.push(
            this._self.#queue.addCommand(args, {
              chainId,
              typeMapping
            })
          );
        }

        promises.push(
          this._self.#queue.addCommand(['EXEC'], { chainId })
        );

        this._self.#scheduleWrite();

        const results = await Promise.all(promises),
          execResult = results[results.length - 1];

        if (execResult === null) {
          throw new WatchError();
        }

        if (selectedDB !== undefined) {
          this._self.#selectedDB = selectedDB;
        }

        return execResult as Array<unknown>;