Function makeClient

packages/sql-pg/src/PgClient.ts:106–393

(
  pool: Pg.Pool,
  config: PgClientConfig,
  options: ClientOptions
)

}

const makeClient = (
  pool: Pg.Pool,
  config: PgClientConfig,
  options: ClientOptions
): Effect.Effect<PgClient, SqlError, Scope.Scope | Reactivity.Reactivity> =>
  Effect.gen(function*() {
    const compiler = makeCompiler(
      options.transformQueryNames,
      options.transformJson
    )
    const transformRows = options.transformResultNames ?
      Statement.defaultTransforms(
        options.transformResultNames,
        options.transformJson
      ).array :
      undefined

    class ConnectionImpl implements Connection {
      readonly pg: Pg.PoolClient | undefined
      constructor(pg?: Pg.PoolClient) {
        this.pg = pg
      }

      private runWithClient<A>(f: (client: Pg.PoolClient, resume: (_: Effect.Effect<A, SqlError>) => void) => void) {
        if (this.pg !== undefined) {
          return Effect.async<A, SqlError>((resume) => {
            f(this.pg!, resume)
            return makeCancel(pool, this.pg!)
          })
        }
        return Effect.async<A, SqlError>((resume) => {
          let done = false
          let cancel: Effect.Effect<void> | undefined = undefined
          let client: Pg.PoolClient | undefined = undefined
          function onError(cause: Error) {
            cleanup(cause)
            resume(Effect.fail(new SqlError({ cause, message: "Connection error" })))
          }
          function cleanup(cause?: Error) {
            if (!done) client?.release(cause)
            done = true
            client?.off("error", onError)
          }
          pool.connect((cause, client_) => {
            if (cause) {
              return resume(Effect.fail(new SqlError({ cause, message: "Failed to acquire connection" })))
            } else if (!client_) {
              return resume(
                Effect.fail(
                  new SqlError({ message: "Failed to acquire connection", cause: new Error("No client returned") })
                )
              )
            } else if (done) {
              client_.release()
              return
            }
            client = client_
            client.once("error", onError)