@tldraw/store 5.2.0-next.e2b8d10bf10e → 5.2.0

package/src/lib/test/recordType.test.ts

@@ -1,19 +0,0 @@
-import { testSchemaV1 } from './testSchema.v1'
-
-describe('parseId', () => {
-	it('should return the part after the colon', () => {
-		expect(testSchemaV1.types.user.parseId('user:123' as any)).toBe('123')
-		expect(testSchemaV1.types.shape.parseId('shape:xyz' as any)).toBe('xyz')
-	})
-	it('should throw if the typename does not match', () => {
-		expect(() => testSchemaV1.types.user.parseId('shape:123' as any)).toThrow()
-		expect(() => testSchemaV1.types.shape.parseId('user:xyz' as any)).toThrow()
-	})
-})
-
-describe('createId', () => {
-	it('should prepend the typename and a colon', () => {
-		expect(testSchemaV1.types.user.createId('123')).toBe('user:123')
-		expect(testSchemaV1.types.shape.createId('xyz')).toBe('shape:xyz')
-	})
-})

package/src/lib/test/sortMigrations.test.ts

@@ -1,83 +0,0 @@
-import { Migration, MigrationId, sortMigrations } from '../migrate'
-
-describe(sortMigrations, () => {
-	const m = (id: MigrationId, others?: { dependsOn?: MigrationId[] }): Migration => ({
-		...others,
-		id,
-		scope: 'record',
-		up() {
-			// noop
-		},
-	})
-	const sort = (migrations: Migration[]) => {
-		return sortMigrations(migrations).map((m) => m.id)
-	}
-	it('should sort migrations based on version number', () => {
-		expect(sort([m('foo/2'), m('foo/1')])).toEqual(['foo/1', 'foo/2'])
-		expect(sort([m('foo/1'), m('foo/2')])).toEqual(['foo/1', 'foo/2'])
-	})
-	it('should sort multiple migration sequences based on version number', () => {
-		const result = sort([m('foo/2'), m('bar/2'), m('foo/1'), m('bar/1')])
-		expect(result.filter((id) => id.startsWith('foo/'))).toEqual(['foo/1', 'foo/2'])
-		expect(result.filter((id) => id.startsWith('bar/'))).toEqual(['bar/1', 'bar/2'])
-	})
-	it('should use dependsOn to resolve inter-sequence dependencies', () => {
-		expect(
-			sort([m('foo/2'), m('bar/2'), m('foo/1'), m('bar/1', { dependsOn: ['foo/2'] })])
-		).toEqual(['foo/1', 'foo/2', 'bar/1', 'bar/2'])
-
-		expect(
-			sort([m('foo/2'), m('bar/2'), m('foo/1', { dependsOn: ['bar/2'] }), m('bar/1')])
-		).toEqual(['bar/1', 'bar/2', 'foo/1', 'foo/2'])
-	})
-
-	it('should minimize distance between dependencies and dependents', () => {
-		// bar/3 depends on foo/1 - should process bar sequence immediately after foo/1
-		expect(
-			sort([m('foo/2'), m('bar/3', { dependsOn: ['foo/1'] }), m('foo/1'), m('bar/1'), m('bar/2')])
-		).toEqual(['foo/1', 'bar/1', 'bar/2', 'bar/3', 'foo/2'])
-	})
-
-	it('should minimize total distance for multiple explicit dependencies', () => {
-		// Both bar/2 and baz/1 depend on foo/1 - minimize total distance
-		expect(
-			sort([
-				m('foo/2'),
-				m('bar/2', { dependsOn: ['foo/1'] }),
-				m('foo/1'),
-				m('bar/1'),
-				m('baz/1', { dependsOn: ['foo/1'] }),
-			])
-		).toEqual(['foo/1', 'bar/1', 'bar/2', 'baz/1', 'foo/2'])
-	})
-
-	it('should handle chain of explicit dependencies optimally', () => {
-		// foo/1 -> bar/1 -> baz/1 chain should be consecutive
-		expect(
-			sort([
-				m('foo/2'),
-				m('bar/1', { dependsOn: ['foo/1'] }),
-				m('foo/1'),
-				m('baz/1', { dependsOn: ['bar/1'] }),
-			])
-		).toEqual(['foo/1', 'bar/1', 'baz/1', 'foo/2'])
-	})
-
-	it('should fail if a cycle is created', () => {
-		expect(() => {
-			sort([m('foo/1', { dependsOn: ['foo/1'] })])
-		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: foo/1]`)
-
-		expect(() => {
-			sort([m('foo/1', { dependsOn: ['foo/2'] }), m('foo/2')])
-		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: foo/1]`)
-
-		expect(() => {
-			sort([m('foo/1', { dependsOn: ['bar/1'] }), m('bar/1', { dependsOn: ['foo/1'] })])
-		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: foo/1]`)
-
-		expect(() => {
-			sort([m('bar/1', { dependsOn: ['foo/1'] }), m('foo/1', { dependsOn: ['bar/1'] })])
-		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: bar/1]`)
-	})
-})

package/src/lib/test/upgradeSchema.test.ts

@@ -1,80 +0,0 @@
-import { SerializedSchemaV1, upgradeSchema } from '../StoreSchema'
-
-describe('upgradeSchema', () => {
-	it('should upgrade a schema from v1 to v2, assuming its working with tldraw data', () => {
-		const v1: SerializedSchemaV1 = {
-			schemaVersion: 1,
-			storeVersion: 4,
-			recordVersions: {
-				asset: {
-					version: 1,
-					subTypeKey: 'type',
-					subTypeVersions: { image: 2, video: 2, bookmark: 0 },
-				},
-				camera: { version: 1 },
-				document: { version: 2 },
-				instance: { version: 22 },
-				instance_page_state: { version: 5 },
-				page: { version: 1 },
-				shape: {
-					version: 3,
-					subTypeKey: 'type',
-					subTypeVersions: {
-						group: 0,
-						text: 1,
-						bookmark: 1,
-						draw: 1,
-						geo: 7,
-						note: 4,
-						line: 1,
-						frame: 0,
-						arrow: 1,
-						highlight: 0,
-						embed: 4,
-						image: 2,
-						video: 1,
-					},
-				},
-				instance_presence: { version: 5 },
-				pointer: { version: 1 },
-			},
-		}
-
-		expect(upgradeSchema(v1)).toMatchInlineSnapshot(`
-		{
-		  "ok": true,
-		  "value": {
-		    "schemaVersion": 2,
-		    "sequences": {
-		      "com.tldraw.asset": 1,
-		      "com.tldraw.asset.bookmark": 0,
-		      "com.tldraw.asset.image": 2,
-		      "com.tldraw.asset.video": 2,
-		      "com.tldraw.camera": 1,
-		      "com.tldraw.document": 2,
-		      "com.tldraw.instance": 22,
-		      "com.tldraw.instance_page_state": 5,
-		      "com.tldraw.instance_presence": 5,
-		      "com.tldraw.page": 1,
-		      "com.tldraw.pointer": 1,
-		      "com.tldraw.shape": 3,
-		      "com.tldraw.shape.arrow": 1,
-		      "com.tldraw.shape.bookmark": 1,
-		      "com.tldraw.shape.draw": 1,
-		      "com.tldraw.shape.embed": 4,
-		      "com.tldraw.shape.frame": 0,
-		      "com.tldraw.shape.geo": 7,
-		      "com.tldraw.shape.group": 0,
-		      "com.tldraw.shape.highlight": 0,
-		      "com.tldraw.shape.image": 2,
-		      "com.tldraw.shape.line": 1,
-		      "com.tldraw.shape.note": 4,
-		      "com.tldraw.shape.text": 1,
-		      "com.tldraw.shape.video": 1,
-		      "com.tldraw.store": 4,
-		    },
-		  },
-		}
-	`)
-	})
-})

package/src/lib/test/validate.test.ts

@@ -1,178 +0,0 @@
-import { BaseRecord, IdOf, RecordId } from '../BaseRecord'
-import { createRecordType } from '../RecordType'
-import { SerializedStore, Store } from '../Store'
-import { StoreSchema } from '../StoreSchema'
-
-interface Book extends BaseRecord<'book', RecordId<Book>> {
-	title: string
-	author: IdOf<Author>
-	numPages: number
-}
-
-const Book = createRecordType<Book>('book', {
-	validator: {
-		validate(value) {
-			const book = value as Book
-			if (!book.id.startsWith('book:')) throw Error()
-			if (book.typeName !== 'book') throw Error()
-			if (typeof book.title !== 'string') throw Error()
-			if (!Number.isFinite(book.numPages)) throw Error()
-			if (book.numPages < 0) throw Error()
-			return book
-		},
-	},
-	scope: 'document',
-})
-
-interface Author extends BaseRecord<'author', RecordId<Author>> {
-	name: string
-	isPseudonym: boolean
-}
-
-const Author = createRecordType<Author>('author', {
-	validator: {
-		validate(value) {
-			const author = value as Author
-			if (author.typeName !== 'author') throw Error()
-			if (!author.id.startsWith('author:')) throw Error()
-			if (typeof author.name !== 'string') throw Error()
-			if (typeof author.isPseudonym !== 'boolean') throw Error()
-			return author
-		},
-	},
-	scope: 'document',
-}).withDefaultProperties(() => ({
-	isPseudonym: false,
-}))
-
-const schema = StoreSchema.create<Book | Author>({
-	book: Book,
-	author: Author,
-})
-
-describe('Store with validation', () => {
-	let store: Store<Book | Author>
-
-	beforeEach(() => {
-		store = new Store({ schema, props: {} })
-	})
-
-	it('Accepts valid records and rejects invalid records', () => {
-		store.put([Author.create({ name: 'J.R.R Tolkein', id: Author.createId('tolkein') })])
-
-		expect(store.query.records('author').get()).toEqual([
-			{ id: 'author:tolkein', typeName: 'author', name: 'J.R.R Tolkein', isPseudonym: false },
-		])
-
-		expect(() => {
-			store.put([
-				{
-					id: Book.createId('the-hobbit'),
-					typeName: 'book',
-					title: 'The Hobbit',
-					numPages: -1, // <---- Invalid!
-					author: Author.createId('tolkein'),
-				},
-			])
-		}).toThrow()
-
-		expect(store.query.records('book').get()).toEqual([])
-	})
-})
-
-describe('Validating initial data', () => {
-	let snapshot: SerializedStore<Book | Author>
-
-	beforeEach(() => {
-		const authorId = Author.createId('tolkein')
-		const authorRecord = Author.create({ name: 'J.R.R Tolkein', id: authorId })
-		const bookId = Book.createId('the-hobbit')
-		const bookRecord = Book.create({
-			title: 'The Hobbit',
-			numPages: 300,
-			author: authorId,
-			id: bookId,
-		})
-
-		snapshot = {
-			[authorId]: authorRecord,
-			[bookId]: bookRecord,
-		}
-	})
-
-	it('Validates initial data', () => {
-		expect(() => {
-			new Store<Book | Author>({ schema, initialData: snapshot, props: {} })
-		}).not.toThrow()
-
-		expect(() => {
-			// @ts-expect-error
-			snapshot[0].name = 4
-
-			new Store<Book | Author>({ schema, initialData: snapshot, props: {} })
-		}).toThrow()
-	})
-})
-
-describe('Create & update validations', () => {
-	const authorId = Author.createId('tolkein')
-	const bookId = Book.createId('the-hobbit')
-	const initialAuthor = Author.create({ name: 'J.R.R Tolkein', id: authorId })
-	const invalidBook = Book.create({
-		// @ts-expect-error - deliberately invalid data
-		title: 4,
-		numPages: 300,
-		author: authorId,
-		id: bookId,
-	})
-	const validBook = Book.create({
-		title: 'The Hobbit',
-		numPages: 300,
-		author: authorId,
-		id: bookId,
-	})
-
-	it('Prevents creating a store with invalid records', () => {
-		expect(
-			() =>
-				new Store<Book | Author>({
-					schema,
-					initialData: { [bookId]: invalidBook, [authorId]: initialAuthor },
-					props: {},
-				})
-		).toThrow()
-	})
-
-	it('Prevents updating invalid records to a store', () => {
-		const store = new Store<Book | Author>({
-			schema,
-			initialData: { [bookId]: validBook, [authorId]: initialAuthor },
-			props: {},
-		})
-
-		expect(() => {
-			store.put([invalidBook])
-		}).toThrow()
-	})
-
-	it('Prevents adding invalid records to a store', () => {
-		const newAuthorId = Author.createId('shearing')
-		const store = new Store<Book | Author>({
-			schema,
-			initialData: { [bookId]: validBook, [authorId]: initialAuthor },
-			props: {},
-		})
-
-		expect(() => {
-			store.put([
-				Author.create({
-					// @ts-expect-error - deliberately invalid data
-					name: 5,
-					id: newAuthorId,
-				}),
-			])
-		}).toThrow()
-
-		expect(store.get(newAuthorId)).toBeUndefined()
-	})
-})

package/src/lib/test/validateMigrations.test.ts

@@ -1,165 +0,0 @@
-import { validateMigrations } from '../migrate'
-
-describe(validateMigrations, () => {
-	it('should throw if a migration id is invalid', () => {
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [
-					{
-						id: 'foo.1' as any,
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-				],
-
-				sequenceId: 'foo',
-			})
-		).toThrowErrorMatchingInlineSnapshot(
-			`[Error: Every migration in sequence 'foo' must have an id starting with 'foo/'. Got invalid id: 'foo.1']`
-		)
-
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [
-					{
-						id: 'foo/one' as any,
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-				],
-
-				sequenceId: 'foo',
-			})
-		).toThrowErrorMatchingInlineSnapshot(`[Error: Invalid migration id: 'foo/one']`)
-
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [
-					{
-						id: 'foo/1' as any,
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-					{
-						id: 'foo.2' as any,
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-				],
-
-				sequenceId: 'foo',
-			})
-		).toThrowErrorMatchingInlineSnapshot(
-			`[Error: Every migration in sequence 'foo' must have an id starting with 'foo/'. Got invalid id: 'foo.2']`
-		)
-
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [
-					{
-						id: 'foo/1' as any,
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-					{
-						id: 'foo/two' as any,
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-				],
-
-				sequenceId: 'foo',
-			})
-		).toThrowErrorMatchingInlineSnapshot(`[Error: Invalid migration id: 'foo/two']`)
-	})
-
-	it('should throw if the sequenceId is invalid', () => {
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [],
-				sequenceId: 'foo/bar',
-			})
-		).toThrowErrorMatchingInlineSnapshot(`[Error: sequenceId cannot contain a '/', got foo/bar]`)
-
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [],
-				sequenceId: '',
-			})
-		).toThrowErrorMatchingInlineSnapshot(`[Error: sequenceId must be a non-empty string]`)
-	})
-
-	it('should throw if the version numbers do not start at 1', () => {
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [
-					{
-						id: 'foo/2',
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-				],
-
-				sequenceId: 'foo',
-			})
-		).toThrowErrorMatchingInlineSnapshot(
-			`[Error: Expected the first migrationId to be 'foo/1' but got 'foo/2']`
-		)
-	})
-
-	it('should throw if the version numbers do not increase monotonically', () => {
-		expect(() =>
-			validateMigrations({
-				retroactive: false,
-				sequence: [
-					{
-						id: 'foo/1',
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-					{
-						id: 'foo/2',
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-					{
-						id: 'foo/4',
-						scope: 'record',
-						up() {
-							// noop
-						},
-					},
-				],
-
-				sequenceId: 'foo',
-			})
-		).toThrowErrorMatchingInlineSnapshot(
-			`[Error: Migration id numbers must increase in increments of 1, expected foo/3 but got 'foo/4']`
-		)
-	})
-})