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

node-driver.test.ts

151 lines4.9 KB

1import { mkdtempSync, rmSync } from 'node:fs'
2import { tmpdir } from 'node:os'
3import { join } from 'node:path'
4import BetterSqlite3 from 'better-sqlite3'
5import { describe, expect, it } from 'vitest'
6import { runSQLiteDriverContractSuite } from '../../db-sqlite-persistence-core/tests/contracts/sqlite-driver-contract'
7import { BetterSqlite3SQLiteDriver } from '../src/node-driver'
8import type { SQLiteDriverContractHarness } from '../../db-sqlite-persistence-core/tests/contracts/sqlite-driver-contract'
9​
10function createDriverHarness(): SQLiteDriverContractHarness {
11 const tempDirectory = mkdtempSync(join(tmpdir(), `db-node-sqlite-`))
12 const dbPath = join(tempDirectory, `state.sqlite`)
13 const driver = new BetterSqlite3SQLiteDriver({ filename: dbPath })
14​
15 return {
16 driver,
17 cleanup: () => {
18 try {
19 driver.close()
20 } finally {
21 rmSync(tempDirectory, { recursive: true, force: true })
22 }
23 },
24 }
26​
27runSQLiteDriverContractSuite(`better-sqlite3 node driver`, createDriverHarness)
28​
29type SharedDatabaseHarness = {
30 firstDriver: BetterSqlite3SQLiteDriver
31 secondDriver: BetterSqlite3SQLiteDriver
33​
34async function withSharedDatabaseHandle<T>(
35 fn: (harness: SharedDatabaseHarness) => Promise<T>,
36): Promise<T> {
37 const tempDirectory = mkdtempSync(join(tmpdir(), `db-node-sqlite-shared-`))
38 const dbPath = join(tempDirectory, `state.sqlite`)
39 const database = new BetterSqlite3(dbPath)
40​
41 try {
42 return await fn({
43 firstDriver: new BetterSqlite3SQLiteDriver({ database }),
44 secondDriver: new BetterSqlite3SQLiteDriver({ database }),
45 })
46 } finally {
47 database.close()
48 rmSync(tempDirectory, { recursive: true, force: true })
49 }
51​
52/**
53 * The shared contract owns one driver wrapper. This provider-specific law also
54 * covers the supported case where several persistence instances wrap one
55 * better-sqlite3 database handle.
56 *
57 * Known omission: distinct better-sqlite3 connection objects rely on SQLite's
58 * own lock admission and are not modeled as one in-process scheduling queue.
59 */
60describe(`better-sqlite3 shared database handle`, () => {
61 it(`serializes transactions across driver wrappers`, async () => {
62 await withSharedDatabaseHandle(async ({ firstDriver, secondDriver }) => {
63 await firstDriver.exec(`CREATE TABLE events (value INTEGER NOT NULL)`)
64​
65 let releaseHold!: () => void
66 const hold = new Promise<void>((resolve) => {
67 releaseHold = resolve
68 })
69 let signalEntered!: () => void
70 const entered = new Promise<void>((resolve) => {
71 signalEntered = resolve
72 })
73 const firstTransaction = firstDriver.transaction(
74 async (transactionDriver) => {
75 await transactionDriver.run(
76 `INSERT INTO events (value) VALUES (?)`,
77 [1],
78 )
79 signalEntered()
80 await hold
81 await transactionDriver.run(
82 `INSERT INTO events (value) VALUES (?)`,
83 [2],
84 )
85 },
86 )
87​
88 await entered
89 let secondSettled = false
90 const secondTransaction = secondDriver
91 .transaction(async (transactionDriver) => {
92 await transactionDriver.run(
93 `INSERT INTO events (value) VALUES (?)`,
94 [3],
95 )
96 })
97 .then(() => {
98 secondSettled = true
99 })
100 const observed = Promise.allSettled([firstTransaction, secondTransaction])
101​
102 try {
103 await Promise.resolve()
104 expect(secondSettled).toBe(false)
105 releaseHold()
106 await Promise.all([firstTransaction, secondTransaction])
107 } finally {
108 releaseHold()
109 await observed
110 }
111​
112 const rows = await firstDriver.query<{ value: number }>(
113 `SELECT value FROM events ORDER BY rowid ASC`,
114 )
115 expect(rows.map((row) => row.value)).toEqual([1, 2, 3])
116 })
117 })
118​
119 it(`uses savepoints for transactions nested through another wrapper`, async () => {
120 await withSharedDatabaseHandle(async ({ firstDriver, secondDriver }) => {
121 await firstDriver.exec(`CREATE TABLE events (value INTEGER NOT NULL)`)
122​
123 await firstDriver.transaction(async (outerTransactionDriver) => {
124 await outerTransactionDriver.run(
125 `INSERT INTO events (value) VALUES (?)`,
126 [1],
127 )
128​
129 await expect(
130 secondDriver.transaction(async (innerTransactionDriver) => {
131 await innerTransactionDriver.run(
132 `INSERT INTO events (value) VALUES (?)`,
133 [2],
134 )
135 throw new Error(`inner failure`)
136 }),
137 ).rejects.toThrow(`inner failure`)
138​
139 await outerTransactionDriver.run(
140 `INSERT INTO events (value) VALUES (?)`,
141 [3],
142 )
143 })
144​
145 const rows = await firstDriver.query<{ value: number }>(
146 `SELECT value FROM events ORDER BY rowid ASC`,
147 )
148 expect(rows.map((row) => row.value)).toEqual([1, 3])
149 })
150 })
151})