Class PostgresDriver

src/dialect/postgres/postgres-driver.ts:24–148

const PRIVATE_RELEASE_METHOD: unique symbol = Symbol()

export class PostgresDriver implements Driver {
  readonly #config: PostgresDialectConfig
  readonly #connections = new WeakMap<PostgresPoolClient, DatabaseConnection>()
  #pool?: PostgresPool

  constructor(config: PostgresDialectConfig) {
    this.#config = freeze({ ...config })
  }

  async init(options?: AbortableOperationOptions): Promise<void> {
    this.#pool = isFunction(this.#config.pool)
      ? await this.#config.pool(options)
      : this.#config.pool
  }

  async acquireConnection(
    options?: AbortableOperationOptions,
  ): Promise<DatabaseConnection> {
    const client = await this.#pool!.connect()

    let connection = this.#connections.get(client)

    if (!connection) {
      connection = new PostgresConnection(client, {
        controlClient: this.#config.controlClient || this.#pool!.Client,
        cursor: this.#config.cursor ?? null,
        poolOptions: this.#pool!.options,
      })
      this.#connections.set(client, connection)

      // The driver must take care of calling `onCreateConnection` when a new
      // connection is created. The `pg` module doesn't provide an async hook
      // for the connection creation. We need to call the method explicitly.
      if (this.#config.onCreateConnection) {
        await this.#config.onCreateConnection(connection, options)
      }
    }

    if (this.#config.onReserveConnection) {
      await this.#config.onReserveConnection(connection, options)
    }

    return connection
  }

  async beginTransaction(
    connection: DatabaseConnection,
    settings: TransactionSettings,
  ): Promise<void> {
    let sql = 'begin'

    if (settings.isolationLevel || settings.accessMode) {
      sql = 'start transaction'

      if (settings.isolationLevel) {
        sql += ` isolation level ${settings.isolationLevel}`
      }