Method command

src/sdam/server.ts:282–384

(
    operation: AbstractOperation<TResult>,
    timeoutContext: TimeoutContext
  )

  }

  public async command<TResult>(
    operation: AbstractOperation<TResult>,
    timeoutContext: TimeoutContext
  ): Promise<InstanceType<typeof operation.SERVER_COMMAND_RESPONSE_TYPE>> {
    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
      throw new MongoServerClosedError();
    }
    const session = operation.session;

    let conn = session?.pinnedConnection;

    this.incrementOperationCount();
    if (conn == null) {
      try {
        conn = await this.pool.checkOut({ timeoutContext, signal: operation.options.signal });
      } catch (checkoutError) {
        this.decrementOperationCount();
        if (!(checkoutError instanceof PoolClearedError)) this.handleError(checkoutError);
        throw checkoutError;
      }
    }

    let reauthPromise: Promise<void> | null = null;
    const cleanup = () => {
      this.decrementOperationCount();
      if (session?.pinnedConnection !== conn) {
        if (reauthPromise != null) {
          // The reauth promise only exists if it hasn't thrown.
          const checkBackIn = () => {
            this.pool.checkIn(conn);
          };
          void reauthPromise.then(checkBackIn, checkBackIn);
        } else {
          this.pool.checkIn(conn);
        }
      }
    };

    let cmd;
    try {
      cmd = operation.buildCommand(conn, session);
    } catch (e) {
      cleanup();
      throw e;
    }

    const options = operation.buildOptions(timeoutContext);
    const ns = operation.ns;

    if (this.loadBalanced && isPinnableCommand(cmd, session) && !session?.pinnedConnection) {
      session?.pin(conn);
    }

    options.directConnection = this.topology.s.options.directConnection;

    const omitReadPreference =
      operation instanceof AggregateOperation &&
      operation.hasWriteStage &&