Function waitForBatch

packages/client/src/runtime/utils/waitForBatch.ts:17–75

(
  promises: T,
)

 * @returns
 */
export function waitForBatch<T extends PromiseLike<unknown>[]>(
  promises: T,
): Promise<{ [K in keyof T]: Awaited<T[K]> }> {
  if (promises.length === 0) {
    return Promise.resolve([] as { [K in keyof T]: Awaited<T[K]> })
  }
  return new Promise((resolve, reject) => {
    const successfulResults = new Array(promises.length) as { [K in keyof T]: Awaited<T[K]> }
    let bestError: unknown = null
    let done = false
    let settledPromisesCount = 0

    const settleOnePromise = () => {
      if (done) {
        return
      }
      settledPromisesCount++
      if (settledPromisesCount === promises.length) {
        done = true
        if (bestError) {
          reject(bestError)
        } else {
          resolve(successfulResults)
        }
      }
    }

    const immediatelyReject = (error: unknown) => {
      if (!done) {
        done = true
        reject(error)
      }
    }

    for (let i = 0; i < promises.length; i++) {
      promises[i].then(
        (result) => {
          successfulResults[i] = result
          settleOnePromise()
        },
        (error) => {
          if (!hasBatchIndex(error)) {
            immediatelyReject(error)
            return
          }

          if (error.batchRequestIdx === i) {
            immediatelyReject(error)
          } else {
            if (!bestError) {
              bestError = error
            }
            settleOnePromise()
          }
        },
      )
    }
  })