@tldraw/sync-core 4.1.0-next.b6dfe9bccde9 → 4.1.0-next.b9999db71010

package/src/test/chunk.test.ts

@@ -1,4 +1,5 @@
 import { assert } from 'tldraw'
+import { describe, expect, it } from 'vitest'
 import { JsonChunkAssembler, chunk } from '../lib/chunk'
 
 describe('chunk', () => {
@@ -102,7 +103,6 @@ describe('json unchunker', () => {
 		expect(unchunker.handleMessage('{"ok": true}')).toMatchObject({ data: { ok: true } })
 	})
 
-	// todo: test error cases
 	it('returns an error if the json is whack', () => {
 		const chunks = chunk('{"hello": world"}', 5)
 		const unchunker = new JsonChunkAssembler()
@@ -123,7 +123,6 @@ describe('json unchunker', () => {
 	})
 	it('returns an error if one of the chunks was missing', () => {
 		const chunks = chunk('{"hello": world"}', 10)
-		expect(chunks).toHaveLength(3)
 
 		const unchunker = new JsonChunkAssembler()
 		expect(unchunker.handleMessage(chunks[0])).toBeNull()
@@ -138,7 +137,6 @@ describe('json unchunker', () => {
 
 	it('returns an error if the chunk stream ends abruptly', () => {
 		const chunks = chunk('{"hello": world"}', 10)
-		expect(chunks).toHaveLength(3)
 
 		const unchunker = new JsonChunkAssembler()
 		expect(unchunker.handleMessage(chunks[0])).toBeNull()
@@ -166,4 +164,203 @@ describe('json unchunker', () => {
 		// and the next one should be fine
 		expect(unchunker.handleMessage('{"ok": true}')).toMatchObject({ data: { ok: true } })
 	})
+
+	it('handles empty string', () => {
+		const unchunker = new JsonChunkAssembler()
+		const result = unchunker.handleMessage('{}')
+		expect(result).toMatchObject({ data: {}, stringified: '{}' })
+	})
+
+	it('handles complex nested JSON objects', () => {
+		const complexObject = {
+			array: [1, 2, { nested: true }],
+			null: null,
+			boolean: false,
+			number: 3.14,
+			string: 'hello world',
+			unicode: '🎨🗼️📐',
+			deep: {
+				nested: {
+					object: {
+						with: 'many levels',
+					},
+				},
+			},
+		}
+
+		const chunks = chunk(JSON.stringify(complexObject), 50)
+		const unchunker = new JsonChunkAssembler()
+
+		for (const chunk of chunks.slice(0, -1)) {
+			expect(unchunker.handleMessage(chunk)).toBeNull()
+		}
+
+		const result = unchunker.handleMessage(chunks[chunks.length - 1])
+		expect(result).toMatchObject({ data: complexObject })
+	})
+
+	it('handles state reset after error', () => {
+		const unchunker = new JsonChunkAssembler()
+
+		// Start a chunk sequence
+		expect(unchunker.handleMessage('1_hello')).toBeNull()
+
+		// Send malformed chunk to trigger error
+		const result = unchunker.handleMessage('invalid_chunk_format')
+		assert(result && 'error' in result, 'expected error result')
+		expect(result.error.message).toContain('Invalid chunk')
+
+		// Should be able to process normal messages again
+		expect(unchunker.handleMessage('{"test": true}')).toMatchObject({ data: { test: true } })
+	})
+
+	it('returns error for invalid chunk number format', () => {
+		const unchunker = new JsonChunkAssembler()
+		const result = unchunker.handleMessage('abc_invalid_number')
+		assert(result && 'error' in result, 'expected error result')
+		expect(result.error.message).toContain('Invalid chunk')
+	})
+
+	it('handles single chunk with number prefix correctly', () => {
+		const unchunker = new JsonChunkAssembler()
+		const result = unchunker.handleMessage('0_{"single": "chunk"}')
+		expect(result).toMatchObject({
+			data: { single: 'chunk' },
+			stringified: '{"single": "chunk"}',
+		})
+	})
+
+	it('handles chunks with empty data parts', () => {
+		const unchunker = new JsonChunkAssembler()
+
+		expect(unchunker.handleMessage('1_')).toBeNull() // empty first chunk
+		const result = unchunker.handleMessage('0_{"test": true}')
+		expect(result).toMatchObject({ data: { test: true } })
+	})
+
+	it('handles non-JSON string messages that are not chunks', () => {
+		const unchunker = new JsonChunkAssembler()
+		const result = unchunker.handleMessage('not_json_and_not_chunk')
+		assert(result && 'error' in result, 'expected error result')
+		expect(result.error.message).toContain('Invalid chunk')
+	})
+
+	it('handles chunk sequence interrupted by JSON message', () => {
+		const unchunker = new JsonChunkAssembler()
+
+		// Start chunk sequence
+		expect(unchunker.handleMessage('2_hello')).toBeNull()
+
+		// Interrupt with JSON message - should trigger error and reset state
+		const result = unchunker.handleMessage('{"interrupt": true}')
+		assert(result && 'error' in result, 'expected error result')
+		expect(result.error.message).toBe('Unexpected non-chunk message')
+
+		// Should be able to process messages normally again
+		expect(unchunker.handleMessage('{"ok": true}')).toMatchObject({ data: { ok: true } })
+	})
+
+	it('handles duplicate or out-of-order chunk numbers', () => {
+		const unchunker = new JsonChunkAssembler()
+
+		// Start with first chunk
+		expect(unchunker.handleMessage('2_part1')).toBeNull()
+
+		// Send chunk with wrong number (should be 1, not 0)
+		const result = unchunker.handleMessage('0_part3')
+		assert(result && 'error' in result, 'expected error result')
+		expect(result.error.message).toBe('Chunks received in wrong order')
+	})
+
+	it('handles JSON parse error in completed chunk sequence', () => {
+		const unchunker = new JsonChunkAssembler()
+
+		// Send chunks that form invalid JSON when combined
+		expect(unchunker.handleMessage('1_{"invalid":')).toBeNull()
+		const result = unchunker.handleMessage('0_ }')
+
+		assert(result && 'error' in result, 'expected error result')
+		expect(result.error).toBeInstanceOf(Error)
+	})
+})
+
+describe('chunk function edge cases', () => {
+	it('handles empty strings', () => {
+		const result = chunk('', 100)
+		expect(result).toEqual([''])
+	})
+
+	it('handles single character strings', () => {
+		const result = chunk('a', 100)
+		expect(result).toEqual(['a'])
+	})
+
+	it('uses default maxSafeMessageSize when not provided', () => {
+		// Create a string longer than default max size to test chunking
+		const longString = 'x'.repeat(262145) // Larger than 262144 default
+		const result = chunk(longString)
+
+		expect(result.length).toBeGreaterThan(1)
+		expect(result[0]).toMatch(/^\d+_x+$/)
+	})
+
+	it('handles strings exactly at the boundary', () => {
+		const boundaryString = 'x'.repeat(9) // 9 chars fits in 10 char limit
+		const result = chunk(boundaryString, 10)
+
+		expect(result).toEqual([boundaryString])
+	})
+
+	it('handles strings one character over the boundary', () => {
+		const overBoundaryString = 'x'.repeat(11)
+		const result = chunk(overBoundaryString, 10)
+
+		expect(result.length).toBeGreaterThan(1)
+		expect(result[0]).toMatch(/^\d+_x+$/)
+	})
+
+	it('preserves unicode characters correctly', () => {
+		const unicodeString = '🎨'.repeat(10) + '📐'.repeat(10) + '🗼️'.repeat(10)
+		const result = chunk(unicodeString, 20)
+
+		// Verify chunking works with unicode
+		expect(result.length).toBeGreaterThan(1)
+
+		// Reconstruct and verify
+		const reconstructed = result
+			.map((chunk) => {
+				const match = /^(\d+)_(.*)$/.exec(chunk)
+				return match ? match[2] : chunk
+			})
+			.join('')
+
+		expect(reconstructed).toEqual(unicodeString)
+	})
+
+	it('ensures no chunk exceeds maxSafeMessageSize', () => {
+		const maxSize = 15
+		const testString = 'hello world this is a long message'
+		const result = chunk(testString, maxSize)
+
+		for (const chunk of result) {
+			expect(chunk.length).toBeLessThanOrEqual(maxSize)
+		}
+	})
+
+	it('handles very large strings efficiently', () => {
+		const veryLargeString = 'a'.repeat(1000000) // 1MB string
+		const result = chunk(veryLargeString, 10000)
+
+		expect(result.length).toBeGreaterThan(1)
+
+		// Verify reconstruction works
+		const reconstructed = result
+			.map((chunk) => {
+				const match = /^(\d+)_(.*)$/.exec(chunk)
+				return match ? match[2] : chunk
+			})
+			.join('')
+
+		expect(reconstructed).toEqual(veryLargeString)
+	})
 })

package/src/test/diff.test.ts

@@ -1,4 +1,12 @@
-import { applyObjectDiff, diffRecord } from '../lib/diff'
+import { describe, expect, it } from 'vitest'
+import {
+	applyObjectDiff,
+	diffRecord,
+	getNetworkDiff,
+	RecordOpType,
+	ValueOpType,
+	type ObjectDiff,
+} from '../lib/diff'
 
 describe('nested arrays', () => {
 	it('should be patchable at the end', () => {
@@ -187,3 +195,390 @@ test('adding things things to a record', () => {
 
 	expect(applyObjectDiff(a, patch!)).toEqual(b)
 })
+
+describe('getNetworkDiff', () => {
+	it('should return null for empty diff', () => {
+		const diff = { added: {}, updated: {}, removed: {} }
+		expect(getNetworkDiff(diff)).toBeNull()
+	})
+
+	it('should handle added records', () => {
+		const record = { id: 'test:1', type: 'test', data: 'value' }
+		const diff = {
+			added: { 'test:1': record },
+			updated: {},
+			removed: {},
+		}
+
+		const networkDiff = getNetworkDiff(diff)
+		expect(networkDiff).toEqual({
+			'test:1': [RecordOpType.Put, record],
+		})
+	})
+
+	it('should handle removed records', () => {
+		const diff = {
+			added: {},
+			updated: {},
+			removed: { 'test:1': { id: 'test:1', type: 'test' } },
+		}
+
+		const networkDiff = getNetworkDiff(diff)
+		expect(networkDiff).toEqual({
+			'test:1': [RecordOpType.Remove],
+		})
+	})
+
+	it('should handle updated records with patches', () => {
+		const prev = { id: 'test:1', type: 'test', x: 100, y: 200 }
+		const next = { id: 'test:1', type: 'test', x: 150, y: 200 }
+		const diff = {
+			added: {},
+			updated: { 'test:1': [prev, next] },
+			removed: {},
+		}
+
+		const networkDiff = getNetworkDiff(diff)
+		expect(networkDiff).toEqual({
+			'test:1': [RecordOpType.Patch, { x: [ValueOpType.Put, 150] }],
+		})
+	})
+
+	it('should skip updates when no diff exists', () => {
+		const record = { id: 'test:1', type: 'test', x: 100 }
+		const diff = {
+			added: {},
+			updated: { 'test:1': [record, record] },
+			removed: {},
+		}
+
+		const networkDiff = getNetworkDiff(diff)
+		expect(networkDiff).toBeNull()
+	})
+
+	it('should handle mixed operations', () => {
+		const addedRecord = { id: 'test:1', type: 'test', data: 'new' }
+		const prevRecord = { id: 'test:2', type: 'test', x: 100 }
+		const nextRecord = { id: 'test:2', type: 'test', x: 200 }
+		const removedRecord = { id: 'test:3', type: 'test' }
+
+		const diff = {
+			added: { 'test:1': addedRecord },
+			updated: { 'test:2': [prevRecord, nextRecord] },
+			removed: { 'test:3': removedRecord },
+		}
+
+		const networkDiff = getNetworkDiff(diff)
+		expect(networkDiff).toEqual({
+			'test:1': [RecordOpType.Put, addedRecord],
+			'test:2': [RecordOpType.Patch, { x: [ValueOpType.Put, 200] }],
+			'test:3': [RecordOpType.Remove],
+		})
+	})
+})
+
+describe('diffRecord comprehensive tests', () => {
+	it('should return null for identical records', () => {
+		const record = { id: 'test:1', x: 100, y: 200 }
+		expect(diffRecord(record, record)).toBeNull()
+	})
+
+	it('should handle simple property changes', () => {
+		const prev = { id: 'test:1', x: 100, y: 200 }
+		const next = { id: 'test:1', x: 150, y: 200 }
+
+		expect(diffRecord(prev, next)).toEqual({
+			x: [ValueOpType.Put, 150],
+		})
+	})
+
+	it('should handle nested props changes', () => {
+		const prev = { id: 'test:1', props: { color: 'red', size: 'medium' } }
+		const next = { id: 'test:1', props: { color: 'blue', size: 'medium' } }
+
+		expect(diffRecord(prev, next)).toEqual({
+			props: [ValueOpType.Patch, { color: [ValueOpType.Put, 'blue'] }],
+		})
+	})
+
+	it('should handle adding nested props', () => {
+		const prev = { id: 'test:1', props: { color: 'red' } }
+		const next = { id: 'test:1', props: { color: 'red', size: 'large' } }
+
+		expect(diffRecord(prev, next)).toEqual({
+			props: [ValueOpType.Patch, { size: [ValueOpType.Put, 'large'] }],
+		})
+	})
+
+	it('should handle removing nested props', () => {
+		const prev = { id: 'test:1', props: { color: 'red', size: 'large' } }
+		const next = { id: 'test:1', props: { color: 'red' } }
+
+		expect(diffRecord(prev, next)).toEqual({
+			props: [ValueOpType.Patch, { size: [ValueOpType.Delete] }],
+		})
+	})
+
+	it('should handle multiple property changes', () => {
+		const prev = { id: 'test:1', x: 100, y: 200, rotation: 0 }
+		const next = { id: 'test:1', x: 150, y: 250, rotation: 45 }
+
+		expect(diffRecord(prev, next)).toEqual({
+			x: [ValueOpType.Put, 150],
+			y: [ValueOpType.Put, 250],
+			rotation: [ValueOpType.Put, 45],
+		})
+	})
+
+	it('should handle null and undefined values', () => {
+		const prev = { id: 'test:1', optional: 'value', nullable: null }
+		const next = { id: 'test:1', optional: undefined, nullable: 'value' }
+
+		const diff = diffRecord(prev, next)
+		expect(diff).toBeTruthy()
+		expect(diff!.optional).toEqual([ValueOpType.Put, undefined])
+		expect(diff!.nullable).toEqual([ValueOpType.Put, 'value'])
+	})
+})
+
+describe('array diffing comprehensive', () => {
+	describe('simple arrays', () => {
+		it('should handle identical arrays', () => {
+			const prev = { arr: [1, 2, 3] }
+			const next = { arr: [1, 2, 3] }
+
+			expect(diffRecord(prev, next)).toBeNull()
+		})
+
+		it('should handle array appends', () => {
+			const prev = { arr: [1, 2, 3] }
+			const next = { arr: [1, 2, 3, 4, 5] }
+
+			expect(diffRecord(prev, next)).toEqual({
+				arr: [ValueOpType.Append, [4, 5], 3],
+			})
+		})
+
+		it('should replace array when prefix changes', () => {
+			const prev = { arr: [1, 2, 3] }
+			const next = { arr: [1, 3, 4] }
+
+			expect(diffRecord(prev, next)).toEqual({
+				arr: [ValueOpType.Put, [1, 3, 4]],
+			})
+		})
+
+		it('should patch few items in same-length arrays', () => {
+			const prev = { arr: [1, 2, 3, 4, 5] }
+			const next = { arr: [1, 9, 3, 4, 5] }
+
+			expect(diffRecord(prev, next)).toEqual({
+				arr: [ValueOpType.Patch, { '1': [ValueOpType.Put, 9] }],
+			})
+		})
+
+		it('should replace array when too many items change', () => {
+			const prev = { arr: [1, 2, 3, 4, 5] }
+			const next = { arr: [6, 7, 8, 9, 10] }
+
+			expect(diffRecord(prev, next)).toEqual({
+				arr: [ValueOpType.Put, [6, 7, 8, 9, 10]],
+			})
+		})
+	})
+
+	describe('empty arrays', () => {
+		it('should handle empty to non-empty', () => {
+			const prev = { arr: [] }
+			const next = { arr: [1, 2, 3] }
+
+			expect(diffRecord(prev, next)).toEqual({
+				arr: [ValueOpType.Append, [1, 2, 3], 0],
+			})
+		})
+
+		it('should handle non-empty to empty', () => {
+			const prev = { arr: [1, 2, 3] }
+			const next = { arr: [] }
+
+			expect(diffRecord(prev, next)).toEqual({
+				arr: [ValueOpType.Put, []],
+			})
+		})
+	})
+})
+
+describe('applyObjectDiff comprehensive', () => {
+	describe('basic operations', () => {
+		it('should create new object when changes are needed', () => {
+			const obj = { a: 1, b: 2 }
+			const diff: ObjectDiff = { a: [ValueOpType.Put, 5] }
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result).not.toBe(obj)
+			expect(result).toEqual({ a: 5, b: 2 })
+		})
+
+		it('should handle put operations', () => {
+			const obj = { a: 1, b: 2 }
+			const diff: ObjectDiff = {
+				a: [ValueOpType.Put, 10],
+				c: [ValueOpType.Put, 30],
+			}
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result).toEqual({ a: 10, b: 2, c: 30 })
+		})
+
+		it('should handle delete operations', () => {
+			const obj = { a: 1, b: 2, c: 3 }
+			const diff: ObjectDiff = { b: [ValueOpType.Delete] }
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result).toEqual({ a: 1, c: 3 })
+			expect('b' in result).toBe(false)
+		})
+	})
+
+	describe('nested patch operations', () => {
+		it('should handle nested object patches', () => {
+			const obj = { a: 1, nested: { x: 10, y: 20 } }
+			const diff: ObjectDiff = {
+				nested: [ValueOpType.Patch, { x: [ValueOpType.Put, 100] }],
+			}
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result).toEqual({ a: 1, nested: { x: 100, y: 20 } })
+			expect(result.nested).not.toBe(obj.nested)
+		})
+
+		it('should handle deeply nested patches', () => {
+			const obj = {
+				level1: {
+					level2: {
+						level3: { value: 'old' },
+					},
+				},
+			}
+			const diff: ObjectDiff = {
+				level1: [
+					ValueOpType.Patch,
+					{
+						level2: [
+							ValueOpType.Patch,
+							{
+								level3: [
+									ValueOpType.Patch,
+									{
+										value: [ValueOpType.Put, 'new'],
+									},
+								],
+							},
+						],
+					},
+				],
+			}
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result.level1.level2.level3.value).toBe('new')
+		})
+	})
+
+	describe('array operations', () => {
+		it('should handle array append operations', () => {
+			const obj = { arr: [1, 2, 3] }
+			const diff: ObjectDiff = {
+				arr: [ValueOpType.Append, [4, 5], 3],
+			}
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result).toEqual({ arr: [1, 2, 3, 4, 5] })
+		})
+
+		it('should handle array patch operations', () => {
+			const obj = { arr: [{ a: 1 }, { b: 2 }, { c: 3 }] }
+			const diff: ObjectDiff = {
+				arr: [
+					ValueOpType.Patch,
+					{
+						'1': [ValueOpType.Patch, { b: [ValueOpType.Put, 20] }],
+					},
+				],
+			}
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result.arr[1]).toEqual({ b: 20 })
+			expect(result.arr[0]).toBe(obj.arr[0]) // Unchanged items should be same reference
+		})
+	})
+
+	describe('edge cases', () => {
+		it('should handle empty diffs', () => {
+			const obj = { a: 1, b: 2 }
+			const diff: ObjectDiff = {}
+
+			const result = applyObjectDiff(obj, diff)
+			expect(result).toBe(obj) // Should be same reference
+		})
+	})
+})
+
+describe('complex scenarios', () => {
+	it('should handle shape-like record updates', () => {
+		const prev = {
+			id: 'shape:123',
+			type: 'geo',
+			x: 100,
+			y: 200,
+			props: {
+				color: 'red',
+				size: 'medium',
+				geo: 'rectangle',
+			},
+			meta: {},
+		}
+
+		const next = {
+			id: 'shape:123',
+			type: 'geo',
+			x: 150,
+			y: 200,
+			props: {
+				color: 'blue',
+				size: 'medium',
+				geo: 'rectangle',
+			},
+			meta: { timestamp: Date.now() },
+		}
+
+		const diff = diffRecord(prev, next)
+		expect(diff).toBeTruthy()
+		expect(diff!.x).toEqual([ValueOpType.Put, 150])
+		expect(diff!.props).toEqual([ValueOpType.Patch, { color: [ValueOpType.Put, 'blue'] }])
+		expect(diff!.meta).toBeTruthy()
+
+		// Apply the diff and verify result
+		const result = applyObjectDiff(prev, diff!)
+		expect(result).toEqual(next)
+	})
+
+	it('should handle complete network diff workflow', () => {
+		const shape1 = { id: 'shape:1', type: 'geo', x: 100 }
+		const shape2prev = { id: 'shape:2', type: 'geo', x: 200 }
+		const shape2next = { id: 'shape:2', type: 'geo', x: 300 }
+		const shape3 = { id: 'shape:3', type: 'geo', x: 400 }
+
+		const recordsDiff = {
+			added: { 'shape:1': shape1 },
+			updated: { 'shape:2': [shape2prev, shape2next] },
+			removed: { 'shape:3': shape3 },
+		}
+
+		const networkDiff = getNetworkDiff(recordsDiff)
+		expect(networkDiff).toEqual({
+			'shape:1': [RecordOpType.Put, shape1],
+			'shape:2': [RecordOpType.Patch, { x: [ValueOpType.Put, 300] }],
+			'shape:3': [RecordOpType.Remove],
+		})
+	})
+})