@tldraw/sync-core 5.3.0-internal.fba91ed55f6c → 5.3.0-next.4123e97459a9

package/src/test/storageContractSuite.ts

@@ -41,7 +41,6 @@ export function makePage(id: string, name = id, index = 'a2') {
 export interface StorageContractFactory {
 	create(opts?: {
 		snapshot?: RoomSnapshot
-		objectTypes?: readonly string[]
 		onChange?(arg: TLSyncStorageOnChangeCallbackProps): void
 	}): TLSyncStorage<TLRecord>
 }
@@ -62,84 +61,6 @@ export function registerStorageContractTests(factory: StorageContractFactory) {
 			expect(snapshot.documents.map((d) => d.lastChangedClock)).toEqual([0, 0])
 		})
 
-		describe('object-store lane partition', () => {
-			// the storage doesn't care about record semantics, so 'page' stands in as a
-			// generic object-lane type here
-			const createPartitioned = (snapshot?: RoomSnapshot) =>
-				factory.create({ snapshot, objectTypes: ['page'] })
-
-			it('partitions object-lane records out of getSnapshot into getObjectsSnapshot', () => {
-				const storage = createPartitioned(
-					makeContractSnapshot(contractRecords, { documentClock: 5 })
-				)
-				const snapshot = storage.getSnapshot!()
-				expect(snapshot.documents.map((d) => d.state.typeName)).toEqual(['document'])
-				// clock + schema are unaffected by the partition
-				expect(snapshot.documentClock).toBe(5)
-
-				expect(storage.getObjectsSnapshot!().map((d) => d.state.typeName)).toEqual(['page'])
-			})
-
-			it('returns an empty objects snapshot when no objectTypes are configured', () => {
-				const storage = create(makeContractSnapshot(contractRecords))
-				expect(storage.getSnapshot!().documents.length).toBe(2)
-				expect(storage.getObjectsSnapshot!()).toEqual([])
-			})
-
-			it('routes writes by type and shares the clock, tombstones, and change feed', () => {
-				const storage = createPartitioned(makeContractSnapshot(contractRecords))
-				const newPage = makePage('lane')
-				storage.transaction((txn) => txn.set(newPage.id, newPage))
-
-				// the write landed in the object partition, not the document snapshot
-				expect(storage.getSnapshot!().documents.map((d) => d.state.id)).toEqual([TLDOCUMENT_ID])
-				expect(storage.getObjectsSnapshot!().map((d) => d.state.id)).toContain(newPage.id)
-
-				// reads and the change feed span both partitions
-				storage.transaction((txn) => {
-					expect(txn.get(newPage.id)).toEqual(newPage)
-					expect(txn.getChangesSince(0)!.diff.puts[newPage.id]).toEqual(newPage)
-				})
-
-				// deleting an object-lane record writes a shared tombstone
-				const clockBeforeDelete = storage.getClock()
-				storage.transaction((txn) => txn.delete(newPage.id))
-				expect(storage.getObjectsSnapshot!().map((d) => d.state.id)).not.toContain(newPage.id)
-				storage.transaction((txn) => {
-					expect(txn.getChangesSince(clockBeforeDelete)!.diff.deletes).toContain(newPage.id)
-				})
-			})
-
-			it('iterates both partitions so schema migrations cover object-lane records', () => {
-				const storage = createPartitioned(makeContractSnapshot(contractRecords))
-				storage.transaction((txn) => {
-					const ids = Array.from(txn.keys()).sort()
-					expect(ids).toEqual(contractRecords.map((r) => r.id).sort())
-					expect(
-						Array.from(txn.values())
-							.map((r) => r.id)
-							.sort()
-					).toEqual(ids)
-					expect(
-						Array.from(txn.entries())
-							.map(([id]) => id)
-							.sort()
-					).toEqual(ids)
-				})
-			})
-
-			it('round-trips through a merged snapshot (persist lanes separately, re-seed together)', () => {
-				const storage = createPartitioned(makeContractSnapshot(contractRecords))
-				const merged = {
-					...storage.getSnapshot!(),
-					documents: [...storage.getSnapshot!().documents, ...storage.getObjectsSnapshot!()],
-				}
-				const reseeded = createPartitioned(merged)
-				expect(reseeded.getSnapshot!().documents.map((d) => d.state.typeName)).toEqual(['document'])
-				expect(reseeded.getObjectsSnapshot!().map((d) => d.state.typeName)).toEqual(['page'])
-			})
-		})
-
 		describe('transactions', () => {
 			it('[SS2] returns the callback result along with clock metadata', () => {
 				const storage = create(makeContractSnapshot(contractRecords, { documentClock: 7 }))

package/src/test/upgradeDowngrade.test.ts

@@ -2,7 +2,6 @@ import { computed } from '@tldraw/state'
 import {
 	BaseRecord,
 	RecordId,
-	SerializedSchema,
 	Store,
 	StoreSchema,
 	UnknownRecord,
@@ -11,7 +10,6 @@ import {
 	createRecordMigrationSequence,
 	createRecordType,
 } from '@tldraw/store'
-import { commentSchemaRecords, createTLSchema } from '@tldraw/tlschema'
 import { vi, type Mock } from 'vitest'
 import { RecordOpType, ValueOpType } from '../lib/diff'
 import { TLSocketServerSentEvent, getTlsyncProtocolVersion } from '../lib/protocol'
@@ -173,13 +171,8 @@ class TestInstance {
 
 	hasLoaded = false
 
-	constructor(
-		snapshot?: RoomSnapshot,
-		oldSchema = schemaV1,
-		newSchema = schemaV2,
-		roomOpts?: ConstructorParameters<typeof TestServer<RV2>>[2]
-	) {
-		this.server = new TestServer(newSchema, snapshot, roomOpts)
+	constructor(snapshot?: RoomSnapshot, oldSchema = schemaV1, newSchema = schemaV2) {
+		this.server = new TestServer(newSchema, snapshot)
 		this.oldSocketPair = new TestSocketPair('test_upgrade_old', this.server)
 		this.newSocketPair = new TestSocketPair('test_upgrade_new', this.server)
 
@@ -225,47 +218,6 @@ class TestInstance {
 	}
 }
 
-describe('record types unknown to older clients', () => {
-	// Mirrors a deploy that adds the comment record types: stale tabs still run a schema
-	// without them, while the server registers them and serves rooms that may contain them. The
-	// comment types ship guard migrations (retroactive, no `down`), so the server must reject
-	// stale sessions with CLIENT_TOO_OLD (prompting a refresh) rather than sending them record
-	// types their store cannot represent.
-	const schemaWithComments = createTLSchema({ records: commentSchemaRecords })
-	const schemaWithoutComments = createTLSchema()
-
-	function connectWith(server: TestServer<any>, schema: SerializedSchema) {
-		const id = 'stale-tab'
-		const socket = mockSocket()
-		server.room.handleNewSession({ sessionId: id, socket, meta: undefined, isReadonly: false })
-		server.room.handleMessage(id, {
-			type: 'connect',
-			connectRequestId: 'test',
-			lastServerClock: 0,
-			protocolVersion: getTlsyncProtocolVersion(),
-			schema,
-		})
-		return socket
-	}
-
-	it('[HS3] rejects sessions whose schema predates the comment types', () => {
-		const server = new TestServer(schemaWithComments as any, undefined, {
-			objectTypes: ['comment', 'comment-thread'],
-		})
-		const socket = connectWith(server, schemaWithoutComments.serialize())
-		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
-	})
-
-	it('[HS3] accepts sessions whose schema registers the comment types', () => {
-		const server = new TestServer(schemaWithComments as any, undefined, {
-			objectTypes: ['comment', 'comment-thread'],
-		})
-		const socket = connectWith(server, schemaWithComments.serialize())
-		expect(socket.close).not.toHaveBeenCalled()
-		expect((socket.sendMessage as Mock).mock.calls[0][0]).toMatchObject({ type: 'connect' })
-	})
-})
-
 it('[MG2] the server can handle receiving v1 stuff from the client', () => {
 	const t = new TestInstance()
 	t.oldSocketPair.connect()
@@ -616,7 +568,6 @@ describe('when the client is too old', () => {
 			schema: schemaV2.serialize(),
 			serverClock: 10,
 			isReadonly: false,
-			objectAccess: 'write',
 		} satisfies TLSocketServerSentEvent<RV2>)
 
 		expect(v1SendMessage).toHaveBeenCalledWith({
@@ -628,7 +579,6 @@ describe('when the client is too old', () => {
 			schema: schemaV2.serialize(),
 			serverClock: 10,
 			isReadonly: false,
-			objectAccess: 'write',
 		} satisfies TLSocketServerSentEvent<RV2>)
 
 		v2SendMessage.mockClear()
@@ -1150,7 +1100,6 @@ describe('when the client is the same version', () => {
 			schema: schemaV2.serialize(),
 			serverClock: 10,
 			isReadonly: false,
-			objectAccess: 'write',
 		} satisfies TLSocketServerSentEvent<RV2>)
 
 		expect(bSocket.sendMessage).toHaveBeenCalledWith({
@@ -1162,7 +1111,6 @@ describe('when the client is the same version', () => {
 			schema: schemaV2.serialize(),
 			serverClock: 10,
 			isReadonly: false,
-			objectAccess: 'write',
 		} satisfies TLSocketServerSentEvent<RV2>)
 		;(aSocket.sendMessage as Mock).mockClear()
 		;(bSocket.sendMessage as Mock).mockClear()
@@ -1237,93 +1185,3 @@ describe('when the client is the same version', () => {
 		} satisfies TLSocketServerSentEvent<RV2>)
 	})
 })
-
-describe('record authorizers see server-schema records', () => {
-	function makeInstance(authorizeUser: (args: any) => any) {
-		return new TestInstance(undefined, schemaV1, schemaV2, {
-			authorizeRecord: { user: authorizeUser },
-		})
-	}
-
-	it('a put from an old client reaches the authorizer up-migrated', () => {
-		const seen: any[] = []
-		const t = makeInstance((args: any) => {
-			seen.push(structuredClone({ type: args.type, prev: args.prev, next: args.next }))
-			return args.next
-		})
-		t.oldSocketPair.connect()
-		t.flush()
-
-		const user = UserV1.create({ name: 'bob', age: 10 })
-		t.oldClient.store.put([user])
-		t.flush()
-
-		expect(seen).toHaveLength(1)
-		expect(seen[0].type).toBe('create')
-		expect(seen[0].next).toMatchObject({ name: 'bob', birthdate: null })
-		expect(seen[0].next).not.toHaveProperty('age')
-	})
-
-	it('a stamp applied on create survives — no migration runs after the authorizer', () => {
-		const t = makeInstance((args: any) =>
-			args.type === 'create' ? { ...args.next, birthdate: '2001-02-03' } : args.next
-		)
-		t.oldSocketPair.connect()
-		t.flush()
-
-		const user = UserV1.create({ name: 'bob', age: 10 })
-		t.oldClient.store.put([user])
-		t.flush()
-
-		expect(t.server.storage.documents.get(user.id)?.state).toMatchObject({
-			name: 'bob',
-			birthdate: '2001-02-03',
-		})
-	})
-
-	it('a patch from an old client reaches the authorizer as the upgraded committed candidate', () => {
-		const seen: any[] = []
-		const t = makeInstance((args: any) => {
-			seen.push(structuredClone({ type: args.type, prev: args.prev, next: args.next }))
-			return args.next
-		})
-		t.oldSocketPair.connect()
-		t.newSocketPair.connect()
-		t.flush()
-
-		const user = UserV2.create({ name: 'bob', birthdate: '2022-01-09' })
-		t.newClient.store.put([user])
-		t.flush()
-		seen.length = 0
-
-		t.oldClient.store.update(user.id as any, (u: any) => ({ ...u, name: 'bobby' }))
-		t.flush()
-
-		expect(seen).toHaveLength(1)
-		expect(seen[0].type).toBe('update')
-		expect(seen[0].prev).toMatchObject({ name: 'bob', birthdate: '2022-01-09' })
-		// The down→patch→up round-trip through the lossy v1 schema resets birthdate to null.
-		// The authorizer must see exactly what will be committed — not a preview mixing the
-		// server record with the raw v1 diff (which would still show the old birthdate).
-		expect(seen[0].next).toMatchObject({ name: 'bobby', birthdate: null })
-		expect(seen[0].next).not.toHaveProperty('age')
-	})
-
-	it('vetoes based on the server-schema record', () => {
-		const t = makeInstance((args: any) =>
-			args.type === 'update' && args.next.name === 'forged' ? null : args.next
-		)
-		t.oldSocketPair.connect()
-		t.newSocketPair.connect()
-		t.flush()
-
-		const user = UserV2.create({ name: 'bob', birthdate: '2022-01-09' })
-		t.newClient.store.put([user])
-		t.flush()
-
-		t.oldClient.store.update(user.id as any, (u: any) => ({ ...u, name: 'forged' }))
-		t.flush()
-
-		expect(t.server.storage.documents.get(user.id)?.state).toMatchObject({ name: 'bob' })
-	})
-})