@tldraw/sync-core 4.2.0 → 4.2.2

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

@@ -0,0 +1,270 @@
+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

@@ -0,0 +1,272 @@
+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

@@ -0,0 +1,99 @@
+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
+	}
+}

package/src/lib/RoomSession.test.ts

@@ -68,6 +68,7 @@ describe('RoomSession state transitions', () => {
 			isReadonly: initialSession.isReadonly,
 			requiresLegacyRejection: initialSession.requiresLegacyRejection,
 			serializedSchema: mockSerializedSchema,
+			requiresDownMigrations: false,
 			supportsStringAppend: true,
 			lastInteractionTime: Date.now(),
 			debounceTimer: null,

package/src/lib/RoomSession.ts

@@ -132,6 +132,8 @@ export type RoomSession<R extends UnknownRecord, Meta> =
 			state: typeof RoomSessionState.Connected
 			/** Serialized schema information for this connected session */
 			serializedSchema: SerializedSchema
+			/** Whether this session requires down migrations */
+			requiresDownMigrations: boolean
 			/** Timestamp of the last interaction or message from this session */
 			lastInteractionTime: number
 			/** Timer for debouncing operations, if active */