Open History to see the last commit
1import { mkdtempSync, rmSync } from 'node:fs'
2import { tmpdir } from 'node:os'
3import { join } from 'node:path'
4import { afterEach, expect, it } from 'vitest'
5import { OpSQLiteDriver } from '../src/op-sqlite-driver'
6import { InvalidPersistedCollectionConfigError } from '../../db-sqlite-persistence-core/src'
7import { createOpSQLiteTestDatabase } from './helpers/op-sqlite-test-db'
8
9const activeCleanupFns: Array<() => void | Promise<void>> = []
10
11afterEach(async () => {
12 while (activeCleanupFns.length > 0) {
13 const cleanupFn = activeCleanupFns.pop()
14 await Promise.resolve(cleanupFn?.())
15 }
16})
17
18function createTempSqlitePath(): string {
19 const tempDirectory = mkdtempSync(join(tmpdir(), `db-rn-op-sqlite-test-`))
20 const dbPath = join(tempDirectory, `state.sqlite`)
21 activeCleanupFns.push(() => {
22 rmSync(tempDirectory, { recursive: true, force: true })
23 })
24 return dbPath
25}
26
27it.each([`rows-array`, `rows-object`, `rows-list`, `statement-array`] as const)(
28 `reads query rows across result shape: %s`,
29 async (resultShape) => {
30 const dbPath = createTempSqlitePath()
31 const database = createOpSQLiteTestDatabase({
32 filename: dbPath,
33 resultShape,
34 })
35 activeCleanupFns.push(() => Promise.resolve(database.close()))
36
37 const driver = new OpSQLiteDriver({ database })
38 await driver.exec(
39 `CREATE TABLE todos (id TEXT PRIMARY KEY, title TEXT NOT NULL, score INTEGER NOT NULL)`,
40 )
41 await driver.run(`INSERT INTO todos (id, title, score) VALUES (?, ?, ?)`, [
42 `1`,
43 `From test`,
44 7,
45 ])
46
47 const rows = await driver.query<{
48 id: string
49 title: string
50 score: number
51 }>(`SELECT id, title, score FROM todos ORDER BY id ASC`)
52 expect(rows).toEqual([
53 {
54 id: `1`,
55 title: `From test`,
56 score: 7,
57 },
58 ])
59 },
60)
61
62it(`rolls back transaction on failure`, async () => {
63 const dbPath = createTempSqlitePath()
64 const database = createOpSQLiteTestDatabase({ filename: dbPath })
65 activeCleanupFns.push(() => Promise.resolve(database.close()))
66
67 const driver = new OpSQLiteDriver({ database })
68 await driver.exec(
69 `CREATE TABLE tx_test (id TEXT PRIMARY KEY, title TEXT NOT NULL)`,
70 )
71
72 await expect(
73 driver.transactionWithDriver(async (transactionDriver) => {
74 await transactionDriver.run(
75 `INSERT INTO tx_test (id, title) VALUES (?, ?)`,
76 [`1`, `First`],
77 )
78 await transactionDriver.run(
79 `INSERT INTO tx_test (missing_column) VALUES (?)`,
80 [`x`],
81 )
82 }),
83 ).rejects.toThrow()
84
85 const rows = await driver.query<{ count: number }>(
86 `SELECT COUNT(*) AS count FROM tx_test`,
87 )
88 expect(rows[0]?.count).toBe(0)
89})
90
91it(`supports nested savepoint rollback without losing outer transaction`, async () => {
92 const dbPath = createTempSqlitePath()
93 const database = createOpSQLiteTestDatabase({ filename: dbPath })
94 activeCleanupFns.push(() => Promise.resolve(database.close()))
95
96 const driver = new OpSQLiteDriver({ database })
97 await driver.exec(
98 `CREATE TABLE nested_tx_test (id TEXT PRIMARY KEY, title TEXT NOT NULL)`,
99 )
100
101 await driver.transactionWithDriver(async (outerTransactionDriver) => {
102 await outerTransactionDriver.run(
103 `INSERT INTO nested_tx_test (id, title) VALUES (?, ?)`,
104 [`1`, `Outer before`],
105 )
106
107 await expect(
108 outerTransactionDriver.transaction(async (innerTransactionDriver) => {
109 await innerTransactionDriver.run(
110 `INSERT INTO nested_tx_test (id, title) VALUES (?, ?)`,
111 [`2`, `Inner failing`],
112 )
113 throw new Error(`nested-failure`)
114 }),
115 ).rejects.toThrow(`nested-failure`)
116
117 await outerTransactionDriver.run(
118 `INSERT INTO nested_tx_test (id, title) VALUES (?, ?)`,
119 [`3`, `Outer after`],
120 )
121 })
122
123 const rows = await driver.query<{ id: string; title: string }>(
124 `SELECT id, title FROM nested_tx_test ORDER BY id ASC`,
125 )
126 expect(rows).toEqual([
127 { id: `1`, title: `Outer before` },
128 { id: `3`, title: `Outer after` },
129 ])
130})
131
132it(`supports transaction callbacks that use provided transaction driver`, async () => {
133 const dbPath = createTempSqlitePath()
134 const database = createOpSQLiteTestDatabase({ filename: dbPath })
135 activeCleanupFns.push(() => Promise.resolve(database.close()))
136
137 const driver = new OpSQLiteDriver({ database })
138 await driver.exec(`CREATE TABLE closure_tx_test (value INTEGER NOT NULL)`)
139
140 let resolveHold: (() => void) | undefined
141 const hold = new Promise<void>((resolve) => {
142 resolveHold = resolve
143 })
144 let resolveEntered: (() => void) | undefined
145 const entered = new Promise<void>((resolve) => {
146 resolveEntered = resolve
147 })
148
149 const txPromise = driver.transaction(async (transactionDriver) => {
150 if (!resolveEntered) {
151 throw new Error(`transaction entry signal missing`)
152 }
153 resolveEntered()
154 await transactionDriver.run(
155 `INSERT INTO closure_tx_test (value) VALUES (?)`,
156 [1],
157 )
158 await hold
159 await transactionDriver.run(
160 `INSERT INTO closure_tx_test (value) VALUES (?)`,
161 [2],
162 )
163 })
164
165 await entered
166
167 let outsideResolved = false
168 const outsidePromise = driver
169 .run(`INSERT INTO closure_tx_test (value) VALUES (?)`, [3])
170 .then(() => {
171 outsideResolved = true
172 })
173
174 await Promise.resolve()
175 expect(outsideResolved).toBe(false)
176
177 if (!resolveHold) {
178 throw new Error(`transaction hold signal missing`)
179 }
180 resolveHold()
181
182 await Promise.all([txPromise, outsidePromise])
183
184 const rows = await driver.query<{ value: number }>(
185 `SELECT value FROM closure_tx_test ORDER BY value ASC`,
186 )
187 expect(rows.map((row) => row.value)).toEqual([1, 2, 3])
188})
189
190it(`throws when transaction callback omits transaction driver argument`, async () => {
191 const dbPath = createTempSqlitePath()
192 const database = createOpSQLiteTestDatabase({ filename: dbPath })
193 activeCleanupFns.push(() => Promise.resolve(database.close()))
194
195 const driver = new OpSQLiteDriver({ database })
196
197 await expect(
198 driver.transaction((async () => undefined) as never),
199 ).rejects.toThrow(`transaction driver argument`)
200})
201
202it(`serializes unrelated operations behind an active transaction`, async () => {
203 const dbPath = createTempSqlitePath()
204 const database = createOpSQLiteTestDatabase({ filename: dbPath })
205 activeCleanupFns.push(() => Promise.resolve(database.close()))
206
207 const driver = new OpSQLiteDriver({ database })
208 await driver.exec(
209 `CREATE TABLE tx_scope_test (id TEXT PRIMARY KEY, title TEXT NOT NULL)`,
210 )
211
212 let resolveOuterTransaction: (() => void) | undefined
213 const outerTransactionGate = new Promise<void>((resolve) => {
214 resolveOuterTransaction = resolve
215 })
216
217 let signalOuterInsertComplete: (() => void) | undefined
218 const outerInsertComplete = new Promise<void>((resolve) => {
219 signalOuterInsertComplete = resolve
220 })
221
222 const outerTransaction = driver.transactionWithDriver(
223 async (transactionDriver) => {
224 await transactionDriver.run(
225 `INSERT INTO tx_scope_test (id, title) VALUES (?, ?)`,
226 [`outer`, `Inside transaction`],
227 )
228 signalOuterInsertComplete?.()
229 await outerTransactionGate
230 throw new Error(`rollback-outer-transaction`)
231 },
232 )
233
234 await outerInsertComplete
235
236 let unrelatedWriteCompleted = false
237 const unrelatedWrite = driver
238 .run(`INSERT INTO tx_scope_test (id, title) VALUES (?, ?)`, [
239 `outside`,
240 `Outside transaction`,
241 ])
242 .then(() => {
243 unrelatedWriteCompleted = true
244 })
245 await Promise.resolve()
246 expect(unrelatedWriteCompleted).toBe(false)
247
248 resolveOuterTransaction?.()
249
250 await expect(outerTransaction).rejects.toThrow(`rollback-outer-transaction`)
251 await unrelatedWrite
252
253 const rows = await driver.query<{ id: string; title: string }>(
254 `SELECT id, title FROM tx_scope_test ORDER BY id ASC`,
255 )
256 expect(rows).toEqual([{ id: `outside`, title: `Outside transaction` }])
257})
258
259it(`throws config error when db execute methods are missing`, () => {
260 expect(() => new OpSQLiteDriver({ database: {} as never })).toThrowError(
261 InvalidPersistedCollectionConfigError,
262 )
263})