Function grouped

packages/sql/src/SqlResolver.ts:266–337

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

 * @category resolvers
 */
export const grouped = <T extends string, I, II, K, RI, A, IA, Row, E, RA = never, R = never>(
  tag: T,
  options:
    | {
      readonly Request: Schema.Schema<I, II, RI>
      readonly RequestGroupKey: (request: Types.NoInfer<I>) => K
      readonly Result: Schema.Schema<A, IA>
      readonly ResultGroupKey: (result: Types.NoInfer<A>, row: Types.NoInfer<Row>) => K
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<Row>, E>
      readonly withContext?: false
    }
    | {
      readonly Request: Schema.Schema<I, II, RI>
      readonly RequestGroupKey: (request: Types.NoInfer<I>) => K
      readonly Result: Schema.Schema<A, IA, RA>
      readonly ResultGroupKey: (result: Types.NoInfer<A>, row: Types.NoInfer<Row>) => K
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<Row>, E, R>
      readonly withContext: true
    }
): Effect.Effect<SqlResolver<T, I, Array<A>, E, RI>, never, RA | R> => {
  const decodeResults = Schema.decodeUnknown(Schema.Array(options.Result))
  const resolver = RequestResolver.makeBatched(
    (requests: NonEmptyArray<SqlRequest<T, Array<A>, E>>) => {
      const [inputs, spanLinks] = partitionRequests(requests)
      const resultMap = MutableHashMap.empty<K, Array<A>>()
      return options.execute(inputs as any).pipe(
        Effect.bindTo("rawResults"),
        Effect.bind("results", ({ rawResults }) => decodeResults(rawResults)),
        Effect.tap(({ rawResults, results }) => {
          for (let i = 0, len = results.length; i < len; i++) {
            const result = results[i]
            const key = options.ResultGroupKey(result, rawResults[i])
            const group = MutableHashMap.get(resultMap, key)
            if (group._tag === "None") {
              MutableHashMap.set(resultMap, key, [result])
            } else {
              group.value.push(result)
            }
          }

          return Effect.forEach(
            requests,
            (request) => {
              const key = options.RequestGroupKey(request.input as I)
              const result = MutableHashMap.get(resultMap, key)
              return Request.succeed(request, result._tag === "None" ? [] : result.value)
            },
            { discard: true }
          )
        }),
        Effect.catchAllCause((cause) =>
          Effect.forEach(
            requests,
            (request) => Request.failCause(request, cause),