Feature Request: Support for native Bun.sql adapter (PostgreSQL)

[codelonesomest]

Is your feature request related to a problem? Please describe.
With recent updates to the Bun runtime, they have introduced a native, high-performance SQL driver (Bun.sql) specifically for PostgreSQL. Currently, to use Orchid ORM with Bun, we still rely on third-party Node.js drivers like pg or postgres.js.

While these work well, they do not take full advantage of the Bun runtime's potential.

Describe the solution you'd like
I would love to see a native adapter added to Orchid ORM that utilizes Bun.sql.

Since Bun.sql is built-in to the runtime, this would offer two main benefits:

1. Performance: Bun claims their native implementation is significantly faster than existing Node.js drivers.
2. Zero Dependencies: It removes the need to install pg or postgres.js as dependencies in the project.

Proposed Usage
Ideally, it would look something like this in the configuration:

import { OrchidORM } from 'orchid-orm';
import { BunSqlAdapter } from 'orchid-orm/adapter-bun-sql'; // Proposed new adapter

export const db = new OrchidORM({
  adapter: new BunSqlAdapter({
    url: process.env.DATABASE_URL,
    // Bun specific options
    max: 20, 
    idleTimeout: 30,
  }),
});

Additional Context

• Bun SQL Documentation: https://bun.sh/docs/api/sql
• The API for Bun.sql is relatively simple and supports prepared statements, which should map well to Orchid's internal query building structure.

Describe alternatives you've considered
The current alternative is continuing to use postgres.js or node-postgres. While stable, this misses out on the optimization opportunities provided by the native Bun environment.

[romeerez]

I've seen that recent video from Anton Putra and it's crazy! spoiler link

I'd love to add the support for Bun, but I currently have other plans for Orchid ORM development. They're also optimizations-focused.

Maybe you're willing to contribute a support for Bun driver? There are 2 drivers and it just takes to copy the existing postgres-js code and replacing it with Bun.

current plans/goal

The milestone is to have a benchmark with lots of use-cases comparing with Prisma, Drizzle, others. And I hope it could be maintained by other interested people, to remain non-biased, and so I don't have to do the whole thing myself.

Because currently we have so many different ORMs, recently ZenStack announced they have a full Prisma replacement with more features and better performance, but how to know if that's true, how to know how much is missing? Drizzle has certain features that Orchid ORM doesn't have and vice-versa, but you'd have to do a deep long research to find out the differences.

So I hope to pitch up the idea of vendor-neutral repository, a website with ORMs comparisons. Benchmarks are crucial to gain people attention. At the same time it will make more visible what ORMs have what features, and what they're missing compared to the others.

With all my excitement for what Bun is doing and achieving, people are less interested. It's more important for the ORM to provide SQL-level optimizations in whatever runtime/driver you're executing, because node.js will remain #1 for many years to come.

Currently I'm focusing on minimizing queries amount so there are less round-trips. Realistically, in the best case scenario you'd have 3ms of latency between the app and the db. With that in mind, no matter how fast the driver is, if you can perform multiple changes via a single query it's going to be more efficient than having several queries and having to wrap it in a transaction (for atomicity). So I'm planning to ensure that Orchid ORM can do all the relation queries the Prisma can, but in a single round-trip each. And then Orchid ORM is going to crash the benchmarks (that's the plan).

[codelonesomest]

I'm currently working on creating a Bun.sql driver adapter for the Orchid ORM. Since I'm not highly experienced in this area, I'd value your expert feedback and review of the code.

import type {
  AdapterBase,
  AdapterConfigBase,
  ColumnSchemaConfig,
  DbOptions,
  DbResult,
  DefaultColumnTypes,
  DefaultSchemaConfig,
  MaybeArray,
  QueryArraysResult,
  QueryError,
  QueryResult,
  QueryResultRow
} from 'orchid-orm'
import { SQL } from 'bun'
import {
  createDbWithAdapter,
  emptyObject,
  setConnectRetryConfig,
  wrapAdapterFnWithConnectRetry
} from 'orchid-orm'

// SQL specific options interface
export interface BunSqlAdapterOptions extends Omit<AdapterConfigBase, 'databaseURL'> {
  /** Explicit SQL configuration object */
  config?: SQL.PostgresOrMySQLOptions
  /** Database schema (search_path) */
  schema?: string
  /** Option to pass an existing Bun SQL instance */
  sql?: SQL
}

export interface CreateBunSqlDbOptions<
  SchemaConfig extends ColumnSchemaConfig,
  ColumnTypes
> extends BunSqlAdapterOptions,
  DbOptions<SchemaConfig, ColumnTypes> {}

export const createDb = <
  SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig,
  ColumnTypes = DefaultColumnTypes<SchemaConfig>
>(
  options: CreateBunSqlDbOptions<SchemaConfig, ColumnTypes>
): DbResult<ColumnTypes> => {
  return createDbWithAdapter({
    ...options,
    adapter: new BunSqlAdapter(options)
  })
}

/**
 * Wraps SQL result into QueryResult format expected by Orchid ORM
 */
class BunSqlResult<T extends QueryResultRow> implements QueryResult<T> {
  fields: QueryResult<T>['fields'] = []
  rowCount: number
  rows: T[]

  constructor(result: unknown[]) {
    this.rows = result as T[]
    this.rowCount = result.length
  }
}

const wrapResult = <T extends QueryResultRow>(result: MaybeArray<unknown[]>): QueryResult<T> => {
  if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0])) {
    return (result as unknown[][]).map(
      (res) => new BunSqlResult(res)
    ) as never
  }
  return new BunSqlResult(result as unknown[]) as never
}

export class BunSqlAdapter implements AdapterBase {
  config: BunSqlAdapterOptions
  // Use Bun's PostgresError for proper error type checking
  errorClass = SQL.PostgresError
  schema?: string

  sql: SQL

  /**
   * Set search_path if schema is configured and not 'public'
   */
  private searchPathSet = false

  constructor(config: BunSqlAdapterOptions) {
    this.config = config
    this.schema = config.schema

    // Use provided SQL instance or create a new one
    if (config.sql) {
      this.sql = config.sql
    } else {
      const bunOptions: SQL.PostgresOrMySQLOptions = {
        ...(config.config || {}),
        adapter: 'postgres'
      }
      this.sql = new SQL(bunOptions)
    }

    // Handle connect retry configuration
    if (config.connectRetry) {
      setConnectRetryConfig(
        this,
        config.connectRetry === true ? emptyObject : config.connectRetry
      )
      this.query = wrapAdapterFnWithConnectRetry(this, this.query)
      this.arrays = wrapAdapterFnWithConnectRetry(this, this.arrays)
    }
  }

  /**
   * Execute query and return rows as arrays of arrays
   */
  async arrays<R extends any[] = any[]>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryArraysResult<R>> {
    await this.ensureSearchPath()
    const result = await executeQuery(this.sql, text, values, 'array', catchingSavepoint)
    return wrapResult(result) as QueryArraysResult<R>
  }

  /**
   * Map database error properties to Orchid's QueryError format
   */
  assignError(to: QueryError, dbError: Error): void {
    const from = dbError as any
    to.message = from.message
    to.severity = from.severity
    to.code = from.code
    to.detail = from.detail
    to.hint = from.hint
    to.position = from.position
    to.internalPosition = from.internalPosition
    to.internalQuery = from.internalQuery
    to.where = from.where
    to.schema = from.schema_name ?? from.schema
    to.table = from.table_name ?? from.table
    to.column = from.column_name ?? from.column
    to.dataType = from.data_type_name ?? from.dataType
    to.constraint = from.constraint_name ?? from.constraint
    to.file = from.file
    to.line = from.line
    to.routine = from.routine
  }

  async close(): Promise<void> {
    await this.sql.close({ timeout: 0 })
  }

  getDatabase(): string {
    const url = this.getURL()
    return url
      ? url.pathname.slice(1)
      : (this.config.config?.database || this.config.config?.db || '')
  }

  getHost(): string {
    const url = this.getURL()
    return url
      ? url.hostname
      : (this.config.config?.hostname || this.config.config?.host || '')
  }

  getSchema(): string | undefined {
    return this.schema
  }

  getUser(): string {
    const url = this.getURL()
    return url
      ? url.username
      : (this.config.config?.username || this.config.config?.user || '')
  }

  /**
   * Execute query and return rows as objects
   */
  async query<T extends QueryResultRow = QueryResultRow>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryResult<T>> {
    await this.ensureSearchPath()
    const result = await executeQuery(this.sql, text, values, undefined, catchingSavepoint)
    return wrapResult(result) as QueryResult<T>
  }

  reconfigure(params: {
    database?: string
    password?: string
    schema?: string
    user?: string
  }): AdapterBase {
    const newConfig: BunSqlAdapterOptions = {
      ...this.config,
      config: { ...this.config.config }
    }

    if (!newConfig.config) {
      newConfig.config = {}
    }

    // Update URL if exists
    if (newConfig.config.url) {
      const urlString = newConfig.config.url instanceof URL
        ? newConfig.config.url.toString()
        : newConfig.config.url

      const url = new URL(urlString)

      if (params.database) url.pathname = `/${params.database}`
      if (params.user) url.username = params.user
      if (params.password) url.password = params.password
      if (params.schema) url.searchParams.set('schema', params.schema)
      newConfig.config.url = url.toString()
    }

    // Map Orchid params to Bun options
    if (params.database) newConfig.config.database = params.database
    if (params.user) newConfig.config.username = params.user
    if (params.password) newConfig.config.password = params.password
    if (params.schema) newConfig.schema = params.schema

    // Invalidate existing SQL instance if connection details changed
    if ((params.user || params.password || params.database) && newConfig.sql) {
      delete newConfig.sql
    }

    return new BunSqlAdapter(newConfig)
  }

  /**
   * Run queries within a transaction
   */
  async transaction<Result>(
    options: string | undefined,
    cb: (adapter: AdapterBase) => Promise<Result>
  ): Promise<Result> {
    return this.sql.begin(async (tx) => {
      const txAdapter = new BunSqlTransactionAdapter(this, tx, this.schema)

      // Set transaction options (e.g., isolation level)
      if (options) {
        await tx.unsafe(`SET TRANSACTION ${options}`)
      }

      // Set schema search_path within transaction
      await txAdapter.ensureSearchPath()

      return cb(txAdapter)
    }) as Promise<Result>
  }

  private async ensureSearchPath(): Promise<void> {
    if (this.searchPathSet || !this.schema || this.schema === 'public') return
    await this.sql.unsafe(`SET search_path = ${this.schema}`)
    this.searchPathSet = true
  }

  private getURL(): undefined | URL {
    if (!this.config.config?.url) return undefined
    return this.config.config.url instanceof URL
      ? this.config.config.url
      : new URL(this.config.config.url)
  }
}

/**
 * Transaction-scoped adapter that uses the transaction connection
 */
export class BunSqlTransactionAdapter implements AdapterBase {
  errorClass = SQL.PostgresError
  schema?: string

  /**
   * Set search_path within the transaction context
   */
  private searchPathSet = false

  constructor(
    public mainAdapter: BunSqlAdapter,
    public sql: SQL,
    schema?: string
  ) {
    this.schema = schema
  }

  async arrays<R extends any[] = any[]>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryArraysResult<R>> {
    const result = await executeQuery(this.sql, text, values, 'array', catchingSavepoint)
    return wrapResult(result) as QueryArraysResult<R>
  }

  assignError(to: QueryError, from: Error): void {
    this.mainAdapter.assignError(to, from)
  }

  async close(): Promise<void> {
    // Transaction connections are managed by the parent .begin() scope
  }

  async ensureSearchPath(): Promise<void> {
    if (this.searchPathSet || !this.schema || this.schema === 'public') return
    await this.sql.unsafe(`SET search_path = ${this.schema}`)
    this.searchPathSet = true
  }

  getDatabase = (): string => this.mainAdapter.getDatabase()
  getHost = (): string => this.mainAdapter.getHost()

  getSchema = (): string | undefined => this.schema

  getUser = (): string => this.mainAdapter.getUser()

  async query<T extends QueryResultRow = QueryResultRow>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryResult<T>> {
    const result = await executeQuery(this.sql, text, values, undefined, catchingSavepoint)
    return wrapResult(result) as QueryResult<T>
  }

  reconfigure(params: {
    database?: string
    password?: string
    schema?: string
    user?: string
  }): AdapterBase {
    return this.mainAdapter.reconfigure(params)
  }

  /**
   * Nested transactions use savepoints via Bun's tx.savepoint() API
   */
  async transaction<Result>(
    _options: string | undefined,
    cb: (adapter: AdapterBase) => Promise<Result>
  ): Promise<Result> {
    // For nested transactions, we're already in a transaction context
    // Just pass through - the outer transaction handles commit/rollback
    // Options are ignored for nested transactions as per PostgreSQL behavior
    return cb(this)
  }
}

/**
 * Execute a query with optional savepoint wrapping for error recovery.
 * When catchingSavepoint is provided, the query is wrapped in a savepoint
 * so that on error we can rollback just that statement without aborting the transaction.
 */
async function executeQuery(
  sql: SQL,
  text: string,
  values: undefined | unknown[],
  rowMode: 'array' | undefined,
  catchingSavepoint: string | undefined
): Promise<unknown[]> {
  const runQuery = async (): Promise<unknown[]> => {
    const query = values && values.length > 0
      ? sql.unsafe(text, values as any[])
      : sql.unsafe(text)

    return rowMode === 'array'
      ? await query.values()
      : await query
  }

  if (catchingSavepoint) {
    // Wrap query in savepoint for error recovery
    await sql.unsafe(`SAVEPOINT "${catchingSavepoint}"`)
    try {
      const result = await runQuery()
      await sql.unsafe(`RELEASE SAVEPOINT "${catchingSavepoint}"`)
      return result
    } catch (err) {
      await sql.unsafe(`ROLLBACK TO SAVEPOINT "${catchingSavepoint}"`)
      throw err
    }
  }

  return runQuery()
}

[codelonesomest]

V2:

orchidORMWithAdapter({
    adapter: new BunSqlAdapter({
      connectRetry: true,
      onQuery: (event) => {
        console.log(event.command, event.duration, event.error, event.params, event.rowCount, event.sql)
      },
      sql: new SQL({ adapter: 'postgres', ... })
    }),
    autoPreparedStatements: true
  }, {...tables})

import type {
  AdapterBase,
  AdapterConfigBase,
  ColumnSchemaConfig,
  DbOptions,
  DbResult,
  DefaultColumnTypes,
  DefaultSchemaConfig,
  MaybeArray,
  QueryArraysResult,
  QueryError,
  QueryResult,
  QueryResultRow
} from 'orchid-orm'
import { SQL } from 'bun'
import {
  createDbWithAdapter,
  emptyObject,
  setConnectRetryConfig,
  wrapAdapterFnWithConnectRetry
} from 'orchid-orm'

// SQL specific options interface
export interface BunSqlAdapterOptions extends Omit<AdapterConfigBase, 'databaseURL'> {
  /** Explicit SQL configuration object */
  config?: SQL.PostgresOrMySQLOptions
  /** Custom query event handler for logging/monitoring */
  onQuery?: (event: LogEvent) => void
  /** Database schema (search_path) */
  schema?: string
  /** Option to pass an existing Bun SQL instance */
  sql?: SQL
}

export interface CreateBunSqlDbOptions<
  SchemaConfig extends ColumnSchemaConfig,
  ColumnTypes
> extends BunSqlAdapterOptions,
  DbOptions<SchemaConfig, ColumnTypes> {}

/**
 * Query execution event for logging and monitoring.
 * Emitted after each query execution when `onQuery` handler is configured.
 */
export interface LogEvent {
  /** SQL command type (e.g., 'SELECT', 'INSERT') - may be undefined for some queries */
  command?: string
  /** Query execution duration in milliseconds */
  duration: number
  /** Error if query failed */
  error?: Error
  /** Query parameters */
  params?: unknown[]
  /** Number of rows affected or returned */
  rowCount?: number
  /** The SQL query text */
  sql: string
}

export const createDb = <
  SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig,
  ColumnTypes = DefaultColumnTypes<SchemaConfig>
>(
  options: CreateBunSqlDbOptions<SchemaConfig, ColumnTypes>
): DbResult<ColumnTypes> => {
  return createDbWithAdapter({
    ...options,
    adapter: new BunSqlAdapter(options)
  })
}

/**
 * Wraps SQL result into QueryResult format expected by Orchid ORM
 */
class BunSqlResult<T extends QueryResultRow> implements QueryResult<T> {
  fields: QueryResult<T>['fields'] = []
  rowCount: number
  rows: T[]

  constructor(result: unknown[]) {
    this.rows = result as T[]
    this.rowCount = result.length
  }
}

const wrapResult = <T extends QueryResultRow>(result: MaybeArray<unknown[]>): QueryResult<T> => {
  return new BunSqlResult(result as unknown[]) as never
}

export class BunSqlAdapter implements AdapterBase {
  config: BunSqlAdapterOptions
  // Use Bun's PostgresError for proper error type checking
  errorClass = SQL.PostgresError
  schema?: string

  sql: SQL

  /**
   * Set search_path if schema is configured and not 'public'
   */
  private searchPathSet = false

  constructor(config: BunSqlAdapterOptions) {
    this.config = config
    this.schema = config.schema

    // Use provided SQL instance or create a new one
    if (config.sql) {
      this.sql = config.sql
    } else {
      const bunOptions: SQL.PostgresOrMySQLOptions = {
        ...(config.config || {}),
        adapter: 'postgres'
      }
      this.sql = new SQL(bunOptions)
    }

    // Handle connect retry configuration
    if (config.connectRetry) {
      setConnectRetryConfig(
        this,
        config.connectRetry === true ? emptyObject : config.connectRetry
      )
      this.query = wrapAdapterFnWithConnectRetry(this, this.query)
      this.arrays = wrapAdapterFnWithConnectRetry(this, this.arrays)
    }
  }

  /**
   * Execute query and return rows as arrays of arrays
   */
  async arrays<R extends any[] = any[]>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryArraysResult<R>> {
    await this.ensureSearchPath()
    const result = await executeQuery(
      this.sql,
      text,
      values,
      'array',
      catchingSavepoint,
      this.config.onQuery
    )
    return wrapResult(result) as QueryArraysResult<R>
  }

  /**
   * Map database error properties to Orchid's QueryError format
   */
  assignError(to: QueryError, dbError: Error): void {
    const from = dbError as any
    to.message = from.message
    to.severity = from.severity
    to.code = from.code
    to.detail = from.detail
    to.hint = from.hint
    to.position = from.position
    to.internalPosition = from.internalPosition
    to.internalQuery = from.internalQuery
    to.where = from.where
    to.schema = from.schema_name ?? from.schema
    to.table = from.table_name ?? from.table
    to.column = from.column_name ?? from.column
    to.dataType = from.data_type_name ?? from.dataType
    to.constraint = from.constraint_name ?? from.constraint
    to.file = from.file
    to.line = from.line
    to.routine = from.routine
  }

  async close(): Promise<void> {
    await this.sql.close({ timeout: 0 })
  }

  getDatabase(): string {
    const url = this.getURL()
    return url
      ? url.pathname.slice(1)
      : (this.config.config?.database || this.config.config?.db || '')
  }

  getHost(): string {
    const url = this.getURL()
    return url
      ? url.hostname
      : (this.config.config?.hostname || this.config.config?.host || '')
  }

  getSchema(): string | undefined {
    return this.schema
  }

  getUser(): string {
    const url = this.getURL()
    return url
      ? url.username
      : (this.config.config?.username || this.config.config?.user || '')
  }

  /**
   * Execute query and return rows as objects
   */
  async query<T extends QueryResultRow = QueryResultRow>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryResult<T>> {
    await this.ensureSearchPath()
    const result = await executeQuery(
      this.sql,
      text,
      values,
      undefined,
      catchingSavepoint,
      this.config.onQuery
    )
    return wrapResult(result) as QueryResult<T>
  }

  reconfigure(params: {
    database?: string
    password?: string
    schema?: string
    user?: string
  }): AdapterBase {
    const newConfig: BunSqlAdapterOptions = {
      ...this.config,
      config: { ...this.config.config }
    }

    if (!newConfig.config) {
      newConfig.config = {}
    }

    // Update URL if exists
    if (newConfig.config.url) {
      const urlString = newConfig.config.url instanceof URL
        ? newConfig.config.url.toString()
        : newConfig.config.url

      const url = new URL(urlString)

      if (params.database) url.pathname = `/${params.database}`
      if (params.user) url.username = params.user
      if (params.password) url.password = params.password
      if (params.schema) url.searchParams.set('schema', params.schema)
      newConfig.config.url = url.toString()
    }

    // Map Orchid params to Bun options
    if (params.database) newConfig.config.database = params.database
    if (params.user) newConfig.config.username = params.user
    if (params.password) newConfig.config.password = params.password
    if (params.schema) newConfig.schema = params.schema

    // Invalidate existing SQL instance if connection details changed
    if ((params.user || params.password || params.database) && newConfig.sql) {
      delete newConfig.sql
    }

    return new BunSqlAdapter(newConfig)
  }

  /**
   * Run queries within a transaction
   */
  async transaction<Result>(
    options: string | undefined,
    cb: (adapter: AdapterBase) => Promise<Result>
  ): Promise<Result> {
    return this.sql.begin(async (tx) => {
      const txAdapter = new BunSqlTransactionAdapter(this, tx, this.schema)

      // Set transaction options (e.g., isolation level)
      if (options) {
        await tx.unsafe(`SET TRANSACTION ${options}`)
      }

      // Set schema search_path within transaction
      await txAdapter.ensureSearchPath()

      return cb(txAdapter)
    }) as Promise<Result>
  }

  private async ensureSearchPath(): Promise<void> {
    if (this.searchPathSet || !this.schema || this.schema === 'public') return
    await this.sql.unsafe(`SET search_path = ${this.schema}`)
    this.searchPathSet = true
  }

  private getURL(): undefined | URL {
    if (!this.config.config?.url) return undefined
    return this.config.config.url instanceof URL
      ? this.config.config.url
      : new URL(this.config.config.url)
  }
}

/**
 * Transaction-scoped adapter that uses the transaction connection
 */
export class BunSqlTransactionAdapter implements AdapterBase {
  errorClass = SQL.PostgresError
  schema?: string

  /**
   * Set search_path within the transaction context
   */
  private searchPathSet = false

  constructor(
    public mainAdapter: BunSqlAdapter,
    public sql: SQL,
    schema?: string
  ) {
    this.schema = schema
  }

  async arrays<R extends any[] = any[]>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryArraysResult<R>> {
    const result = await executeQuery(
      this.sql,
      text,
      values,
      'array',
      catchingSavepoint,
      this.mainAdapter.config.onQuery
    )
    return wrapResult(result) as QueryArraysResult<R>
  }

  assignError(to: QueryError, from: Error): void {
    this.mainAdapter.assignError(to, from)
  }

  async close(): Promise<void> {
    // Transaction connections are managed by the parent .begin() scope
  }

  async ensureSearchPath(): Promise<void> {
    if (this.searchPathSet || !this.schema || this.schema === 'public') return
    await this.sql.unsafe(`SET search_path = ${this.schema}`)
    this.searchPathSet = true
  }

  getDatabase = (): string => this.mainAdapter.getDatabase()
  getHost = (): string => this.mainAdapter.getHost()

  getSchema = (): string | undefined => this.schema

  getUser = (): string => this.mainAdapter.getUser()

  async query<T extends QueryResultRow = QueryResultRow>(
    text: string,
    values?: unknown[],
    catchingSavepoint?: string
  ): Promise<QueryResult<T>> {
    const result = await executeQuery(
      this.sql,
      text,
      values,
      undefined,
      catchingSavepoint,
      this.mainAdapter.config.onQuery
    )
    return wrapResult(result) as QueryResult<T>
  }

  reconfigure(params: {
    database?: string
    password?: string
    schema?: string
    user?: string
  }): AdapterBase {
    return this.mainAdapter.reconfigure(params)
  }

  /**
   * Nested transactions: pass through since we're already in a transaction context.
   * The outer transaction handles commit/rollback.
   * Options are ignored for nested transactions as per PostgreSQL behavior.
   */
  async transaction<Result>(
    _options: string | undefined,
    cb: (adapter: AdapterBase) => Promise<Result>
  ): Promise<Result> {
    return cb(this)
  }
}

/**
 * Execute a query with optional savepoint wrapping for error recovery.
 * When catchingSavepoint is provided, the query is wrapped in a savepoint
 * so that on error we can rollback just that statement without aborting the transaction.
 *
 * @param sql - Bun SQL instance
 * @param text - SQL query text
 * @param values - Query parameters
 * @param rowMode - 'array' to return rows as arrays, undefined for objects
 * @param catchingSavepoint - Optional savepoint name for error recovery
 * @param onQuery - Optional callback for query logging/monitoring
 */
async function executeQuery(
  sql: SQL,
  text: string,
  values: undefined | unknown[],
  rowMode: 'array' | undefined,
  catchingSavepoint: string | undefined,
  onQuery?: (event: LogEvent) => void
): Promise<unknown[]> {
  const start = performance.now()

  const runQuery = async (): Promise<unknown[]> => {
    const query = values && values.length > 0
      ? sql.unsafe(text, values as any[])
      : sql.unsafe(text)

    return rowMode === 'array'
      ? await query.values()
      : await query
  }

  try {
    let result: unknown[]

    if (catchingSavepoint) {
      // Wrap query in savepoint for error recovery
      await sql.unsafe(`SAVEPOINT "${catchingSavepoint}"`)
      try {
        result = await runQuery()
        await sql.unsafe(`RELEASE SAVEPOINT "${catchingSavepoint}"`)
      } catch (err) {
        await sql.unsafe(`ROLLBACK TO SAVEPOINT "${catchingSavepoint}"`)
        throw err
      }
    } else {
      result = await runQuery()
    }

    // Emit query event for logging/monitoring
    if (onQuery) {
      const anyResult = result as any
      // SQL returns array-like objects with extra properties for write operations:
      // - `count`: number of affected rows (INSERT/UPDATE/DELETE)
      // - `command`: SQL command type (may not be present in all versions)
      onQuery({
        command: anyResult?.command,
        duration: performance.now() - start,
        params: values,
        rowCount: anyResult?.count ?? result.length,
        sql: text
      })
    }

    return result
  } catch (err) {
    // Log failed queries too
    if (onQuery) {
      onQuery({
        duration: performance.now() - start,
        error: err as Error,
        params: values,
        sql: text
      })
    }
    throw err
  }
}

[romeerez]

Thanks, but github issues can't replace PRs.

Bun support means adding adapter files, tests, all the ORM and related libraries tests should pass with the new adapter, pipeline should be extended to run tests on Bun, I'm entirely sure there will be edge cases when Bun adapter behaves differently and it will require figuring out workarounds.

If you're willing to contribute, please open a PR. It doesn't have to be complete, it could be as much complete as much time you're ready to give it, and I'll use this work later in the future.