Function findById

packages/sql/src/SqlResolver.ts:345–416

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

 * @category resolvers
 */
export const findById = <T extends string, I, II, RI, A, IA, Row, E, RA = never, R = never>(
  tag: T,
  options:
    | {
      readonly Id: Schema.Schema<I, II, RI>
      readonly Result: Schema.Schema<A, IA>
      readonly ResultId: (result: Types.NoInfer<A>, row: Types.NoInfer<Row>) => I
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<Row>, E>
      readonly withContext?: false
    }
    | {
      readonly Id: Schema.Schema<I, II, RI>
      readonly Result: Schema.Schema<A, IA, RA>
      readonly ResultId: (result: Types.NoInfer<A>, row: Types.NoInfer<Row>) => I
      readonly execute: (
        requests: Array<Types.NoInfer<II>>
      ) => Effect.Effect<ReadonlyArray<Row>, E, R>
      readonly withContext: true
    }
): Effect.Effect<SqlResolver<T, I, Option.Option<A>, E, RI>, never, RA | R> => {
  const decodeResults = Schema.decodeUnknown(Schema.Array(options.Result))
  const resolver = RequestResolver.makeBatched(
    (requests: NonEmptyArray<SqlRequest<T, Option.Option<A>, E>>) => {
      const [inputs, spanLinks, idMap] = partitionRequestsById<I, II>()(requests)
      return options.execute(inputs as any).pipe(
        Effect.bindTo("rawResults"),
        Effect.bind("results", ({ rawResults }) => decodeResults(rawResults)),
        Effect.flatMap(({ rawResults, results }) =>
          Effect.forEach(
            results,
            (result, i) => {
              const id = options.ResultId(result, rawResults[i])
              const request = MutableHashMap.get(idMap, id)
              if (request._tag === "None") {
                return Effect.void
              }
              MutableHashMap.remove(idMap, id)
              return Request.succeed(request.value, Option.some(result))
            },
            { discard: true }
          )
        ),
        Effect.tap((_) => {
          if (MutableHashMap.size(idMap) === 0) {
            return Effect.void
          }
          return Effect.forEach(
            idMap,
            ([, request]) => Request.succeed(request, Option.none()),
            { discard: true }
          )
        }),
        Effect.catchAllCause((cause) =>
          Effect.forEach(
            requests,
            (request) => Request.failCause(request, cause),