Function makeResolver

packages/sql/src/SqlResolver.ts:113–183

(
  self: RequestResolver.RequestResolver<SqlRequest<T, A, E>>,
  tag: T,
  Request: Schema.Schema<I, II, RI>,
  withContext?: boolean
)

}

const makeResolver = <T extends string, A, E, I, II, RI, R>(
  self: RequestResolver.RequestResolver<SqlRequest<T, A, E>>,
  tag: T,
  Request: Schema.Schema<I, II, RI>,
  withContext?: boolean
): Effect.Effect<SqlResolver<T, I, A, E, RI>, never, R> => {
  function make(context: Context.Context<R> | undefined) {
    const encode = Schema.encode(Request)
    function makeExecute(self: RequestResolver.RequestResolver<SqlRequest<T, A, E>>) {
      return function(input: I) {
        return Effect.useSpan(
          `sql.Resolver.execute ${tag}`,
          { kind: "client", captureStackTrace: false },
          (span) =>
            Effect.withFiberRuntime<A, E | ParseError, RI>((fiber) => {
              span.attribute("request.input", input)
              const currentContext = fiber.currentContext
              const connection = currentContext.unsafeMap.get(
                internalClient.TransactionConnection.key
              )
              let toProvide: Context.Context<R> | undefined = context
              if (connection !== undefined) {
                if (toProvide === undefined) {
                  toProvide = Context.make(
                    internalClient.TransactionConnection,
                    connection
                  ) as Context.Context<R>
                } else {
                  toProvide = Context.add(
                    toProvide,
                    internalClient.TransactionConnection,
                    connection
                  )
                }
              }
              const resolver = toProvide === undefined
                ? self
                : RequestResolver.provideContext(self, toProvide)
              return Effect.flatMap(
                encode(input),
                (encoded) => Effect.request(makeRequest<T, I, II, A, E>(tag, input, encoded, span), resolver)
              )
            })
        )
      }
    }
    return Object.assign(self, {
      request(input: I) {
        return Effect.withFiberRuntime<SqlRequest<T, A, E>, ParseError, RI>(
          (fiber) => {
            const span = fiber.currentContext.unsafeMap.get(Tracer.ParentSpan.key)
            return Effect.map(encode(input), (encoded) => makeRequest(tag, input, encoded, span))
          }
        )
      },
      cachePopulate(input: I, value: A) {
        return Effect.cacheRequestResult(makeRequest(tag, input, null as any, null as any), Exit.succeed(value))
      },