@tldraw/store 5.2.0-next.ee0fa4d6244f → 5.2.0

package/src/lib/setUtils.test.ts

@@ -1,105 +1,64 @@
 import { describe, expect, it } from 'vitest'
 import { diffSets, intersectSets } from './setUtils'
 
-describe('intersectSets', () => {
-	it('should return intersection of multiple sets', () => {
-		const set1 = new Set([1, 2, 3, 4])
-		const set2 = new Set([2, 3, 4, 5])
-		const set3 = new Set([3, 4, 5, 6])
+// Tests for SPEC.md §25 (set utilities).
+// Rule IDs like [SU1] in test names refer to that document.
 
-		const result = intersectSets([set1, set2, set3])
+describe('intersectSets (SU)', () => {
+	it('[SU1] returns the elements present in every set', () => {
+		expect(
+			intersectSets([new Set([1, 2, 3, 4]), new Set([2, 3, 4, 5]), new Set([3, 4, 5, 6])])
+		).toEqual(new Set([3, 4]))
 
-		expect(Array.from(result).sort()).toEqual([3, 4])
+		expect(intersectSets([new Set([1, 2, 3]), new Set([4, 5, 6])])).toEqual(new Set())
+		expect(intersectSets([new Set([1, 2, 3]), new Set(), new Set([2, 3, 4])])).toEqual(new Set())
 	})
 
-	it('should return empty set when no sets provided', () => {
-		const result = intersectSets([])
-		expect(result.size).toBe(0)
+	it('[SU1] no sets yields an empty set', () => {
+		expect(intersectSets([])).toEqual(new Set())
 	})
 
-	it('should return empty set when no common elements exist', () => {
-		const set1 = new Set([1, 2, 3])
-		const set2 = new Set([4, 5, 6])
+	it('[SU1] a single set yields a copy', () => {
+		const set = new Set([1, 2, 3])
+		const result = intersectSets([set])
 
-		const result = intersectSets([set1, set2])
-
-		expect(result.size).toBe(0)
-	})
-
-	it('should return empty set when any set is empty', () => {
-		const set1 = new Set([1, 2, 3])
-		const set2 = new Set<number>()
-		const set3 = new Set([2, 3, 4])
-
-		const result = intersectSets([set1, set2, set3])
-
-		expect(result.size).toBe(0)
-	})
-
-	it('should return copy of single set', () => {
-		const set1 = new Set([1, 2, 3])
-		const result = intersectSets([set1])
-
-		expect(result).not.toBe(set1)
-		expect(Array.from(result).sort()).toEqual([1, 2, 3])
+		expect(result).not.toBe(set)
+		expect(result).toEqual(set)
 	})
 })
 
-describe('diffSets', () => {
-	it('should detect added elements', () => {
-		const prev = new Set(['a', 'b'])
-		const next = new Set(['a', 'b', 'c'])
+describe('diffSets (SU)', () => {
+	it('[SU2] reports added and removed elements, with only the populated keys', () => {
+		expect(diffSets(new Set(['a', 'b']), new Set(['a', 'b', 'c']))).toEqual({
+			added: new Set(['c']),
+		})
 
-		const result = diffSets(prev, next)
+		expect(diffSets(new Set(['a', 'b', 'c']), new Set(['a', 'b']))).toEqual({
+			removed: new Set(['c']),
+		})
 
-		expect(result?.added).toBeDefined()
-		expect(result?.removed).toBeUndefined()
-		expect(Array.from(result!.added!)).toEqual(['c'])
+		expect(diffSets(new Set(['a', 'b']), new Set(['b', 'c']))).toEqual({
+			added: new Set(['c']),
+			removed: new Set(['a']),
+		})
 	})
 
-	it('should detect removed elements', () => {
-		const prev = new Set(['a', 'b', 'c'])
-		const next = new Set(['a', 'b'])
-
-		const result = diffSets(prev, next)
-
-		expect(result?.removed).toBeDefined()
-		expect(result?.added).toBeUndefined()
-		expect(Array.from(result!.removed!)).toEqual(['c'])
+	it('[SU2] returns undefined when the sets have the same members', () => {
+		expect(diffSets(new Set(['a', 'b', 'c']), new Set(['a', 'b', 'c']))).toBeUndefined()
+		expect(diffSets(new Set(), new Set())).toBeUndefined()
 	})
 
-	it('should detect both added and removed elements', () => {
-		const prev = new Set(['a', 'b'])
-		const next = new Set(['b', 'c'])
-
-		const result = diffSets(prev, next)
-
-		expect(result?.added).toBeDefined()
-		expect(result?.removed).toBeDefined()
-		expect(Array.from(result!.added!)).toEqual(['c'])
-		expect(Array.from(result!.removed!)).toEqual(['a'])
-	})
-
-	it('should return undefined when sets are identical', () => {
-		const prev = new Set(['a', 'b', 'c'])
-		const next = new Set(['a', 'b', 'c'])
-
-		const result = diffSets(prev, next)
-
-		expect(result).toBeUndefined()
-	})
-
-	it('should handle object references correctly', () => {
+	it('[SU2] compares object members by reference', () => {
 		const obj1 = { id: 1 }
 		const obj2 = { id: 2 }
 		const obj3 = { id: 3 }
 
-		const prev = new Set([obj1, obj2])
-		const next = new Set([obj2, obj3])
-
-		const result = diffSets(prev, next)
+		expect(diffSets(new Set([obj1, obj2]), new Set([obj2, obj3]))).toEqual({
+			added: new Set([obj3]),
+			removed: new Set([obj1]),
+		})
 
-		expect(result?.added?.has(obj3)).toBe(true)
-		expect(result?.removed?.has(obj1)).toBe(true)
+		// structurally equal but distinct objects are different members
+		expect(diffSets(new Set([{ id: 1 }]), new Set([{ id: 1 }]))).toBeDefined()
 	})
 })

package/src/lib/test/createMigrations.test.ts

@@ -1,75 +0,0 @@
-import { createMigrationSequence } from '../migrate'
-
-describe(createMigrationSequence, () => {
-	it('allows dependsOn to be deferred', () => {
-		expect(
-			createMigrationSequence({
-				sequenceId: 'foo',
-				retroactive: false,
-				sequence: [{ dependsOn: ['bar/1'] }],
-			}).sequence.length
-		).toBe(0)
-
-		const result = createMigrationSequence({
-			sequenceId: 'foo',
-			retroactive: false,
-			sequence: [
-				{
-					id: 'foo/1',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-				{ dependsOn: ['bar/1'] },
-			],
-		})
-
-		expect(result.sequence.length).toBe(1)
-		expect(result.sequence[0].dependsOn?.length).toBeFalsy()
-
-		const result2 = createMigrationSequence({
-			sequenceId: 'foo',
-			retroactive: false,
-			sequence: [
-				{ dependsOn: ['bar/1'] },
-				{
-					id: 'foo/1',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-			],
-		})
-
-		expect(result2.sequence.length).toBe(1)
-		expect(result2.sequence[0].dependsOn).toEqual(['bar/1'])
-
-		const result3 = createMigrationSequence({
-			sequenceId: 'foo',
-			retroactive: false,
-			sequence: [
-				{
-					id: 'foo/1',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-				{ dependsOn: ['bar/1'] },
-				{
-					id: 'foo/2',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-			],
-		})
-
-		expect(result3.sequence.length).toBe(2)
-		expect(result3.sequence[0].dependsOn?.length).toBeFalsy()
-		expect(result3.sequence[1].dependsOn).toEqual(['bar/1'])
-	})
-})

package/src/lib/test/dependsOn.test.ts

@@ -1,166 +0,0 @@
-import { MigrationSequence, createMigrationSequence } from '../migrate'
-import { StoreSchema } from '../StoreSchema'
-
-describe('dependsOn', () => {
-	it('requires the depended on ids to be present', () => {
-		expect(() => {
-			StoreSchema.create(
-				{},
-				{
-					migrations: [
-						{
-							sequenceId: 'foo',
-							retroactive: false,
-							sequence: [
-								{
-									id: 'foo/1',
-									dependsOn: ['bar/1'],
-									scope: 'record',
-									up() {
-										// noop
-									},
-								},
-							],
-						},
-					],
-				}
-			)
-		}).toThrowErrorMatchingInlineSnapshot(
-			`[Error: Migration 'foo/1' depends on missing migration 'bar/1']`
-		)
-	})
-
-	it('makes sure the migrations are sorted', () => {
-		const foo: MigrationSequence = {
-			sequenceId: 'foo',
-			retroactive: false,
-			sequence: [
-				{
-					id: 'foo/1',
-					dependsOn: ['bar/1'],
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-			],
-		}
-		const bar: MigrationSequence = {
-			sequenceId: 'bar',
-			retroactive: false,
-			sequence: [
-				{
-					id: 'bar/1',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-			],
-		}
-		const s = StoreSchema.create(
-			{},
-			{
-				migrations: [foo, bar],
-			}
-		)
-		const s2 = StoreSchema.create(
-			{},
-			{
-				migrations: [bar, foo],
-			}
-		)
-
-		expect(s.sortedMigrations.map((s) => s.id)).toMatchInlineSnapshot(`
-		[
-		  "bar/1",
-		  "foo/1",
-		]
-	`)
-		expect(s2.sortedMigrations).toEqual(s.sortedMigrations)
-	})
-})
-
-describe('standalone dependsOn', () => {
-	it('requires the depended on ids to be present', () => {
-		expect(() => {
-			StoreSchema.create(
-				{},
-				{
-					migrations: [
-						createMigrationSequence({
-							sequenceId: 'foo',
-							retroactive: false,
-							sequence: [
-								{
-									dependsOn: ['bar/1'],
-								},
-								{
-									id: 'foo/1',
-									scope: 'record',
-									up() {
-										// noop
-									},
-								},
-							],
-						}),
-					],
-				}
-			)
-		}).toThrowErrorMatchingInlineSnapshot(
-			`[Error: Migration 'foo/1' depends on missing migration 'bar/1']`
-		)
-	})
-
-	it('makes sure the migrations are sorted', () => {
-		const foo: MigrationSequence = createMigrationSequence({
-			sequenceId: 'foo',
-			retroactive: false,
-			sequence: [
-				{
-					dependsOn: ['bar/1'],
-				},
-				{
-					id: 'foo/1',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-			],
-		})
-		const bar: MigrationSequence = createMigrationSequence({
-			sequenceId: 'bar',
-			retroactive: false,
-			sequence: [
-				{
-					id: 'bar/1',
-					scope: 'record',
-					up() {
-						// noop
-					},
-				},
-			],
-		})
-		const s = StoreSchema.create(
-			{},
-			{
-				migrations: [foo, bar],
-			}
-		)
-		const s2 = StoreSchema.create(
-			{},
-			{
-				migrations: [bar, foo],
-			}
-		)
-
-		expect(s.sortedMigrations.map((s) => s.id)).toMatchInlineSnapshot(`
-		[
-		  "bar/1",
-		  "foo/1",
-		]
-	`)
-		expect(s2.sortedMigrations).toEqual(s.sortedMigrations)
-	})
-})

package/src/lib/test/getMigrationsSince.test.ts

@@ -1,121 +0,0 @@
-import { MigrationSequence } from '../migrate'
-import { SerializedSchemaV2, StoreSchema } from '../StoreSchema'
-
-const mockSequence = ({
-	id,
-	retroactive,
-	versions,
-}: {
-	id: string
-	retroactive: boolean
-	versions: number
-}) =>
-	({
-		sequenceId: id,
-		retroactive,
-		sequence: new Array(versions).fill(0).map((_, i) => ({
-			id: `${id}/${i + 1}`,
-			scope: 'record',
-			up() {
-				// noop
-			},
-		})),
-	}) satisfies MigrationSequence
-
-function getMigrationsBetween(
-	serialized: SerializedSchemaV2['sequences'],
-	current: MigrationSequence[]
-) {
-	const schema = StoreSchema.create({}, { migrations: current })
-	const ms = schema.getMigrationsSince({ schemaVersion: 2, sequences: serialized })
-	if (!ms.ok) {
-		throw new Error('Expected migrations to be found')
-	}
-	return ms.value.map((m) => m.id)
-}
-
-describe('getMigrationsSince', () => {
-	it('includes migrations from new migration sequences with retroactive: true', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: true, versions: 2 })
-		const bar = mockSequence({ id: 'bar', retroactive: true, versions: 3 })
-
-		const ids = getMigrationsBetween({}, [foo, bar])
-		const foos = ids.filter((id) => id.startsWith('foo'))
-		const bars = ids.filter((id) => id.startsWith('bar'))
-
-		expect(foos).toEqual(['foo/1', 'foo/2'])
-		expect(bars).toEqual(['bar/1', 'bar/2', 'bar/3'])
-	})
-
-	it('does not include migrations from new migration sequences with retroactive: false', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: true, versions: 2 })
-		const bar = mockSequence({ id: 'bar', retroactive: false, versions: 3 })
-
-		const ids = getMigrationsBetween({}, [foo, bar])
-		const foos = ids.filter((id) => id.startsWith('foo'))
-		const bars = ids.filter((id) => id.startsWith('bar'))
-
-		expect(foos).toEqual(['foo/1', 'foo/2'])
-		expect(bars).toEqual([])
-	})
-
-	it('returns the empty array if there are no overlapping sequences and new ones are retroactive: false', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: false, versions: 2 })
-		const bar = mockSequence({ id: 'bar', retroactive: false, versions: 3 })
-
-		const ids = getMigrationsBetween({}, [foo, bar])
-		expect(ids).toEqual([])
-	})
-
-	it('if a sequence is present both before and now, unapplied migrations will be returned', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: true, versions: 2 })
-		const bar = mockSequence({ id: 'bar', retroactive: false, versions: 3 })
-		const ids = getMigrationsBetween({ foo: 1, bar: 1 }, [foo, bar])
-
-		const foos = ids.filter((id) => id.startsWith('foo'))
-		const bars = ids.filter((id) => id.startsWith('bar'))
-
-		expect(foos).toEqual(['foo/2'])
-		expect(bars).toEqual(['bar/2', 'bar/3'])
-	})
-
-	it('if a sequence has not changed the empty array will be returned', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: true, versions: 2 })
-		const bar = mockSequence({ id: 'bar', retroactive: false, versions: 3 })
-		const ids = getMigrationsBetween({ foo: 2, bar: 3 }, [foo, bar])
-
-		expect(ids).toEqual([])
-	})
-
-	it('if a sequence starts with 0 all unapplied migrations will be returned', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: true, versions: 2 })
-		const bar = mockSequence({ id: 'bar', retroactive: false, versions: 3 })
-
-		const ids = getMigrationsBetween(
-			{
-				foo: 0,
-				bar: 0,
-			},
-			[foo, bar]
-		)
-		const foos = ids.filter((id) => id.startsWith('foo'))
-		const bars = ids.filter((id) => id.startsWith('bar'))
-
-		expect(foos).toEqual(['foo/1', 'foo/2'])
-		expect(bars).toEqual(['bar/1', 'bar/2', 'bar/3'])
-	})
-
-	it('if a sequence starts with 0 and has 0 new migrations, no migrations will be returned', () => {
-		const foo = mockSequence({ id: 'foo', retroactive: true, versions: 0 })
-		const bar = mockSequence({ id: 'bar', retroactive: false, versions: 0 })
-
-		const ids = getMigrationsBetween(
-			{
-				foo: 0,
-				bar: 0,
-			},
-			[foo, bar]
-		)
-		expect(ids).toEqual([])
-	})
-})

package/src/lib/test/migrate.test.ts

@@ -1,118 +0,0 @@
-import { SerializedStore } from '../Store'
-import { testSchemaV0 } from './testSchema.v0'
-import { testSchemaV1 } from './testSchema.v1'
-
-const serializedV0Schenma = testSchemaV0.serialize()
-const serializedV1Schenma = testSchemaV1.serialize()
-
-test('serializedV0Schenma', () => {
-	expect(serializedV0Schenma).toMatchInlineSnapshot(`
-		{
-		  "schemaVersion": 2,
-		  "sequences": {},
-		}
-	`)
-})
-
-test('serializedV1Schenma', () => {
-	expect(serializedV1Schenma).toMatchInlineSnapshot(`
-		{
-		  "schemaVersion": 2,
-		  "sequences": {
-		    "com.tldraw.shape": 2,
-		    "com.tldraw.shape.oval": 1,
-		    "com.tldraw.shape.rectangle": 1,
-		    "com.tldraw.store": 1,
-		    "com.tldraw.user": 2,
-		  },
-		}
-	`)
-})
-
-test('unknown types fail', () => {
-	expect(
-		testSchemaV1.migratePersistedRecord(
-			{
-				id: 'whatevere',
-				typeName: 'steve',
-			} as any,
-			serializedV0Schenma,
-			'up'
-		)
-	).toMatchObject({
-		type: 'error',
-	})
-
-	expect(
-		testSchemaV1.migratePersistedRecord(
-			{
-				id: 'whatevere',
-				typeName: 'jeff',
-			} as any,
-			serializedV0Schenma,
-			'down'
-		)
-	).toMatchObject({
-		type: 'error',
-	})
-})
-
-test('migrating a whole store snapshot works', () => {
-	const serializedStore: SerializedStore<any> = {
-		'user-1': {
-			id: 'user-1',
-			typeName: 'user',
-			name: 'name',
-		},
-		'shape-1': {
-			id: 'shape-1',
-			typeName: 'shape',
-			x: 0,
-			y: 0,
-			type: 'rectangle',
-			props: {
-				width: 100,
-				height: 100,
-			},
-		},
-		'org-1': {
-			id: 'org-1',
-			typeName: 'org',
-			name: 'tldraw',
-		},
-	}
-
-	const result = testSchemaV1.migrateStoreSnapshot({
-		store: serializedStore,
-		schema: serializedV0Schenma,
-	})
-
-	if (result.type !== 'success') {
-		console.error(result)
-		throw new Error('Migration failed')
-	}
-
-	expect(result.value).toEqual({
-		'shape-1': {
-			id: 'shape-1',
-			typeName: 'shape',
-			x: 0,
-			y: 0,
-			type: 'rectangle',
-			parentId: null,
-			rotation: 0,
-			props: {
-				width: 100,
-				height: 100,
-				opacity: 1,
-			},
-		},
-		'user-1': {
-			id: 'user-1',
-			typeName: 'user',
-			name: 'name',
-			locale: 'en',
-			phoneNumber: null,
-		},
-	})
-})