@tldraw/sync-core 4.2.0 → 4.2.2

package/src/test/TestServer.ts

@@ -1,11 +1,22 @@
 import { StoreSchema, UnknownRecord } from '@tldraw/store'
+import { InMemorySyncStorage } from '../lib/InMemorySyncStorage'
 import { RoomSnapshot, TLSyncRoom } from '../lib/TLSyncRoom'
 import { TestSocketPair } from './TestSocketPair'
 
 export class TestServer<R extends UnknownRecord, P = unknown> {
 	room: TLSyncRoom<R, undefined>
+	storage: InMemorySyncStorage<R>
 	constructor(schema: StoreSchema<R, P>, snapshot?: RoomSnapshot) {
-		this.room = new TLSyncRoom<R, undefined>({ schema, snapshot })
+		// Use provided snapshot or create an empty one with the current schema
+		this.storage = new InMemorySyncStorage<R>({
+			snapshot: snapshot ?? {
+				documents: [],
+				clock: 0,
+				documentClock: 0,
+				schema: schema.serialize(),
+			},
+		})
+		this.room = new TLSyncRoom<R, undefined>({ schema, storage: this.storage })
 	}
 
 	connect(socketPair: TestSocketPair<R>): void {

package/src/test/customMessages.test.ts

@@ -12,7 +12,7 @@ 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 store = new Store<any, any>({ schema, props: {} })
 
 		const sessionId = 'test-session-1'
 		const server = new TestServer(schema)

package/src/test/presenceMode.test.ts

@@ -97,21 +97,21 @@ test('presence is pushed on change when mode is full', () => {
 	const session = t.server.room.sessions.values().next().value
 	expect(session).toBeDefined()
 	expect(session?.presenceId).toBeDefined()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 11 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 11,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 12,
 	})
@@ -128,21 +128,21 @@ test('presence is only pushed once on connect when mode is solo', () => {
 	const session = t.server.room.sessions.values().next().value
 	expect(session).toBeDefined()
 	expect(session?.presenceId).toBeDefined()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 11 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).not.toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
 		name: 'bob',
 		age: 11,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).not.toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
 		name: 'bob',
 		age: 12,
 	})

package/src/test/syncFuzz.test.ts

@@ -1,7 +1,5 @@
 import {
 	Editor,
-	TLArrowBinding,
-	TLArrowShape,
 	TLRecord,
 	TLStore,
 	computed,
@@ -111,9 +109,9 @@ let totalNumShapes = 0
 let totalNumPages = 0
 
 function arrowsAreSound(editor: Editor) {
-	const arrows = editor.getCurrentPageShapes().filter((s): s is TLArrowShape => s.type === 'arrow')
+	const arrows = editor.getCurrentPageShapes().filter((s) => s.type === 'arrow')
 	for (const arrow of arrows) {
-		const bindings = editor.getBindingsFromShape<TLArrowBinding>(arrow, 'arrow')
+		const bindings = editor.getBindingsFromShape(arrow, 'arrow')
 		const terminalsSeen = new Set()
 		for (const binding of bindings) {
 			if (terminalsSeen.has(binding.props.terminal)) {

package/src/test/upgradeDowngrade.test.ts

@@ -228,11 +228,11 @@ test('the server can handle receiving v1 stuff from the client', () => {
 	t.oldClient.store.put([user])
 	t.flush()
 
-	expect(t.server.room.documents.get(user.id)?.state).toMatchObject({
+	expect(t.server.storage.documents.get(user.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: null,
 	})
-	expect(t.server.room.documents.get(user.id)?.state).not.toMatchObject({
+	expect(t.server.storage.documents.get(user.id)?.state).not.toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
@@ -254,7 +254,7 @@ test('the server can send v2 stuff to the v1 client', () => {
 	t.newClient.store.put([user])
 	t.flush()
 
-	expect(t.server.room.documents.get(user.id)?.state).toMatchObject({
+	expect(t.server.storage.documents.get(user.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: '2022-01-09',
 	})
@@ -287,14 +287,14 @@ test('the server will run schema migrations on a snapshot', () => {
 		schemaV3
 	)
 
-	expect(t.server.room.documents.get(bob.id)?.state).toMatchObject({
+	expect(t.server.storage.documents.get(bob.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: null,
 	})
-	expect(t.server.room.documents.get(joe.id)).toBeUndefined()
+	expect(t.server.storage.documents.get(joe.id)).toBeUndefined()
 
 	// there should be someone named steve
-	const snapshot = t.server.room.getSnapshot()
+	const snapshot = t.server.storage.getSnapshot()
 	expect(snapshot.documents.find((u: any) => u.state.name === 'steve')).toBeDefined()
 })
 
@@ -309,7 +309,7 @@ test('clients will receive updates from a snapshot migration upon connection', (
 	t.newClient.store.put([bob, joe])
 	t.flush()
 
-	const snapshot = t.server.room.getSnapshot()
+	const snapshot = t.server.storage.getSnapshot()
 
 	t.oldSocketPair.disconnect()
 	t.newSocketPair.disconnect()
@@ -333,7 +333,7 @@ test('clients will receive updates from a snapshot migration upon connection', (
 	newServer.room.handleMessage(id, {
 		type: 'connect',
 		connectRequestId: 'test',
-		lastServerClock: snapshot.clock,
+		lastServerClock: snapshot.documentClock ?? snapshot.clock ?? 0,
 		protocolVersion: getTlsyncProtocolVersion(),
 		schema: schemaV3.serialize(),
 	})
@@ -670,6 +670,288 @@ describe('when the client is too old', () => {
 	})
 })
 
+describe('migration failure during push (TLSyncError handling)', () => {
+	let consoleSpy: ReturnType<typeof vi.spyOn>
+	beforeEach(() => {
+		consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+	})
+	afterEach(() => {
+		consoleSpy.mockRestore()
+	})
+
+	// Create a schema where migrations will fail during push
+	const UserVersionsWithFailure = createMigrationIds('com.tldraw.user.failure', {
+		AddNickname: 1,
+	} as const)
+
+	interface UserWithNickname extends BaseRecord<'user_fail', RecordId<UserWithNickname>> {
+		name: string
+		nickname: string
+	}
+
+	const UserWithNicknameType = createRecordType<UserWithNickname>('user_fail', {
+		scope: 'document',
+		validator: { validate: (value) => value as UserWithNickname },
+	})
+
+	interface UserWithoutNickname extends BaseRecord<'user_fail', RecordId<UserWithoutNickname>> {
+		name: string
+	}
+
+	const UserWithoutNicknameType = createRecordType<UserWithoutNickname>('user_fail', {
+		scope: 'document',
+		validator: { validate: (value) => value as UserWithoutNickname },
+	})
+
+	// Server schema with migration that throws on specific conditions
+	// - up() throws when name === 'FAIL_UP_MIGRATION'
+	// - down() throws when nickname === 'FAIL_DOWN_MIGRATION'
+	const serverSchemaWithThrowingMigration = StoreSchema.create<UserWithNickname>(
+		{ user_fail: UserWithNicknameType },
+		{
+			migrations: [
+				createRecordMigrationSequence({
+					sequenceId: 'com.tldraw.user.failure',
+					recordType: 'user_fail',
+					sequence: [
+						{
+							id: UserVersionsWithFailure.AddNickname,
+							up(record: any) {
+								// Simulate UP migration failure for specific data
+								if (record.name === 'FAIL_UP_MIGRATION') {
+									throw new Error('UP migration intentionally failed for testing')
+								}
+								return {
+									...record,
+									nickname: record.name.toUpperCase(),
+								}
+							},
+							down(record: any) {
+								// Simulate DOWN migration failure for specific data
+								if (record.nickname === 'FAIL_DOWN_MIGRATION') {
+									throw new Error('DOWN migration intentionally failed for testing')
+								}
+								const { nickname: _, ...rest } = record
+								return rest
+							},
+						},
+					],
+				}),
+			],
+		}
+	)
+
+	// Client schema (old version without nickname)
+	const clientSchemaWithoutNickname = StoreSchema.create<UserWithoutNickname>(
+		{ user_fail: UserWithoutNicknameType },
+		{
+			migrations: [
+				createMigrationSequence({
+					sequenceId: 'com.tldraw.user.failure',
+					sequence: [],
+					retroactive: true,
+				}),
+			],
+		}
+	)
+
+	it('rejects session when addDocument UP migration throws during PUT', () => {
+		const server = new TestServer(serverSchemaWithThrowingMigration)
+
+		const sessionId = 'failing-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema - should succeed since migration has down function
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Push a record that will cause the UP migration to throw
+		const failingRecord = UserWithoutNicknameType.create({
+			id: UserWithoutNicknameType.createId('fail'),
+			name: 'FAIL_UP_MIGRATION', // This name triggers the UP throw
+		})
+
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[failingRecord.id]: [RecordOpType.Put, failingRecord as any],
+			},
+		})
+
+		// Session should be rejected due to migration failure (TLSyncError)
+		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
+
+	it('successfully migrates records when migration does not throw', () => {
+		const server = new TestServer(serverSchemaWithThrowingMigration)
+
+		const sessionId = 'successful-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Push a record that will NOT cause the migration to throw
+		const validRecord = UserWithoutNicknameType.create({
+			id: UserWithoutNicknameType.createId('valid'),
+			name: 'ValidName', // This name does not trigger the throw
+		})
+
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[validRecord.id]: [RecordOpType.Put, validRecord as any],
+			},
+		})
+
+		// Session should still be connected
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+
+		// Record should be migrated and stored
+		const storedRecord = server.storage.documents.get(validRecord.id)?.state as UserWithNickname
+		expect(storedRecord).toBeDefined()
+		expect(storedRecord.nickname).toBe('VALIDNAME') // Uppercase from migration
+	})
+
+	it('rejects session when patchDocument DOWN migration throws', () => {
+		// Create a server with a document that has a nickname that will fail DOWN migration
+		const existingUser = UserWithNicknameType.create({
+			id: UserWithNicknameType.createId('existing_down_fail'),
+			name: 'ExistingUser',
+			nickname: 'FAIL_DOWN_MIGRATION', // This nickname triggers the DOWN throw
+		})
+
+		const server = new TestServer(serverSchemaWithThrowingMigration, {
+			clock: 10,
+			documents: [{ state: existingUser, lastChangedClock: 10 }],
+			schema: serverSchemaWithThrowingMigration.serialize(),
+			tombstones: {},
+		})
+
+		const sessionId = 'patch-down-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 10,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Patch the existing record - the DOWN migration will fail because nickname is 'FAIL_DOWN_MIGRATION'
+		// This tests line 951 in TLSyncRoom.ts
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[existingUser.id]: [RecordOpType.Patch, { name: [ValueOpType.Put, 'NewName'] }],
+			},
+		})
+
+		// Session should be rejected due to DOWN migration failure
+		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
+
+	it('rejects session when patchDocument UP migration throws (after successful DOWN migration)', () => {
+		// Create a server with a document that will pass DOWN migration but fail UP migration
+		const existingUser = UserWithNicknameType.create({
+			id: UserWithNicknameType.createId('existing_up_fail'),
+			name: 'ExistingUser',
+			nickname: 'EXISTINGUSER', // Normal nickname, DOWN migration will succeed
+		})
+
+		const server = new TestServer(serverSchemaWithThrowingMigration, {
+			clock: 10,
+			documents: [{ state: existingUser, lastChangedClock: 10 }],
+			schema: serverSchemaWithThrowingMigration.serialize(),
+			tombstones: {},
+		})
+
+		const sessionId = 'patch-up-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 10,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Patch the existing record - changes the name to 'FAIL_UP_MIGRATION'
+		// 1. DOWN migration: {name: 'ExistingUser', nickname: 'EXISTINGUSER'} -> {name: 'ExistingUser'} (succeeds)
+		// 2. Patch applied: {name: 'ExistingUser'} -> {name: 'FAIL_UP_MIGRATION'}
+		// 3. UP migration: {name: 'FAIL_UP_MIGRATION'} -> THROWS
+		// This tests line 972 in TLSyncRoom.ts
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[existingUser.id]: [RecordOpType.Patch, { name: [ValueOpType.Put, 'FAIL_UP_MIGRATION'] }],
+			},
+		})
+
+		// Session should be rejected due to UP migration failure during patch
+		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
+})
+
 describe('when the client is the same version', () => {
 	function setup() {
 		const steve = UserV2.create({

package/src/test/validation.test.ts

@@ -50,7 +50,12 @@ const schemaWithoutValidator = StoreSchema.create<Book | Presence>({
 })
 
 const disposables: Array<() => void> = []
+let consoleSpy: ReturnType<typeof vi.spyOn>
+beforeEach(() => {
+	consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+})
 afterEach(() => {
+	consoleSpy.mockRestore()
 	for (const dispose of disposables) {
 		dispose()
 	}
@@ -95,7 +100,7 @@ async function makeTestInstance() {
 it('rejects invalid put operations that create a new document', async () => {
 	const { client, flush, onSyncError, server } = await makeTestInstance()
 
-	const prevServerDocs = server.room.getSnapshot().documents
+	const prevServerDocs = server.storage.getSnapshot().documents
 
 	client.store.put([
 		{
@@ -109,20 +114,20 @@ it('rejects invalid put operations that create a new document', async () => {
 
 	expect(onSyncError).toHaveBeenCalledTimes(1)
 	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.room.getSnapshot().documents).toStrictEqual(prevServerDocs)
+	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
 })
 
 it('rejects invalid put operations that replace an existing document', async () => {
 	const { client, flush, onSyncError, server } = await makeTestInstance()
 
-	let prevServerDocs = server.room.getSnapshot().documents
+	let prevServerDocs = server.storage.getSnapshot().documents
 	const book: Book = { typeName: 'book', id: Book.createId('1'), title: 'Annihilation' }
 	client.store.put([book])
 	await flush()
 
 	expect(onSyncError).toHaveBeenCalledTimes(0)
-	expect(server.room.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
-	prevServerDocs = server.room.getSnapshot().documents
+	expect(server.storage.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
+	prevServerDocs = server.storage.getSnapshot().documents
 
 	client.socket.sendMessage({
 		type: 'push',
@@ -143,13 +148,13 @@ it('rejects invalid put operations that replace an existing document', async ()
 
 	expect(onSyncError).toHaveBeenCalledTimes(1)
 	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.room.getSnapshot().documents).toStrictEqual(prevServerDocs)
+	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
 })
 
 it('rejects invalid update operations', async () => {
 	const { client, flush, onSyncError, server } = await makeTestInstance()
 
-	let prevServerDocs = server.room.getSnapshot().documents
+	let prevServerDocs = server.storage.getSnapshot().documents
 
 	// create the book
 	client.store.put([
@@ -162,8 +167,8 @@ it('rejects invalid update operations', async () => {
 	await flush()
 
 	expect(onSyncError).toHaveBeenCalledTimes(0)
-	expect(server.room.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
-	prevServerDocs = server.room.getSnapshot().documents
+	expect(server.storage.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
+	prevServerDocs = server.storage.getSnapshot().documents
 
 	// update the title to be wrong
 	client.store.put([
@@ -177,5 +182,5 @@ it('rejects invalid update operations', async () => {
 	await flush()
 	expect(onSyncError).toHaveBeenCalledTimes(1)
 	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.room.getSnapshot().documents).toStrictEqual(prevServerDocs)
+	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
 })