Function ordered

packages/sql/src/SqlResolver.ts:196–256

(
  tag: T,
  options:
    | {
      readonly Request: Schema.Schema<I, II, RI>
      readonly Result: Schema.Schema<A, IA>
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<_>, E>
      readonly withContext?: false
    }
    | {
      readonly Request: Schema.Schema<I, II, RI>
      readonly Result: Schema.Schema<A, IA, RA>
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<_>, E, R>
      readonly withContext: true
    }
)

 * @category resolvers
 */
export const ordered = <T extends string, I, II, RI, A, IA, _, E, RA = never, R = never>(
  tag: T,
  options:
    | {
      readonly Request: Schema.Schema<I, II, RI>
      readonly Result: Schema.Schema<A, IA>
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<_>, E>
      readonly withContext?: false
    }
    | {
      readonly Request: Schema.Schema<I, II, RI>
      readonly Result: Schema.Schema<A, IA, RA>
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<_>, E, R>
      readonly withContext: true
    }
): Effect.Effect<
  SqlResolver<T, I, A, E | ResultLengthMismatch, RI>,
  never,
  RA | R
> => {
  const decodeResults = Schema.decodeUnknown(Schema.Array(options.Result))
  const resolver = RequestResolver.makeBatched(
    (requests: NonEmptyArray<SqlRequest<T, A, E | ResultLengthMismatch>>) => {
      const [inputs, spanLinks] = partitionRequests(requests)
      return options.execute(inputs as any).pipe(
        Effect.filterOrFail(
          (results) => results.length === inputs.length,
          ({ length }) =>
            new ResultLengthMismatch({
              expected: inputs.length,
              actual: length
            })
        ),
        Effect.flatMap(decodeResults),
        Effect.flatMap(
          Effect.forEach((result, i) => Request.succeed(requests[i], result), {
            discard: true
          })
        ),
        Effect.catchAllCause((cause) =>
          Effect.forEach(
            requests,
            (request) => Request.failCause(request, cause),
            { discard: true }
          )
        ),
        Effect.withSpan(`sql.Resolver.batch ${tag}`, {
          kind: "client",
          links: spanLinks,
          attributes: { "request.count": inputs.length },
          captureStackTrace: false
        })
      ) as Effect.Effect<void>
    }