Class ExpoSQLiteDriver

packages/expo-db-sqlite-persistence/src/expo-sqlite-driver.ts:78–226

}

export class ExpoSQLiteDriver implements SQLiteDriver {
  private readonly databasePromise: Promise<ExpoSQLiteDatabaseLike>
  private readonly ownsDatabase: boolean
  private queue: Promise<void> = Promise.resolve()
  private nextSavepointId = 1

  constructor(options: ExpoSQLiteDriverOptions) {
    if (hasExistingDatabase(options)) {
      if (!isExpoSQLiteDatabaseLike(options.database)) {
        throw new InvalidPersistedCollectionConfigError(
          `Expo SQLite database must provide execAsync/getAllAsync/runAsync/withExclusiveTransactionAsync`,
        )
      }

      this.databasePromise = Promise.resolve(options.database)
      this.ownsDatabase = false
      return
    }

    this.databasePromise = Promise.resolve(options.openDatabase()).then(
      (database) => {
        if (!isExpoSQLiteDatabaseLike(database)) {
          throw new InvalidPersistedCollectionConfigError(
            `Expo SQLite openDatabase() must resolve a database with execAsync/getAllAsync/runAsync/withExclusiveTransactionAsync`,
          )
        }

        return database
      },
    )
    this.ownsDatabase = true
  }

  async exec(sql: string): Promise<void> {
    await this.enqueue(async () => {
      const database = await this.getDatabase()
      await database.execAsync(sql)
    })
  }

  async query<T>(
    sql: string,
    params: ReadonlyArray<unknown> = [],
  ): Promise<ReadonlyArray<T>> {
    return this.enqueue(async () => {
      const database = await this.getDatabase()
      return database.getAllAsync<T>(sql, normalizeParams(params))
    })
  }

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

  async transaction<T>(