@tldraw/sync-core 3.16.0-internal.51e99e128bd4 → 3.16.0-internal.71f83a8a571b

package/src/test/TLSocketRoom.test.ts

@@ -4,6 +4,7 @@ import { vi } from 'vitest'
 import { WebSocketMinimal } from '../lib/ServerSocketAdapter'
 import { TLSocketRoom } from '../lib/TLSocketRoom'
 import { RecordOpType } from '../lib/diff'
+import { getTlsyncProtocolVersion } from '../lib/protocol'
 
 function getStore() {
 	const schema = createTLSchema()
@@ -266,4 +267,144 @@ describe(TLSocketRoom, () => {
 		await addPage(room)
 		expect(called).toEqual(2)
 	})
+
+	it('sends custom messages', async () => {
+		const json = JSON.stringify
+		const store = getStore()
+		const room = new TLSocketRoom({ initialSnapshot: store.getStoreSnapshot() })
+
+		const sessionId = 'test-session-1'
+		const send = vi.fn()
+
+		// Add session to the room
+		const mockSocket: WebSocketMinimal = { send, close: vi.fn(), readyState: WebSocket.OPEN }
+		room.handleSocketConnect({ sessionId, socket: mockSocket })
+
+		// Send connect message to establish the session
+		const connect = {
+			type: 'connect' as const,
+			connectRequestId: 'connect-1',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: store.schema.serialize(),
+		}
+		room.handleSocketMessage(sessionId, json(connect))
+
+		room.sendCustomMessage(sessionId, 'hello world')
+		expect(send.mock.lastCall).toEqual([json({ type: 'custom', data: 'hello world' })])
+	})
+
+	describe('Room state resetting behavior', () => {
+		it('sets documentClock to oldRoom.clock + 1 when resetting room state', () => {
+			const store = getStore()
+			store.ensureStoreIsUsable()
+			const room = new TLSocketRoom({
+				initialSnapshot: store.getStoreSnapshot(),
+			})
+
+			// Load a snapshot to increment the clock
+			const snapshot = store.getStoreSnapshot()
+			room.loadSnapshot(snapshot)
+
+			const oldClock = room.getCurrentSnapshot().clock
+			expect(oldClock).toBe(1)
+
+			// Reset with a new snapshot
+			const newSnapshot = store.getStoreSnapshot()
+			room.loadSnapshot(newSnapshot)
+
+			const newSnapshotResult = room.getCurrentSnapshot()
+			expect(newSnapshotResult.documentClock).toBe(oldClock + 1)
+			expect(newSnapshotResult.clock).toBe(oldClock + 1)
+		})
+
+		it('updates all documents lastChangedClock when resetting', () => {
+			const store = getStore()
+			store.ensureStoreIsUsable()
+			const room = new TLSocketRoom({
+				initialSnapshot: store.getStoreSnapshot(),
+			})
+
+			// Get initial clock
+			const initialClock = room.getCurrentSnapshot().clock
+
+			// Reset with a new snapshot
+			const newSnapshot = store.getStoreSnapshot()
+			room.loadSnapshot(newSnapshot)
+
+			const result = room.getCurrentSnapshot()
+			expect(result.clock).toBe(initialClock + 1)
+
+			// All documents should have updated lastChangedClock
+			for (const doc of result.documents) {
+				expect(doc.lastChangedClock).toBe(initialClock + 1)
+			}
+		})
+
+		it('preserves existing tombstones with original clock values', async () => {
+			// Create a room with initial state
+			const store = getStore()
+			store.ensureStoreIsUsable()
+			const testPageId = PageRecordType.createId('test_page')
+			store.put([
+				PageRecordType.create({ id: testPageId, name: 'Test Page', index: ZERO_INDEX_KEY }),
+			])
+			const room = new TLSocketRoom({
+				initialSnapshot: store.getStoreSnapshot(),
+			})
+
+			await room.updateStore((store) => {
+				store.delete(testPageId)
+			})
+
+			const deletionClock = room.getCurrentDocumentClock()
+			expect(room.getCurrentSnapshot().tombstones).toEqual({
+				[testPageId]: deletionClock,
+			})
+
+			room.loadSnapshot(room.getCurrentSnapshot())
+
+			expect(room.getCurrentSnapshot().tombstones).toEqual({
+				[testPageId]: deletionClock,
+			})
+
+			expect(room.getCurrentSnapshot().documentClock).toBe(deletionClock + 1)
+		})
+
+		it('handles empty snapshot reset correctly', () => {
+			const store = getStore()
+			// Don't call ensureStoreIsUsable to get an empty snapshot
+			const room = new TLSocketRoom({
+				initialSnapshot: store.getStoreSnapshot(),
+			})
+
+			const oldClock = room.getCurrentSnapshot().clock
+
+			// Reset with empty snapshot
+			const emptySnapshot = store.getStoreSnapshot()
+			room.loadSnapshot(emptySnapshot)
+
+			const result = room.getCurrentSnapshot()
+			expect(result.documentClock).toBe(oldClock + 1)
+			expect(result.clock).toBe(oldClock + 1)
+			expect(result.documents).toHaveLength(0)
+		})
+
+		it('preserves schema when resetting room state', () => {
+			const store = getStore()
+			store.ensureStoreIsUsable()
+			const room = new TLSocketRoom({
+				initialSnapshot: store.getStoreSnapshot(),
+			})
+
+			const originalSchema = room.getCurrentSnapshot().schema
+
+			// Reset with a new snapshot
+			const newSnapshot = store.getStoreSnapshot()
+			room.loadSnapshot(newSnapshot)
+
+			const result = room.getCurrentSnapshot()
+			expect(result.schema).toEqual(originalSchema)
+		})
+	})
 })

package/src/test/TLSyncRoom.test.ts

@@ -44,6 +44,17 @@ const records = [
 ].sort(compareById)
 
 const makeSnapshot = (records: TLRecord[], others: Partial<RoomSnapshot> = {}) => ({
+	documents: records.map((r) => ({ state: r, lastChangedClock: 0 })),
+	clock: 0,
+	documentClock: 0,
+	...others,
+})
+
+// Helper to create legacy snapshots without documentClock field
+const makeLegacySnapshot = (
+	records: TLRecord[],
+	others: Partial<Omit<RoomSnapshot, 'documentClock'>> = {}
+) => ({
 	documents: records.map((r) => ({ state: r, lastChangedClock: 0 })),
 	clock: 0,
 	...others,
@@ -158,7 +169,7 @@ describe('TLSyncRoom', () => {
 
 		const room = new TLSyncRoom({
 			schema,
-			snapshot: makeSnapshot([...records, oldArrow], {
+			snapshot: makeSnapshot([...records, oldArrow as any], {
 				schema: oldSerializedSchema,
 			}),
 		})
@@ -720,4 +731,187 @@ describe('isReadonly', () => {
 		}
 	`)
 	})
+
+	describe('Backward compatibility with existing snapshots', () => {
+		it('can load snapshot without documentClock field', () => {
+			const legacySnapshot = makeLegacySnapshot(records)
+
+			const room = new TLSyncRoom<TLRecord, undefined>({
+				schema,
+				snapshot: legacySnapshot,
+			})
+
+			// Room should load successfully without errors
+			expect(room.getSnapshot().documents.length).toBe(2)
+
+			// documentClock should be calculated from existing data
+			const snapshot = room.getSnapshot()
+			expect(snapshot.documentClock).toBe(0) // max lastChangedClock from documents
+		})
+
+		it('calculates documentClock correctly from documents with different lastChangedClock values', () => {
+			const legacySnapshot = makeLegacySnapshot(records, {
+				documents: [
+					{ state: records[0], lastChangedClock: 5 },
+					{ state: records[1], lastChangedClock: 10 },
+				],
+			})
+
+			const room = new TLSyncRoom<TLRecord, undefined>({
+				schema,
+				snapshot: legacySnapshot,
+			})
+
+			const snapshot = room.getSnapshot()
+			expect(snapshot.documentClock).toBe(10) // max lastChangedClock
+		})
+
+		it('calculates documentClock correctly from tombstones', () => {
+			const legacySnapshot = makeLegacySnapshot(records, {
+				documents: [{ state: records[0], lastChangedClock: 3 }],
+				tombstones: {
+					'shape:deleted1': 7,
+					'shape:deleted2': 12,
+				},
+			})
+
+			const room = new TLSyncRoom<TLRecord, undefined>({
+				schema,
+				snapshot: legacySnapshot,
+			})
+
+			const snapshot = room.getSnapshot()
+			expect(snapshot.documentClock).toBe(12) // max of document (3) and tombstones (7, 12)
+		})
+
+		it('handles empty snapshot gracefully', () => {
+			const emptyLegacySnapshot = makeLegacySnapshot([], {
+				documents: [],
+				tombstones: {},
+			})
+
+			const room = new TLSyncRoom<TLRecord, undefined>({
+				schema,
+				snapshot: emptyLegacySnapshot,
+			})
+
+			const snapshot = room.getSnapshot()
+			expect(snapshot.documentClock).toBe(0) // no documents or tombstones
+		})
+
+		it('handles snapshot with only tombstones', () => {
+			const legacySnapshot = makeLegacySnapshot([], {
+				documents: [],
+				tombstones: {
+					'shape:deleted1': 5,
+					'shape:deleted2': 8,
+				},
+			})
+
+			const room = new TLSyncRoom<TLRecord, undefined>({
+				schema,
+				snapshot: legacySnapshot,
+			})
+
+			const snapshot = room.getSnapshot()
+			expect(snapshot.documentClock).toBe(8) // max tombstone clock
+		})
+
+		it('preserves explicit documentClock when present', () => {
+			const snapshotWithDocumentClock = makeSnapshot(records, {
+				documentClock: 15,
+			})
+
+			const room = new TLSyncRoom<TLRecord, undefined>({
+				schema,
+				snapshot: snapshotWithDocumentClock,
+			})
+
+			const snapshot = room.getSnapshot()
+			expect(snapshot.documentClock).toBe(15) // should preserve explicit value
+		})
+
+		describe('Document clock initialization logic', () => {
+			it('sets documentClock to room clock when migrations run (didIncrementClock = true)', () => {
+				// Create a schema with a migration that will update documents
+				const schemaWithMigration = createTLSchema({
+					migrations: [
+						{
+							sequenceId: 'test-migration',
+							retroactive: false,
+							sequence: [
+								{
+									id: 'test-migration/1',
+									scope: 'record',
+									filter: (record: any) => record.typeName === 'document',
+									up: (record: any) => {
+										// Modify the record to trigger clock increment
+										return { ...record, meta: { ...record.meta, migrated: true } }
+									},
+								},
+							],
+						},
+					],
+				})
+
+				const snapshotWithDocumentClock = makeSnapshot(records, {
+					documentClock: 5,
+					clock: 10,
+				})
+
+				const onDataChange = vi.fn()
+				const room = new TLSyncRoom<TLRecord, undefined>({
+					schema: schemaWithMigration,
+					snapshot: snapshotWithDocumentClock,
+					onDataChange,
+				})
+
+				// Migration should have run, incrementing the clock
+				expect(room.getSnapshot().clock).toBe(11)
+				expect(room.getSnapshot().documentClock).toBe(11)
+				expect(onDataChange).toHaveBeenCalled()
+			})
+
+			it('preserves documentClock from snapshot when no migrations run (didIncrementClock = false)', () => {
+				const snapshotWithDocumentClock = makeSnapshot(records, {
+					documentClock: 15,
+					clock: 20,
+				})
+
+				const onDataChange = vi.fn()
+				const room = new TLSyncRoom<TLRecord, undefined>({
+					schema,
+					snapshot: snapshotWithDocumentClock,
+					onDataChange,
+				})
+
+				// No migrations should have run
+				expect(room.getSnapshot().documentClock).toBe(15)
+				expect(room.getSnapshot().clock).toBe(20)
+				expect(onDataChange).not.toHaveBeenCalled()
+			})
+
+			it('calculates documentClock when snapshot lacks documentClock field (didIncrementClock = false)', () => {
+				const legacySnapshot = makeLegacySnapshot(records, {
+					documents: [
+						{ state: records[0], lastChangedClock: 7 },
+						{ state: records[1], lastChangedClock: 12 },
+					],
+					clock: 15,
+				})
+
+				const onDataChange = vi.fn()
+				const room = new TLSyncRoom<TLRecord, undefined>({
+					schema,
+					snapshot: legacySnapshot,
+					onDataChange,
+				})
+
+				// Should calculate from existing data
+				expect(room.getSnapshot().documentClock).toBe(12) // max lastChangedClock
+				expect(room.getSnapshot().clock).toBe(15) // clock from snapshot
+				expect(onDataChange).not.toHaveBeenCalled()
+			})
+		})
+	})
 })

package/src/test/TestSocketPair.ts

@@ -28,6 +28,14 @@ export class TestSocketPair<R extends UnknownRecord> {
 		})
 	}
 
+	async flushAllEvents() {
+		await Promise.resolve()
+		while (this.getNeedsFlushing()) {
+			this.flushClientSentEvents()
+			this.flushServerSentEvents()
+		}
+	}
+
 	getNeedsFlushing() {
 		return this.serverSentEventQueue.length > 0 || this.clientSentEventQueue.length > 0
 	}

package/src/test/customMessages.test.ts

@@ -0,0 +1,36 @@
+import { atom, createRecordType, Store, StoreSchema, UnknownRecord } from 'tldraw'
+import { TLSyncClient } from '../lib/TLSyncClient'
+import { TestServer } from './TestServer'
+import { TestSocketPair } from './TestSocketPair'
+
+type Presence = UnknownRecord & { typeName: 'presence' }
+const presenceType = createRecordType<Presence>('presence', {
+	scope: 'presence',
+	validator: { validate: (record) => record as Presence },
+})
+const schema = StoreSchema.create<Presence>({ presence: presenceType })
+
+describe('custom messages', () => {
+	it('sends a message to a client', async () => {
+		const store = new Store({ schema, props: {} })
+
+		const sessionId = 'test-session-1'
+		const server = new TestServer(schema)
+		const socketPair = new TestSocketPair(sessionId, server)
+		socketPair.connect()
+
+		const onCustomMessageReceived = vi.fn()
+		new TLSyncClient({
+			store,
+			socket: socketPair.clientSocket,
+			onCustomMessageReceived,
+			onLoad: vi.fn(),
+			onSyncError: vi.fn(),
+			presence: atom('', null),
+		})
+		await socketPair.flushAllEvents()
+		server.room.sendCustomMessage(sessionId, 'hello world')
+		await socketPair.flushAllEvents()
+		expect(onCustomMessageReceived.mock.lastCall).toEqual(['hello world'])
+	})
+})