@tldraw/sync-core 5.2.0-next.e2b8d10bf10e → 5.2.0

package/src/test/presenceMode.test.ts

@@ -1,149 +0,0 @@
-import { atom, computed, Signal } from '@tldraw/state'
-import { BaseRecord, createRecordType, RecordId, Store, StoreSchema } from '@tldraw/store'
-import { vi } from 'vitest'
-import { TLSyncClient } from '../lib/TLSyncClient'
-import { TestServer } from './TestServer'
-import { TestSocketPair } from './TestSocketPair'
-
-vi.mock('@tldraw/utils', async () => {
-	const actual = await vi.importActual('@tldraw/utils')
-	return {
-		...actual,
-		fpsThrottle: vi.fn((fn) => fn),
-	}
-})
-
-const disposables: Array<() => void> = []
-
-afterEach(() => {
-	for (const dispose of disposables) {
-		dispose()
-	}
-	disposables.length = 0
-})
-
-interface User extends BaseRecord<'user', RecordId<User>> {
-	name: string
-	age: number
-}
-
-interface Presence extends BaseRecord<'presence', RecordId<Presence>> {
-	name: string
-	age: number
-}
-
-const Presence = createRecordType<Presence>('presence', {
-	scope: 'presence',
-	validator: { validate: (value) => value as Presence },
-})
-
-const User = createRecordType<User>('user', {
-	scope: 'document',
-	validator: { validate: (value) => value as User },
-})
-
-type R = User | Presence
-
-const schema = StoreSchema.create<R>({ user: User, presence: Presence })
-
-class TestInstance {
-	server: TestServer<R>
-	socketPair: TestSocketPair<R>
-	client: TLSyncClient<R>
-
-	hasLoaded = false
-
-	constructor(presenceSignal: Signal<Presence | null>, presenceMode?: 'solo' | 'full') {
-		this.server = new TestServer(schema)
-		this.socketPair = new TestSocketPair('test_presence_mode', this.server)
-		this.socketPair.connect()
-
-		this.client = new TLSyncClient<R>({
-			store: new Store({ schema, props: {} }),
-			socket: this.socketPair.clientSocket,
-			onLoad: () => {
-				this.hasLoaded = true
-			},
-			onSyncError: vi.fn((reason) => {
-				throw new Error('onSyncError: ' + reason)
-			}),
-			presence: presenceSignal,
-			presenceMode: presenceMode ? computed('', () => presenceMode) : undefined,
-		})
-
-		disposables.push(() => {
-			this.client.close()
-		})
-	}
-
-	flush() {
-		this.server.flushDebouncingMessages()
-
-		while (this.socketPair.getNeedsFlushing()) {
-			this.socketPair.flushClientSentEvents()
-			this.socketPair.flushServerSentEvents()
-		}
-	}
-}
-
-test('presence is pushed on change when mode is full', () => {
-	const presence = Presence.create({ name: 'bob', age: 10 })
-	const presenceSignal = atom('', presence)
-
-	const t = new TestInstance(presenceSignal, 'full')
-	t.socketPair.connect()
-	t.flush()
-
-	const session = t.server.room.sessions.values().next().value
-	expect(session).toBeDefined()
-	expect(session?.presenceId).toBeDefined()
-	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.presenceStore.get(session!.presenceId!)).toMatchObject({
-		name: 'bob',
-		age: 11,
-	})
-
-	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
-	t.flush()
-	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
-		name: 'bob',
-		age: 12,
-	})
-})
-
-test('presence is only pushed once on connect when mode is solo', () => {
-	const presence = Presence.create({ name: 'bob', age: 10 })
-	const presenceSignal = atom('', presence)
-
-	const t = new TestInstance(presenceSignal, 'solo')
-	t.socketPair.connect()
-	t.flush()
-
-	const session = t.server.room.sessions.values().next().value
-	expect(session).toBeDefined()
-	expect(session?.presenceId).toBeDefined()
-	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.presenceStore.get(session!.presenceId!)).not.toMatchObject({
-		name: 'bob',
-		age: 11,
-	})
-
-	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
-	t.flush()
-	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
-		name: 'bob',
-		age: 12,
-	})
-})

package/src/test/validation.test.ts

@@ -1,186 +0,0 @@
-import { computed } from '@tldraw/state'
-import { RecordId, Store, StoreSchema, UnknownRecord, createRecordType } from '@tldraw/store'
-import { vi } from 'vitest'
-import { RecordOpType } from '../lib/diff'
-import { TLSyncClient, TLSyncErrorCloseEventReason } from '../lib/TLSyncClient'
-import { TestServer } from './TestServer'
-import { TestSocketPair } from './TestSocketPair'
-
-// @ts-expect-error
-global.requestAnimationFrame = (cb: () => any) => {
-	cb()
-}
-
-interface Book {
-	typeName: 'book'
-	id: RecordId<Book>
-	title: string
-}
-const Book = createRecordType<Book>('book', {
-	scope: 'document',
-	validator: {
-		validate: (record: unknown): Book => {
-			if (typeof record !== 'object' || record === null) {
-				throw new Error('Expected object')
-			}
-			if (!('title' in record)) {
-				throw new Error('Expected title')
-			}
-			if (typeof record.title !== 'string') {
-				throw new Error('Expected title to be a string')
-			}
-			return record as Book
-		},
-	},
-})
-const BookWithoutValidator = createRecordType<Book>('book', {
-	scope: 'document',
-	validator: { validate: (record) => record as Book },
-})
-type Presence = UnknownRecord & { typeName: 'presence' }
-const presenceType = createRecordType<Presence>('presence', {
-	scope: 'presence',
-	validator: { validate: (record) => record as Presence },
-})
-
-const schema = StoreSchema.create<Book | Presence>({ book: Book, presence: presenceType })
-const schemaWithoutValidator = StoreSchema.create<Book | Presence>({
-	book: BookWithoutValidator,
-	presence: presenceType,
-})
-
-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()
-	}
-	disposables.length = 0
-})
-
-async function makeTestInstance() {
-	const server = new TestServer(schema)
-	const socketPair = new TestSocketPair('test', server)
-	socketPair.connect()
-
-	const flush = async () => {
-		await Promise.resolve()
-		while (socketPair.getNeedsFlushing()) {
-			socketPair.flushClientSentEvents()
-			socketPair.flushServerSentEvents()
-		}
-	}
-	let onSyncError = vi.fn()
-	const client = await new Promise<TLSyncClient<Book | Presence>>((resolve, reject) => {
-		onSyncError = vi.fn(reject)
-		const client = new TLSyncClient({
-			store: new Store<Book | Presence, unknown>({ schema: schemaWithoutValidator, props: {} }),
-			socket: socketPair.clientSocket as any,
-			onLoad: resolve,
-			onSyncError,
-			presence: computed('', () => null),
-		})
-		disposables.push(() => client.close())
-		flush()
-	})
-
-	return {
-		server,
-		socketPair,
-		client,
-		flush,
-		onSyncError,
-	}
-}
-
-it('rejects invalid put operations that create a new document', async () => {
-	const { client, flush, onSyncError, server } = await makeTestInstance()
-
-	const prevServerDocs = server.storage.getSnapshot().documents
-
-	client.store.put([
-		{
-			typeName: 'book',
-			id: Book.createId('1'),
-			// @ts-expect-error - deliberate invalid data
-			title: 123 as string,
-		},
-	])
-	await flush()
-
-	expect(onSyncError).toHaveBeenCalledTimes(1)
-	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	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.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.storage.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
-	prevServerDocs = server.storage.getSnapshot().documents
-
-	client.socket.sendMessage({
-		type: 'push',
-		// @ts-expect-error clientClock is private
-		clientClock: client.clientClock++,
-		diff: {
-			[book.id]: [
-				RecordOpType.Put,
-				{
-					...book,
-					// @ts-expect-error - deliberate invalid data
-					title: 123 as string,
-				},
-			],
-		},
-	})
-	await flush()
-
-	expect(onSyncError).toHaveBeenCalledTimes(1)
-	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
-})
-
-it('rejects invalid update operations', async () => {
-	const { client, flush, onSyncError, server } = await makeTestInstance()
-
-	let prevServerDocs = server.storage.getSnapshot().documents
-
-	// create the book
-	client.store.put([
-		{
-			typeName: 'book',
-			id: Book.createId('1'),
-			title: 'The silence of the girls',
-		},
-	])
-	await flush()
-
-	expect(onSyncError).toHaveBeenCalledTimes(0)
-	expect(server.storage.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
-	prevServerDocs = server.storage.getSnapshot().documents
-
-	// update the title to be wrong
-	client.store.put([
-		{
-			typeName: 'book',
-			id: Book.createId('1'),
-			// @ts-expect-error - deliberate invalid data
-			title: 123 as string,
-		},
-	])
-	await flush()
-	expect(onSyncError).toHaveBeenCalledTimes(1)
-	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
-})