Skip to content
Source
Sign inSign up
TanStack/db
Open History to see the last commit

wa-sqlite-driver.ts

153 lines4.4 KB

1import { InvalidPersistedCollectionConfigError } from '@tanstack/db-sqlite-persistence-core'
2import type { SQLiteDriver } from '@tanstack/db-sqlite-persistence-core'
3​
4export type BrowserWASQLiteDatabase = {
5 execute: <TRow = unknown>(
6 sql: string,
7 params?: ReadonlyArray<unknown>,
8 ) => Promise<ReadonlyArray<TRow>>
9 close?: () => Promise<void> | void
11​
12export type BrowserWASQLiteDriverOptions = {
13 database: BrowserWASQLiteDatabase
15​
16function assertTransactionCallbackHasDriverArg(
17 fn: (transactionDriver: SQLiteDriver) => Promise<unknown>,
18): void {
19 if (fn.length > 0) {
20 return
21 }
22​
23 throw new InvalidPersistedCollectionConfigError(
24 `SQLiteDriver.transaction callback must accept the transaction driver argument`,
25 )
27​
28function assertDatabaseShape(
29 database: BrowserWASQLiteDatabase,
30): asserts database is BrowserWASQLiteDatabase {
31 if (typeof database.execute !== `function`) {
32 throw new InvalidPersistedCollectionConfigError(
33 `Browser wa-sqlite database handle must provide execute(sql, params?)`,
34 )
35 }
37​
38export class BrowserWASQLiteDriver implements SQLiteDriver {
39 private readonly database: BrowserWASQLiteDatabase
40 private queue: Promise<void> = Promise.resolve()
41 private nextSavepointId = 1
42 private closed = false
43​
44 constructor(options: BrowserWASQLiteDriverOptions) {
45 assertDatabaseShape(options.database)
46 this.database = options.database
47 }
48​
49 async exec(sql: string): Promise<void> {
50 await this.enqueue(async () => {
51 await this.database.execute(sql)
52 })
53 }
54​
55 async query<T>(
56 sql: string,
57 params: ReadonlyArray<unknown> = [],
58 ): Promise<ReadonlyArray<T>> {
59 return this.enqueue(() => this.database.execute<T>(sql, params))
60 }
61​
62 async run(sql: string, params: ReadonlyArray<unknown> = []): Promise<void> {
63 await this.enqueue(async () => {
64 await this.database.execute(sql, params)
65 })
66 }
67​
68 async transaction<T>(
69 fn: (transactionDriver: SQLiteDriver) => Promise<T>,
70 ): Promise<T> {
71 assertTransactionCallbackHasDriverArg(fn)
72​
73 return this.enqueue(async () => {
74 await this.database.execute(`BEGIN IMMEDIATE`)
75 try {
76 const result = await fn(this.createTransactionDriver())
77 await this.database.execute(`COMMIT`)
78 return result
79 } catch (error) {
80 try {
81 await this.database.execute(`ROLLBACK`)
82 } catch {
83 // Preserve original transaction error.
84 }
85 throw error
86 }
87 })
88 }
89​
90 async transactionWithDriver<T>(
91 fn: (transactionDriver: SQLiteDriver) => Promise<T>,
92 ): Promise<T> {
93 return this.transaction(fn)
94 }
95​
96 async close(): Promise<void> {
97 if (this.closed) {
98 return
99 }
100 this.closed = true
101​
102 if (typeof this.database.close === `function`) {
103 await Promise.resolve(this.database.close())
104 }
105 }
106​
107 getDatabase(): BrowserWASQLiteDatabase {
108 return this.database
109 }
110​
111 private createTransactionDriver(): SQLiteDriver {
112 return {
113 exec: (sql) => this.database.execute(sql).then(() => undefined),
114 query: <T>(sql: string, params: ReadonlyArray<unknown> = []) =>
115 this.database.execute<T>(sql, params),
116 run: (sql: string, params: ReadonlyArray<unknown> = []) =>
117 this.database.execute(sql, params).then(() => undefined),
118 transaction: <T>(fn: (transactionDriver: SQLiteDriver) => Promise<T>) =>
119 this.runNestedTransaction(fn),
120 transactionWithDriver: <T>(
121 fn: (transactionDriver: SQLiteDriver) => Promise<T>,
122 ) => this.runNestedTransaction(fn),
123 }
124 }
125​
126 private async runNestedTransaction<T>(
127 fn: (transactionDriver: SQLiteDriver) => Promise<T>,
128 ): Promise<T> {
129 assertTransactionCallbackHasDriverArg(fn)
130​
131 const savepointName = `tsdb_sp_${this.nextSavepointId}`
132 this.nextSavepointId++
133 await this.database.execute(`SAVEPOINT ${savepointName}`)
134 try {
135 const result = await fn(this.createTransactionDriver())
136 await this.database.execute(`RELEASE SAVEPOINT ${savepointName}`)
137 return result
138 } catch (error) {
139 await this.database.execute(`ROLLBACK TO SAVEPOINT ${savepointName}`)
140 await this.database.execute(`RELEASE SAVEPOINT ${savepointName}`)
141 throw error
142 }
143 }
144​
145 private enqueue<T>(operation: () => Promise<T> | T): Promise<T> {
146 const queuedOperation = this.queue.then(operation, operation)
147 this.queue = queuedOperation.then(
148 () => undefined,
149 () => undefined,
150 )
151 return queuedOperation
152 }