Class TransactionBuilder

src/kysely.ts:862–922

interface ConnectionBuilderProps extends KyselyProps {}

export class TransactionBuilder<DB> {
  readonly #props: TransactionBuilderProps

  constructor(props: TransactionBuilderProps) {
    this.#props = freeze(props)
  }

  setAccessMode(accessMode: AccessMode): TransactionBuilder<DB> {
    return new TransactionBuilder({
      ...this.#props,
      accessMode,
    })
  }

  setIsolationLevel(isolationLevel: IsolationLevel): TransactionBuilder<DB> {
    return new TransactionBuilder({
      ...this.#props,
      isolationLevel,
    })
  }

  async execute<T>(callback: (trx: Transaction<DB>) => Promise<T>): Promise<T> {
    const { isolationLevel, accessMode, ...kyselyProps } = this.#props
    const settings = { isolationLevel, accessMode }

    validateTransactionSettings(settings)

    return this.#props.executor.provideConnection(async (connection) => {
      const state = { isCommitted: false, isRolledBack: false }

      const executor = new NotCommittedOrRolledBackAssertingExecutor(
        this.#props.executor.withConnectionProvider(
          new SingleConnectionProvider(connection),
        ),
        state,
      )

      const transaction = new Transaction<DB>({ ...kyselyProps, executor })

      let transactionBegun = false
      try {
        await this.#props.driver.beginTransaction(connection, settings)
        transactionBegun = true

        const result = await callback(transaction)

        await this.#props.driver.commitTransaction(connection)
        state.isCommitted = true

        return result
      } catch (error) {
        if (transactionBegun) {
          await this.#props.driver.rollbackTransaction(connection)
          state.isRolledBack = true
        }

        throw error
      }