Function make

packages/sql/src/SqlResolver.ts:119–180

(context: Context.Context<R> | undefined)

  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))
      },
      cacheInvalidate(input: I) {
        return Effect.withFiberRuntime<void>((fiber) => {
          const cache = fiber.getFiberRef(FiberRef.currentRequestCache)
          return cache.invalidate(makeRequest(tag, input, null as any, null as any))
        })
      },