Function fromClient

repos/effect/packages/sql/pglite/src/PgliteClient.ts:182–270

(
  options:
    & PgliteClientConfig.Base
    & {
      readonly liveClient: PGliteInterface
    }
)

 * @since 4.0.0
 */
export const fromClient = (
  options:
    & PgliteClientConfig.Base
    & {
      readonly liveClient: PGliteInterface
    }
): Effect.Effect<PgliteClient, SqlError, Scope.Scope | Reactivity.Reactivity> =>
  Effect.gen(function*() {
    const pglite = options.liveClient
    const compiler = makeCompiler(options.transformQueryNames, options.transformJson)
    const transformRows = options.transformResultNames
      ? Statement.defaultTransforms(options.transformResultNames, options.transformJson).array
      : undefined

    const spanAttributes: Array<[string, unknown]> = [
      ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
      [ATTR_DB_SYSTEM_NAME, "postgresql"]
    ]

    const connection = new PgliteConnection(pglite)
    const semaphore = Semaphore.makeUnsafe(1)
    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
      const fiber = Fiber.getCurrent()!
      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
      return Effect.as(
        Effect.tap(
          restore(semaphore.take(1)),
          () => Scope.addFinalizer(scope, semaphore.release(1))
        ),
        connection
      )
    })

    const config = options as PgliteClientConfig
    const client = yield* Client.make({
      acquirer,
      compiler,
      transactionAcquirer,
      spanAttributes,
      transformRows
    })

    return Object.assign(
      client,
      {
        [TypeId]: TypeId as TypeId,
        config,
        pglite,
        json: (_: unknown) => Statement.fragment([PgJson(_)]),
        listen: (channel: string) =>
          Stream.callback<string, SqlError>((queue) =>
            Effect.acquireRelease(
              Effect.tryPromise({
                try: () =>
                  pglite.listen(channel, (payload) => {
                    Queue.offerUnsafe(queue, payload)
                  }),