Open History to see the last commit
1import { afterEach, describe, expect, it } from 'vitest'
2import {
3 InvalidPersistedCollectionConfigError,
4 PersistenceUnavailableError,
5} from '@tanstack/db-sqlite-persistence-core'
6import { openBrowserWASQLiteOPFSDatabase } from '../src/opfs-database'
7import type {
8 BrowserOPFSWorkerErrorCode,
9 BrowserOPFSWorkerRequest,
10 BrowserOPFSWorkerResponse,
11} from '../src/opfs-worker-protocol'
12
13type FakeWorkerBehavior = {
14 initErrorCode?: BrowserOPFSWorkerErrorCode
15 initErrorMessage?: string
16 executeRows?: ReadonlyArray<Record<string, unknown>>
17 closeErrorCode?: BrowserOPFSWorkerErrorCode
18 closeErrorMessage?: string
19}
20
21class FakeWorker {
22 static instances: Array<FakeWorker> = []
23 static behavior: FakeWorkerBehavior = {}
24
25 private readonly listeners: {
26 message: Set<(event: MessageEvent<BrowserOPFSWorkerResponse>) => void>
27 error: Set<(event: MessageEvent<BrowserOPFSWorkerResponse>) => void>
28 messageerror: Set<(event: MessageEvent<BrowserOPFSWorkerResponse>) => void>
29 } = {
30 message: new Set(),
31 error: new Set(),
32 messageerror: new Set(),
33 }
34
35 private initialized = false
36 public terminated = false
37
38 constructor(..._args: Array<unknown>) {
39 FakeWorker.instances.push(this)
40 }
41
42 addEventListener(
43 type: keyof FakeWorker[`listeners`],
44 listener: (event: MessageEvent<BrowserOPFSWorkerResponse>) => void,
45 ): void {
46 this.listeners[type].add(listener)
47 }
48
49 removeEventListener(
50 type: keyof FakeWorker[`listeners`],
51 listener: (event: MessageEvent<BrowserOPFSWorkerResponse>) => void,
52 ): void {
53 this.listeners[type].delete(listener)
54 }
55
56 terminate(): void {
57 this.terminated = true
58 }
59
60 postMessage(request: BrowserOPFSWorkerRequest): void {
61 if (this.terminated) {
62 return
63 }
64
65 queueMicrotask(() => {
66 const response = this.handleRequest(request)
67 this.emitMessage(response)
68 })
69 }
70
71 private handleRequest(
72 request: BrowserOPFSWorkerRequest,
73 ): BrowserOPFSWorkerResponse {
74 switch (request.type) {
75 case `init`: {
76 if (FakeWorker.behavior.initErrorCode) {
77 return {
78 type: `response`,
79 requestId: request.requestId,
80 ok: false,
81 code: FakeWorker.behavior.initErrorCode,
82 error:
83 FakeWorker.behavior.initErrorMessage ??
84 `init failed in fake OPFS worker`,
85 }
86 }
87
88 this.initialized = true
89 return {
90 type: `response`,
91 requestId: request.requestId,
92 ok: true,
93 }
94 }
95 case `execute`: {
96 if (!this.initialized) {
97 return {
98 type: `response`,
99 requestId: request.requestId,
100 ok: false,
101 code: `INVALID_CONFIG`,
102 error: `worker not initialized`,
103 }
104 }
105 return {
106 type: `response`,
107 requestId: request.requestId,
108 ok: true,
109 rows: FakeWorker.behavior.executeRows ?? [{ value: 1 }],
110 }
111 }
112 case `close`: {
113 if (FakeWorker.behavior.closeErrorCode) {
114 return {
115 type: `response`,
116 requestId: request.requestId,
117 ok: false,
118 code: FakeWorker.behavior.closeErrorCode,
119 error:
120 FakeWorker.behavior.closeErrorMessage ??
121 `close failed in fake OPFS worker`,
122 }
123 }
124
125 this.initialized = false
126 return {
127 type: `response`,
128 requestId: request.requestId,
129 ok: true,
130 }
131 }
132 }
133 }
134
135 private emitMessage(response: BrowserOPFSWorkerResponse): void {
136 for (const listener of this.listeners.message) {
137 listener({
138 data: response,
139 } as MessageEvent<BrowserOPFSWorkerResponse>)
140 }
141 }
142}
143
144const originalWorker = (globalThis as typeof globalThis & { Worker?: unknown })
145 .Worker
146const originalNavigator = globalThis.navigator
147
148function installWorkerTestEnvironment(behavior: FakeWorkerBehavior = {}): void {
149 FakeWorker.instances = []
150 FakeWorker.behavior = behavior
151 Object.defineProperty(globalThis, `Worker`, {
152 value: FakeWorker,
153 configurable: true,
154 writable: true,
155 })
156 Object.defineProperty(globalThis, `navigator`, {
157 value: {
158 storage: {
159 getDirectory: () => Promise.resolve({}),
160 },
161 },
162 configurable: true,
163 writable: true,
164 })
165}
166
167function restoreWorkerTestEnvironment(): void {
168 Object.defineProperty(globalThis, `Worker`, {
169 value: originalWorker,
170 configurable: true,
171 writable: true,
172 })
173 Object.defineProperty(globalThis, `navigator`, {
174 value: originalNavigator,
175 configurable: true,
176 writable: true,
177 })
178}
179
180afterEach(() => {
181 restoreWorkerTestEnvironment()
182})
183
184describe(`openBrowserWASQLiteOPFSDatabase`, () => {
185 it(`initializes via worker and supports execute + close`, async () => {
186 installWorkerTestEnvironment({
187 executeRows: [{ id: `1`, title: `from worker` }],
188 })
189
190 const database = await openBrowserWASQLiteOPFSDatabase({
191 databaseName: `phase-7.sqlite`,
192 })
193 const rows = await database.execute<{ id: string; title: string }>(
194 `SELECT 1`,
195 )
196 expect(rows).toEqual([{ id: `1`, title: `from worker` }])
197
198 await database.close?.()
199
200 expect(FakeWorker.instances).toHaveLength(1)
201 expect(FakeWorker.instances[0]?.terminated).toBe(true)
202 })
203
204 it(`terminates worker when init fails`, async () => {
205 installWorkerTestEnvironment({
206 initErrorCode: `PERSISTENCE_UNAVAILABLE`,
207 initErrorMessage: `sync handles unavailable`,
208 })
209
210 await expect(
211 openBrowserWASQLiteOPFSDatabase({
212 databaseName: `phase-7.sqlite`,
213 }),
214 ).rejects.toBeInstanceOf(PersistenceUnavailableError)
215
216 expect(FakeWorker.instances).toHaveLength(1)
217 expect(FakeWorker.instances[0]?.terminated).toBe(true)
218 })
219
220 it(`always terminates worker when close fails`, async () => {
221 installWorkerTestEnvironment({
222 closeErrorCode: `INVALID_CONFIG`,
223 closeErrorMessage: `close failure`,
224 })
225
226 const database = await openBrowserWASQLiteOPFSDatabase({
227 databaseName: `phase-7.sqlite`,
228 })
229
230 await expect(database.close?.()).rejects.toBeInstanceOf(
231 InvalidPersistedCollectionConfigError,
232 )
233 expect(FakeWorker.instances[0]?.terminated).toBe(true)
234 })
235
236 it(`can reopen a database after closing the worker connection`, async () => {
237 installWorkerTestEnvironment({
238 executeRows: [{ ok: true }],
239 })
240
241 const firstDatabase = await openBrowserWASQLiteOPFSDatabase({
242 databaseName: `phase-7.sqlite`,
243 })
244 await firstDatabase.close?.()
245
246 const secondDatabase = await openBrowserWASQLiteOPFSDatabase({
247 databaseName: `phase-7.sqlite`,
248 })
249 const rows = await secondDatabase.execute<{ ok: boolean }>(`SELECT 1`)
250 expect(rows).toEqual([{ ok: true }])
251 await secondDatabase.close?.()
252
253 expect(FakeWorker.instances).toHaveLength(2)
254 expect(FakeWorker.instances[0]?.terminated).toBe(true)
255 expect(FakeWorker.instances[1]?.terminated).toBe(true)
256 })
257})