@tldraw/sync-core 4.2.2 → 4.2.3

package/src/lib/NodeSqliteSyncWrapper.integration.test.ts

@@ -1,270 +0,0 @@
-import { DatabaseSync } from 'node:sqlite'
-import { RecordId, StoreSchema } from 'tldraw'
-import { beforeEach, describe, expect, it } from 'vitest'
-import { NodeSqliteWrapper } from './NodeSqliteWrapper'
-import { migrateSqliteSyncStorage, SQLiteSyncStorage } from './SQLiteSyncStorage'
-import { RoomSnapshot } from './TLSyncRoom'
-
-// Simple record type for testing
-interface TestRecord {
-	id: RecordId<TestRecord>
-	typeName: string
-	name: string
-	value: number
-}
-
-type ID = RecordId<TestRecord>
-
-// SQLiteSyncStorage uses multi-statement DDL in constructor which node:sqlite
-// doesn't support (prepare() only handles one statement). We need to initialize
-// the tables separately before creating the storage.
-function initializeTables(db: DatabaseSync) {
-	migrateSqliteSyncStorage(new NodeSqliteWrapper(db))
-}
-
-const defaultSnapshot: RoomSnapshot = {
-	documents: [],
-	tombstones: {},
-	schema: StoreSchema.create({}).serialize(),
-}
-
-describe('NodeSqliteSyncWrapper + SQLiteSyncStorage integration', () => {
-	let db: DatabaseSync
-	let sql: NodeSqliteWrapper
-	let storage: SQLiteSyncStorage<TestRecord>
-
-	beforeEach(() => {
-		db = new DatabaseSync(':memory:')
-		initializeTables(db)
-		sql = new NodeSqliteWrapper(db)
-		// Pass undefined snapshot since we already initialized the tables
-		storage = new SQLiteSyncStorage<TestRecord>({
-			sql,
-			snapshot: defaultSnapshot,
-		})
-	})
-
-	describe('basic operations', () => {
-		it('can set and get a record', () => {
-			const record: TestRecord = { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 }
-
-			storage.transaction((txn) => {
-				txn.set(record.id, record)
-			})
-
-			const result = storage.transaction((txn) => txn.get('test-1'))
-			expect(result.result).toEqual(record)
-		})
-
-		it('can delete a record', () => {
-			const record: TestRecord = { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 }
-
-			storage.transaction((txn) => {
-				txn.set(record.id, record)
-			})
-
-			storage.transaction((txn) => {
-				txn.delete('test-1')
-			})
-
-			const result = storage.transaction((txn) => txn.get('test-1'))
-			expect(result.result).toBeUndefined()
-		})
-
-		it('increments clock on mutations', () => {
-			expect(storage.getClock()).toBe(0)
-
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			expect(storage.getClock()).toBe(1)
-
-			storage.transaction((txn) => {
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			expect(storage.getClock()).toBe(2)
-		})
-
-		it('only increments clock once per transaction', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-				txn.set('test-3', { id: 'test-3' as ID, typeName: 'test', name: 'Charlie', value: 300 })
-			})
-
-			expect(storage.getClock()).toBe(1)
-		})
-	})
-
-	describe('iteration', () => {
-		it('can iterate over entries', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const entries = storage.transaction((txn) => [...txn.entries()])
-			expect(entries.result).toHaveLength(2)
-			expect(entries.result.map(([id]) => id).sort()).toEqual(['test-1', 'test-2'])
-		})
-
-		it('can iterate over keys', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const keys = storage.transaction((txn) => [...txn.keys()])
-			expect(keys.result.sort()).toEqual(['test-1', 'test-2'])
-		})
-
-		it('can iterate over values', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const values = storage.transaction((txn) => [...txn.values()])
-			expect(values.result).toHaveLength(2)
-			expect(values.result.map((v) => v.name).sort()).toEqual(['Alice', 'Bob'])
-		})
-	})
-
-	describe('snapshots', () => {
-		it('can get a snapshot', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const snapshot = storage.getSnapshot()
-
-			expect(snapshot.documentClock).toBe(1)
-			expect(snapshot.documents).toHaveLength(1)
-			expect(snapshot.documents[0].state).toEqual({
-				id: 'test-1',
-				typeName: 'test',
-				name: 'Alice',
-				value: 100,
-			})
-			expect(snapshot.schema).toEqual(defaultSnapshot.schema)
-		})
-
-		it('includes tombstones in snapshot', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			storage.transaction((txn) => {
-				txn.delete('test-1')
-			})
-
-			const snapshot = storage.getSnapshot()
-
-			expect(snapshot.documents).toHaveLength(0)
-			expect(snapshot.tombstones).toEqual({ 'test-1': 2 })
-		})
-	})
-
-	describe('getChangesSince', () => {
-		it('returns changes since a given clock', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const clock1 = storage.getClock()
-
-			storage.transaction((txn) => {
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const changes = storage.transaction((txn) => txn.getChangesSince(clock1))
-
-			expect(changes.result?.diff.puts).toHaveProperty('test-2')
-			expect(changes.result?.diff.puts).not.toHaveProperty('test-1')
-		})
-
-		it('includes deletes in changes', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const clock1 = storage.getClock()
-
-			storage.transaction((txn) => {
-				txn.delete('test-1')
-			})
-
-			const changes = storage.transaction((txn) => txn.getChangesSince(clock1))
-
-			expect(changes.result?.diff.deletes).toContain('test-1')
-		})
-
-		it('returns undefined when no changes', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const clock = storage.getClock()
-
-			const changes = storage.transaction((txn) => txn.getChangesSince(clock))
-
-			expect(changes.result).toBeUndefined()
-		})
-	})
-
-	describe('transaction rollback', () => {
-		it('rolls back on error', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			expect(() => {
-				storage.transaction((txn) => {
-					txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-					throw new Error('oops')
-				})
-			}).toThrow('oops')
-
-			// test-2 should not exist
-			const result = storage.transaction((txn) => txn.get('test-2'))
-			expect(result.result).toBeUndefined()
-
-			// test-1 should still exist
-			const result1 = storage.transaction((txn) => txn.get('test-1'))
-			expect(result1.result?.name).toBe('Alice')
-		})
-	})
-
-	describe('onChange', () => {
-		it('notifies on changes', async () => {
-			const changes: { id?: string; documentClock: number }[] = []
-			storage.onChange((change) => {
-				changes.push(change)
-			})
-
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			// onChange uses microtask, so wait for it
-			await new Promise((resolve) => setTimeout(resolve, 0))
-
-			expect(changes).toHaveLength(1)
-			expect(changes[0].documentClock).toBe(1)
-		})
-	})
-
-	describe('hasBeenInitialized', () => {
-		it('returns true for initialized storage', () => {
-			expect(SQLiteSyncStorage.hasBeenInitialized(sql)).toBe(true)
-		})
-
-		it('returns false for uninitialized storage', () => {
-			const freshDb = new DatabaseSync(':memory:')
-			const freshWrapper = new NodeSqliteWrapper(freshDb)
-			expect(SQLiteSyncStorage.hasBeenInitialized(freshWrapper)).toBe(false)
-		})
-	})
-})

package/src/lib/NodeSqliteSyncWrapper.test.ts

@@ -1,272 +0,0 @@
-import { DatabaseSync } from 'node:sqlite'
-import { beforeEach, describe, expect, it } from 'vitest'
-import { NodeSqliteWrapper } from './NodeSqliteWrapper'
-
-describe('NodeSqliteSyncWrapper', () => {
-	let db: DatabaseSync
-	let wrapper: NodeSqliteWrapper
-
-	beforeEach(() => {
-		db = new DatabaseSync(':memory:')
-		wrapper = new NodeSqliteWrapper(db)
-		wrapper.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT, value INTEGER)')
-	})
-
-	describe('exec', () => {
-		it('executes DDL statements', () => {
-			wrapper.exec('CREATE TABLE another (id INTEGER PRIMARY KEY)')
-			// Verify table exists by inserting
-			wrapper.prepare('INSERT INTO another (id) VALUES (?)').run(1)
-			const results = wrapper.prepare<{ id: number }>('SELECT * FROM another').all()
-			expect(results).toEqual([{ id: 1 }])
-		})
-
-		it('executes multi-statement DDL', () => {
-			wrapper.exec(`
-				CREATE TABLE t1 (id INTEGER PRIMARY KEY);
-				CREATE TABLE t2 (id INTEGER PRIMARY KEY);
-				CREATE TABLE t3 (id INTEGER PRIMARY KEY)
-			`)
-			// Verify all tables exist
-			wrapper.prepare('INSERT INTO t1 (id) VALUES (?)').run(1)
-			wrapper.prepare('INSERT INTO t2 (id) VALUES (?)').run(2)
-			wrapper.prepare('INSERT INTO t3 (id) VALUES (?)').run(3)
-			expect(wrapper.prepare<{ id: number }>('SELECT * FROM t1').all()).toEqual([{ id: 1 }])
-			expect(wrapper.prepare<{ id: number }>('SELECT * FROM t2').all()).toEqual([{ id: 2 }])
-			expect(wrapper.prepare<{ id: number }>('SELECT * FROM t3').all()).toEqual([{ id: 3 }])
-		})
-	})
-
-	describe('prepare', () => {
-		describe('all()', () => {
-			it('returns all results as an array', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-
-				const results = wrapper
-					.prepare<{ id: number; name: string; value: number }>('SELECT * FROM test ORDER BY id')
-					.all()
-
-				expect(results).toEqual([
-					{ id: 1, name: 'alice', value: 100 },
-					{ id: 2, name: 'bob', value: 200 },
-				])
-			})
-
-			it('handles queries with bindings', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-
-				const results = wrapper
-					.prepare<{ name: string }>('SELECT name FROM test WHERE value > ?')
-					.all(150)
-
-				expect(results).toEqual([{ name: 'bob' }])
-			})
-
-			it('returns empty array for DML statements', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-
-				const stmt = wrapper.prepare('UPDATE test SET value = ? WHERE id = ?')
-				expect(stmt.all(999, 1)).toEqual([])
-
-				// Verify the update happened
-				const result = wrapper
-					.prepare<{ value: number }>('SELECT value FROM test WHERE id = ?')
-					.all(1)
-				expect(result).toEqual([{ value: 999 }])
-			})
-
-			it('handles INSERT with RETURNING clause', () => {
-				const results = wrapper
-					.prepare<{
-						id: number
-						name: string
-					}>('INSERT INTO test (name, value) VALUES (?, ?) RETURNING id, name')
-					.all('charlie', 300)
-
-				expect(results).toHaveLength(1)
-				expect(results[0].name).toBe('charlie')
-				expect(typeof results[0].id).toBe('number')
-			})
-		})
-
-		describe('iterate()', () => {
-			it('returns results via iteration', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-
-				const stmt = wrapper.prepare<{ id: number; name: string; value: number }>(
-					'SELECT * FROM test ORDER BY id'
-				)
-				const results: { id: number; name: string; value: number }[] = []
-				for (const row of stmt.iterate()) {
-					results.push(row)
-				}
-
-				expect(results).toEqual([
-					{ id: 1, name: 'alice', value: 100 },
-					{ id: 2, name: 'bob', value: 200 },
-				])
-			})
-
-			it('handles queries with bindings', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(3, 'carol', 300)
-
-				const results: { name: string }[] = []
-				for (const row of wrapper
-					.prepare<{ name: string }>('SELECT name FROM test WHERE value > ?')
-					.iterate(150)) {
-					results.push(row)
-				}
-
-				expect(results).toEqual([{ name: 'bob' }, { name: 'carol' }])
-			})
-		})
-
-		describe('run()', () => {
-			it('executes DML without returning results', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-
-				// Verify the insert happened
-				const results = wrapper.prepare<{ id: number }>('SELECT id FROM test').all()
-				expect(results).toEqual([{ id: 1 }])
-			})
-
-			it('executes UPDATE', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('UPDATE test SET value = ? WHERE id = ?').run(999, 1)
-
-				const results = wrapper
-					.prepare<{ value: number }>('SELECT value FROM test WHERE id = ?')
-					.all(1)
-				expect(results).toEqual([{ value: 999 }])
-			})
-
-			it('executes DELETE', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-				wrapper.prepare('DELETE FROM test WHERE id = ?').run(1)
-
-				const results = wrapper.prepare<{ id: number }>('SELECT id FROM test').all()
-				expect(results).toEqual([{ id: 2 }])
-			})
-		})
-
-		describe('prepared statement reuse', () => {
-			it('can be reused with different bindings', () => {
-				const insert = wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)')
-				insert.run(1, 'alice', 100)
-				insert.run(2, 'bob', 200)
-				insert.run(3, 'carol', 300)
-
-				const results = wrapper.prepare<{ id: number }>('SELECT id FROM test ORDER BY id').all()
-				expect(results).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }])
-			})
-
-			it('iterate can be called multiple times', () => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-
-				const stmt = wrapper.prepare<{ id: number }>('SELECT id FROM test ORDER BY id')
-
-				// First iteration
-				const results1: number[] = []
-				for (const row of stmt.iterate()) {
-					results1.push(row.id)
-				}
-
-				// Second iteration
-				const results2: number[] = []
-				for (const row of stmt.iterate()) {
-					results2.push(row.id)
-				}
-
-				expect(results1).toEqual([1, 2])
-				expect(results2).toEqual([1, 2])
-			})
-		})
-
-		it('only executes first statement in multi-statement SQL (node:sqlite limitation)', () => {
-			// node:sqlite's prepare() silently ignores statements after the first semicolon
-			wrapper.prepare('INSERT INTO test (id) VALUES (1); INSERT INTO test (id) VALUES (2)').run()
-
-			// Only the first statement was executed
-			const results = wrapper.prepare<{ id: number }>('SELECT id FROM test').all()
-			expect(results).toEqual([{ id: 1 }])
-		})
-
-		it('handles string with semicolon in value (not multi-statement)', () => {
-			wrapper
-				.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)')
-				.run(1, 'hello; world', 100)
-
-			const results = wrapper.prepare<{ name: string }>('SELECT name FROM test').all()
-			expect(results).toEqual([{ name: 'hello; world' }])
-		})
-	})
-
-	describe('transaction', () => {
-		it('commits on success', () => {
-			wrapper.transaction(() => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(2, 'bob', 200)
-			})
-
-			const results = wrapper.prepare<{ id: number }>('SELECT id FROM test ORDER BY id').all()
-			expect(results).toEqual([{ id: 1 }, { id: 2 }])
-		})
-
-		it('rolls back on error', () => {
-			expect(() => {
-				wrapper.transaction(() => {
-					wrapper
-						.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)')
-						.run(1, 'alice', 100)
-					throw new Error('oops')
-				})
-			}).toThrow('oops')
-
-			const results = wrapper.prepare('SELECT * FROM test').all()
-			expect(results).toEqual([])
-		})
-
-		it('returns the callback result', () => {
-			const result = wrapper.transaction(() => {
-				wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-				return 'done'
-			})
-
-			expect(result).toBe('done')
-		})
-
-		it('supports nested reads within transaction', () => {
-			wrapper.prepare('INSERT INTO test (id, name, value) VALUES (?, ?, ?)').run(1, 'alice', 100)
-
-			const result = wrapper.transaction(() => {
-				const rows = wrapper
-					.prepare<{ value: number }>('SELECT value FROM test WHERE id = ?')
-					.all(1)
-				wrapper.prepare('UPDATE test SET value = ? WHERE id = ?').run(rows[0].value + 50, 1)
-				return wrapper.prepare<{ value: number }>('SELECT value FROM test WHERE id = ?').all(1)[0]
-					.value
-			})
-
-			expect(result).toBe(150)
-		})
-
-		it('re-throws the original error after rollback', () => {
-			const customError = new Error('custom error')
-
-			try {
-				wrapper.transaction(() => {
-					throw customError
-				})
-			} catch (e) {
-				expect(e).toBe(customError)
-			}
-		})
-	})
-})

package/src/lib/NodeSqliteWrapper.ts

@@ -1,99 +0,0 @@
-import {
-	type TLSqliteInputValue,
-	type TLSqliteRow,
-	type TLSyncSqliteStatement,
-	type TLSyncSqliteWrapper,
-	type TLSyncSqliteWrapperConfig,
-} from './SQLiteSyncStorage'
-
-/**
- * Minimal interface for a synchronous SQLite database.
- *
- * This interface is compatible with:
- * - `node:sqlite` DatabaseSync (Node.js 22.5+)
- * - `better-sqlite3` Database
- *
- * Any SQLite library that provides synchronous `exec` and `prepare` methods
- * with the signatures below can be used with {@link NodeSqliteWrapper}.
- *
- * @public
- */
-export interface SyncSqliteDatabase {
-	/** Execute raw SQL without returning results */
-	exec(sql: string): void
-	/** Prepare a statement for execution */
-	prepare(sql: string): {
-		iterate(...params: unknown[]): IterableIterator<unknown>
-		all(...params: unknown[]): unknown[]
-		run(...params: unknown[]): unknown
-	}
-}
-
-/**
- * A wrapper around synchronous SQLite databases that implements TLSyncSqliteWrapper.
- * Works with both `node:sqlite` DatabaseSync (Node.js 22.5+) and `better-sqlite3` Database.
- *
- * Use this wrapper with SQLiteSyncStorage to persist tldraw sync state to a SQLite database
- * in Node.js environments.
- *
- * @example
- * ```ts
- * // With node:sqlite (Node.js 22.5+)
- * import { DatabaseSync } from 'node:sqlite'
- * import { SQLiteSyncStorage, NodeSqliteWrapper } from '@tldraw/sync-core'
- *
- * const db = new DatabaseSync(':memory:')
- * const sql = new NodeSqliteWrapper(db)
- * const storage = new SQLiteSyncStorage({ sql })
- * ```
- *
- * @example
- * ```ts
- * // With better-sqlite3
- * import Database from 'better-sqlite3'
- * import { SQLiteSyncStorage, NodeSqliteWrapper } from '@tldraw/sync-core'
- *
- * const db = new Database(':memory:')
- * const sql = new NodeSqliteWrapper(db)
- * const storage = new SQLiteSyncStorage({ sql })
- * ```
- *
- * @example
- * ```ts
- * // With table prefix to avoid conflicts with other tables
- * const sql = new NodeSqliteWrapper(db, { tablePrefix: 'tldraw_' })
- * // Creates tables: tldraw_documents, tldraw_tombstones, tldraw_metadata
- * ```
- *
- * @public
- */
-export class NodeSqliteWrapper implements TLSyncSqliteWrapper {
-	constructor(
-		private db: SyncSqliteDatabase,
-		public config?: TLSyncSqliteWrapperConfig
-	) {}
-
-	exec(sql: string): void {
-		this.db.exec(sql)
-	}
-
-	prepare<
-		TResult extends TLSqliteRow | void = void,
-		TParams extends TLSqliteInputValue[] = TLSqliteInputValue[],
-	>(sql: string): TLSyncSqliteStatement<TResult, TParams> {
-		return this.db.prepare(sql) as unknown as TLSyncSqliteStatement<TResult, TParams>
-	}
-
-	transaction<T>(callback: () => T): T {
-		this.db.exec('BEGIN')
-		let result: T
-		try {
-			result = callback()
-		} catch (e) {
-			this.db.exec('ROLLBACK')
-			throw e
-		}
-		this.db.exec('COMMIT')
-		return result
-	}
-}