Open History to see the last commit
1import SQLiteESMFactory from '@journeyapps/wa-sqlite/dist/wa-sqlite.mjs'
2import * as SQLite from '@journeyapps/wa-sqlite'
3import { OPFSCoopSyncVFS } from '@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js'
4import {
5 InvalidPersistedCollectionConfigError,
6 PersistenceUnavailableError,
7} from '@tanstack/db-sqlite-persistence-core'
8import type {
9 BrowserOPFSWorkerErrorCode,
10 BrowserOPFSWorkerRequest,
11 BrowserOPFSWorkerResponse,
12} from './opfs-worker-protocol'
13
14const workerGlobal = globalThis as typeof globalThis & {
15 postMessage: (message: BrowserOPFSWorkerResponse) => void
16 addEventListener: (
17 type: `message`,
18 listener: (event: MessageEvent<BrowserOPFSWorkerRequest>) => void,
19 ) => void
20}
21
22const SQLITE_ROW = 100
23const SQLITE_DONE = 101
24
25type SQLiteCompatibleBinding =
26 | null
27 | string
28 | number
29 | bigint
30 | Uint8Array
31 | Array<number>
32
33type WorkerOPFSGlobal = {
34 navigator?: {
35 storage?: {
36 getDirectory?: () => Promise<unknown>
37 }
38 }
39 FileSystemFileHandle?: {
40 prototype?: {
41 createSyncAccessHandle?: () => Promise<unknown>
42 }
43 }
44}
45
46let sqlite3Instance: ReturnType<typeof SQLite.Factory> | null = null
47let sqliteDatabaseHandle: number | null = null
48let opfsVfsInstance: { close?: () => Promise<void> | void } | null = null
49
50function hasWorkerOPFSSyncAccessSupport(globalObject: unknown): boolean {
51 const candidate = globalObject as WorkerOPFSGlobal
52 const getDirectory = candidate.navigator?.storage?.getDirectory
53 const createSyncAccessHandle =
54 candidate.FileSystemFileHandle?.prototype?.createSyncAccessHandle
55
56 return (
57 typeof getDirectory === `function` &&
58 typeof createSyncAccessHandle === `function`
59 )
60}
61
62function toBindableValue(value: unknown): SQLiteCompatibleBinding {
63 if (value === null || value === undefined) {
64 return null
65 }
66
67 if (typeof value === `string`) {
68 return value
69 }
70
71 if (typeof value === `number`) {
72 return Number.isFinite(value) ? value : null
73 }
74
75 if (typeof value === `bigint`) {
76 return value
77 }
78
79 if (typeof value === `boolean`) {
80 return value ? 1 : 0
81 }
82
83 if (value instanceof Date) {
84 return value.toISOString()
85 }
86
87 if (value instanceof Uint8Array) {
88 return value
89 }
90
91 if (
92 Array.isArray(value) &&
93 value.every((entry) => typeof entry === `number` && Number.isFinite(entry))
94 ) {
95 return [...value]
96 }
97
98 throw new InvalidPersistedCollectionConfigError(
99 `Unsupported parameter type for wa-sqlite binding`,
100 )
101}
102
103function toErrorCode(error: unknown): BrowserOPFSWorkerErrorCode {
104 if (error instanceof PersistenceUnavailableError) {
105 return `PERSISTENCE_UNAVAILABLE`
106 }
107 if (error instanceof InvalidPersistedCollectionConfigError) {
108 return `INVALID_CONFIG`
109 }
110 return `INTERNAL`
111}
112
113async function closeWorkerDatabase(): Promise<void> {
114 const sqlite3 = sqlite3Instance
115 const dbHandle = sqliteDatabaseHandle
116 const vfs = opfsVfsInstance
117
118 sqlite3Instance = null
119 sqliteDatabaseHandle = null
120 opfsVfsInstance = null
121
122 let closeError: unknown
123 if (sqlite3 && dbHandle !== null) {
124 try {
125 await sqlite3.close(dbHandle)
126 } catch (error) {
127 closeError = error
128 }
129 }
130
131 try {
132 await Promise.resolve(vfs?.close?.())
133 } catch (error) {
134 closeError ??= error
135 }
136
137 if (closeError) {
138 throw closeError
139 }
140}
141
142async function initializeWorkerDatabase(request: {
143 databaseName: string
144 vfsName: string
145}): Promise<void> {
146 if (!hasWorkerOPFSSyncAccessSupport(workerGlobal)) {
147 throw new PersistenceUnavailableError(
148 `Browser OPFS sync access is not available in this worker runtime`,
149 )
150 }
151
152 await closeWorkerDatabase()
153
154 const sqliteModule = await SQLiteESMFactory()
155 const sqlite3 = SQLite.Factory(sqliteModule)
156 const opfsVfs = await OPFSCoopSyncVFS.create(request.vfsName, sqliteModule)
157 sqlite3.vfs_register(opfsVfs as never, true)
158
159 const openFlags =
160 SQLite.SQLITE_OPEN_CREATE |
161 SQLite.SQLITE_OPEN_READWRITE |
162 SQLite.SQLITE_OPEN_URI
163 const databaseFileUri = `file:${request.databaseName}?vfs=${encodeURIComponent(request.vfsName)}`
164 const dbHandle = await sqlite3.open_v2(
165 databaseFileUri,
166 openFlags,
167 request.vfsName,
168 )
169
170 sqlite3Instance = sqlite3
171 sqliteDatabaseHandle = dbHandle
172 opfsVfsInstance = opfsVfs
173}
174
175function getInitializedDatabaseState(): {
176 sqlite3: ReturnType<typeof SQLite.Factory>
177 dbHandle: number
178} {
179 if (!sqlite3Instance || sqliteDatabaseHandle === null) {
180 throw new InvalidPersistedCollectionConfigError(
181 `OPFS worker database has not been initialized`,
182 )
183 }
184
185 return {
186 sqlite3: sqlite3Instance,
187 dbHandle: sqliteDatabaseHandle,
188 }
189}
190
191async function executeSqlInWorker(
192 sql: string,
193 params: ReadonlyArray<unknown>,
194): Promise<ReadonlyArray<Record<string, unknown>>> {
195 const { sqlite3, dbHandle } = getInitializedDatabaseState()
196 const rows = new Array<Record<string, unknown>>()
197 let parametersBound = false
198
199 for await (const statement of sqlite3.statements(dbHandle, sql)) {
200 if (params.length > 0) {
201 if (parametersBound) {
202 throw new InvalidPersistedCollectionConfigError(
203 `wa-sqlite worker only supports parameter binding for a single SQL statement`,
204 )
205 }
206
207 sqlite3.bind_collection(
208 statement,
209 params.map((param) => toBindableValue(param)),
210 )
211 parametersBound = true
212 }
213
214 let columns = [...sqlite3.column_names(statement)]
215 for (;;) {
216 const stepResult = await sqlite3.step(statement)
217
218 if (stepResult === SQLITE_ROW) {
219 if (columns.length === 0) {
220 columns = [...sqlite3.column_names(statement)]
221 }
222 const values = sqlite3.row(statement)
223 const row: Record<string, unknown> = {}
224 for (let columnIndex = 0; columnIndex < columns.length; columnIndex++) {
225 const columnName = columns[columnIndex]
226 if (!columnName) {
227 continue
228 }
229 row[columnName] = values[columnIndex]
230 }
231 rows.push(row)
232 continue
233 }
234
235 if (stepResult === SQLITE_DONE) {
236 break
237 }
238
239 throw new InvalidPersistedCollectionConfigError(
240 `wa-sqlite step returned unexpected result code: ${String(stepResult)}`,
241 )
242 }
243 }
244
245 if (params.length > 0 && !parametersBound) {
246 throw new InvalidPersistedCollectionConfigError(
247 `SQL query parameters were provided but no statement accepted bindings`,
248 )
249 }
250
251 return rows
252}
253
254async function handleWorkerRequest(
255 request: BrowserOPFSWorkerRequest,
256): Promise<BrowserOPFSWorkerResponse> {
257 try {
258 switch (request.type) {
259 case `init`:
260 await initializeWorkerDatabase({
261 databaseName: request.databaseName,
262 vfsName: request.vfsName,
263 })
264 return {
265 type: `response`,
266 requestId: request.requestId,
267 ok: true,
268 }
269 case `execute`: {
270 const rows = await executeSqlInWorker(request.sql, request.params)
271 return {
272 type: `response`,
273 requestId: request.requestId,
274 ok: true,
275 rows,
276 }
277 }
278 case `close`:
279 await closeWorkerDatabase()
280 return {
281 type: `response`,
282 requestId: request.requestId,
283 ok: true,
284 }
285 default:
286 throw new InvalidPersistedCollectionConfigError(
287 `Unknown OPFS worker request type`,
288 )
289 }
290 } catch (error) {
291 return {
292 type: `response`,
293 requestId: request.requestId,
294 ok: false,
295 code: toErrorCode(error),
296 error: (error as Error).message,
297 }
298 }
299}
300
301workerGlobal.addEventListener(`message`, (event) => {
302 void handleWorkerRequest(event.data).then((response) => {
303 workerGlobal.postMessage(response)
304 })
305})