@tanstack/tauri-db-sqlite-persistence 0.1.2

package/src/tauri-sql-driver.ts

@@ -0,0 +1,290 @@
+import { InvalidPersistedCollectionConfigError } from '@tanstack/db-sqlite-persistence-core'
+import type { SQLiteDriver } from '@tanstack/db-sqlite-persistence-core'
+import type Database from '@tauri-apps/plugin-sql'
+
+export type TauriSQLiteDatabaseLike = Pick<
+  Database,
+  `execute` | `select` | `close` | `path`
+>
+
+export type TauriSQLiteDriverOptions = {
+  database: TauriSQLiteDatabaseLike
+}
+
+function assertTransactionCallbackHasDriverArg(
+  fn: (transactionDriver: SQLiteDriver) => Promise<unknown>,
+): void {
+  if (fn.length > 0) {
+    return
+  }
+
+  throw new InvalidPersistedCollectionConfigError(
+    `SQLiteDriver.transaction callback must accept the transaction driver argument`,
+  )
+}
+
+function isTauriSQLiteDatabaseLike(
+  value: unknown,
+): value is TauriSQLiteDatabaseLike {
+  const candidate = value as Partial<TauriSQLiteDatabaseLike>
+  return (
+    typeof value === `object` &&
+    value !== null &&
+    typeof candidate.path === `string` &&
+    typeof candidate.execute === `function` &&
+    typeof candidate.select === `function`
+  )
+}
+
+function normalizeQueryRows<TRow>(
+  rows: unknown,
+  sql: string,
+): ReadonlyArray<TRow> {
+  if (Array.isArray(rows)) {
+    return rows as ReadonlyArray<TRow>
+  }
+
+  throw new InvalidPersistedCollectionConfigError(
+    `Unsupported Tauri SQL query result shape for SQL "${sql}"`,
+  )
+}
+
+function convertSqlitePlaceholdersToTauri(sql: string): string {
+  let result = ``
+  let parameterIndex = 1
+  let inSingleQuote = false
+  let inDoubleQuote = false
+  let inLineComment = false
+  let inBlockComment = false
+
+  for (let index = 0; index < sql.length; index++) {
+    const currentChar = sql[index]
+    const nextChar = sql[index + 1]
+
+    if (inLineComment) {
+      result += currentChar
+      if (currentChar === `\n`) {
+        inLineComment = false
+      }
+      continue
+    }
+
+    if (inBlockComment) {
+      result += currentChar
+      if (currentChar === `*` && nextChar === `/`) {
+        result += `/`
+        index++
+        inBlockComment = false
+      }
+      continue
+    }
+
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (currentChar === `-` && nextChar === `-`) {
+        result += `--`
+        index++
+        inLineComment = true
+        continue
+      }
+
+      if (currentChar === `/` && nextChar === `*`) {
+        result += `/*`
+        index++
+        inBlockComment = true
+        continue
+      }
+    }
+
+    if (currentChar === `'` && !inDoubleQuote) {
+      result += currentChar
+      if (inSingleQuote && nextChar === `'`) {
+        result += `'`
+        index++
+        continue
+      }
+      inSingleQuote = !inSingleQuote
+      continue
+    }
+
+    if (currentChar === `"` && !inSingleQuote) {
+      result += currentChar
+      if (inDoubleQuote && nextChar === `"`) {
+        result += `"`
+        index++
+        continue
+      }
+      inDoubleQuote = !inDoubleQuote
+      continue
+    }
+
+    if (currentChar === `?` && !inSingleQuote && !inDoubleQuote) {
+      result += `$${String(parameterIndex)}`
+      parameterIndex++
+      continue
+    }
+
+    result += currentChar
+  }
+
+  return result
+}
+
+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
+      } catch (error) {
+        try {
+          await this.executeStatement(`ROLLBACK`)
+        } catch {
+          // Keep the original transaction error as the primary failure.
+        }
+        throw error
+      }
+    })
+  }
+
+  async close(): Promise<void> {
+    if (typeof this.database.close !== `function`) {
+      return
+    }
+
+    await Promise.resolve(this.database.close(this.database.path))
+  }
+
+  getDatabase(): TauriSQLiteDatabaseLike {
+    return this.database
+  }
+
+  private async executeStatement(
+    sql: string,
+    params: ReadonlyArray<unknown> = [],
+  ): Promise<void> {
+    await this.database.execute(
+      convertSqlitePlaceholdersToTauri(sql),
+      params.length > 0 ? [...params] : undefined,
+    )
+  }
+
+  private enqueue<TReturn>(
+    operation: () => Promise<TReturn>,
+  ): Promise<TReturn> {
+    const queuedOperation = this.queue.then(operation, operation)
+    this.queue = queuedOperation.then(
+      () => undefined,
+      () => undefined,
+    )
+    return queuedOperation
+  }
+
+  private createTransactionDriver(): SQLiteDriver {
+    const transactionDriver: SQLiteDriver = {
+      exec: async (sql) => {
+        await this.executeStatement(sql)
+      },
+      query: async <TRow>(
+        sql: string,
+        params: ReadonlyArray<unknown> = [],
+      ): Promise<ReadonlyArray<TRow>> => {
+        const rows = await this.database.select<ReadonlyArray<TRow>>(
+          convertSqlitePlaceholdersToTauri(sql),
+          params.length > 0 ? [...params] : undefined,
+        )
+        return normalizeQueryRows<TRow>(rows, sql)
+      },
+      run: async (sql, params = []) => {
+        await this.executeStatement(sql, params)
+      },
+      transaction: async <TReturn>(
+        fn: (transactionDriver: SQLiteDriver) => Promise<TReturn>,
+      ): Promise<TReturn> => {
+        assertTransactionCallbackHasDriverArg(fn)
+        return this.runNestedTransaction(transactionDriver, fn)
+      },
+      transactionWithDriver: async <TReturn>(
+        fn: (transactionDriver: SQLiteDriver) => Promise<TReturn>,
+      ): Promise<TReturn> => this.runNestedTransaction(transactionDriver, fn),
+    }
+
+    return transactionDriver
+  }
+
+  private async runNestedTransaction<TReturn>(
+    transactionDriver: SQLiteDriver,
+    fn: (transactionDriver: SQLiteDriver) => Promise<TReturn>,
+  ): Promise<TReturn> {
+    const savepointName = `tsdb_sp_${this.nextSavepointId}`
+    this.nextSavepointId++
+    await this.executeStatement(`SAVEPOINT ${savepointName}`)
+
+    try {
+      const result = await fn(transactionDriver)
+      await this.executeStatement(`RELEASE SAVEPOINT ${savepointName}`)
+      return result
+    } catch (error) {
+      await this.executeStatement(`ROLLBACK TO SAVEPOINT ${savepointName}`)
+      await this.executeStatement(`RELEASE SAVEPOINT ${savepointName}`)
+      throw error
+    }
+  }
+}
+
+export function createTauriSQLiteDriver(
+  options: TauriSQLiteDriverOptions,
+): TauriSQLiteDriver {
+  return new TauriSQLiteDriver(options)
+}

package/src/tauri.ts

@@ -0,0 +1,20 @@
+import { createTauriSQLitePersistence as createPersistence } from './tauri-persistence'
+import type {
+  TauriSQLitePersistenceOptions as TauriSQLitePersistenceOptionsBase,
+  TauriSQLiteSchemaMismatchPolicy as TauriSQLiteSchemaMismatchPolicyBase,
+} from './tauri-persistence'
+import type { PersistedCollectionPersistence } from '@tanstack/db-sqlite-persistence-core'
+
+export type TauriSQLitePersistenceOptions = TauriSQLitePersistenceOptionsBase
+export type TauriSQLiteSchemaMismatchPolicy =
+  TauriSQLiteSchemaMismatchPolicyBase
+export type { TauriSQLiteDatabaseLike } from './tauri-persistence'
+
+export function createTauriSQLitePersistence<
+  T extends object,
+  TKey extends string | number = string | number,
+>(
+  options: TauriSQLitePersistenceOptions,
+): PersistedCollectionPersistence<T, TKey> {
+  return createPersistence<T, TKey>(options)
+}