Class TauriSQLiteDriver

packages/tauri-db-sqlite-persistence/src/tauri-sql-driver.ts:132–284

}

export class TauriSQLiteDriver implements SQLiteDriver {
  private readonly database: TauriSQLiteDatabaseLike
  private queue: Promise<void> = Promise.resolve()
  private nextSavepointId = 1

  constructor(options: TauriSQLiteDriverOptions) {
    if (!isTauriSQLiteDatabaseLike(options.database)) {
      throw new InvalidPersistedCollectionConfigError(
        `Tauri SQLite database object must provide execute/select methods`,
      )
    }

    this.database = options.database
  }

  async exec(sql: string): Promise<void> {
    await this.enqueue(async () => {
      await this.executeStatement(sql)
    })
  }

  async query<TRow>(
    sql: string,
    params: ReadonlyArray<unknown> = [],
  ): Promise<ReadonlyArray<TRow>> {
    return this.enqueue(async () => {
      const rows = await this.database.select<ReadonlyArray<TRow>>(
        convertSqlitePlaceholdersToTauri(sql),
        params.length > 0 ? [...params] : undefined,
      )
      return normalizeQueryRows<TRow>(rows, sql)
    })
  }

  async run(sql: string, params: ReadonlyArray<unknown> = []): Promise<void> {
    await this.enqueue(async () => {
      await this.executeStatement(sql, params)
    })
  }

  async transaction<TReturn>(
    fn: (transactionDriver: SQLiteDriver) => Promise<TReturn>,
  ): Promise<TReturn> {
    assertTransactionCallbackHasDriverArg(fn)
    return this.transactionWithDriver(fn)
  }

  async transactionWithDriver<TReturn>(
    fn: (transactionDriver: SQLiteDriver) => Promise<TReturn>,
  ): Promise<TReturn> {
    return this.enqueue(async () => {
      await this.executeStatement(`BEGIN IMMEDIATE`)
      const transactionDriver = this.createTransactionDriver()

      try {
        const result = await fn(transactionDriver)
        await this.executeStatement(`COMMIT`)
        return result