@tldraw/store 5.2.0-next.ee0fa4d6244f → 5.2.0

package/src/lib/StoreQueries.test.ts

@@ -1,121 +1,67 @@
-import { atom, computed, RESET_VALUE } from '@tldraw/state'
+import { atom, computed, EMPTY_ARRAY, RESET_VALUE } from '@tldraw/state'
 import { beforeEach, describe, expect, it } from 'vitest'
 import { BaseRecord, RecordId } from './BaseRecord'
 import { createRecordType } from './RecordType'
 import { Store } from './Store'
-import { StoreQueries } from './StoreQueries'
 import { StoreSchema } from './StoreSchema'
 
-// Test record types
+// Tests for SPEC.md §11 (filtered history), §12 (indexes), and §13 (id, record, and exec
+// queries). Rule IDs like [QI3] in test names refer to that document.
+
 interface Author extends BaseRecord<'author', RecordId<Author>> {
 	name: string
 	age: number
-	isActive: boolean
-	publishedBooks: number
-}
-
-interface Book extends BaseRecord<'book', RecordId<Book>> {
-	title: string
-	authorId: RecordId<Author>
-	publishedYear: number
-	inStock: boolean
-	rating: number
-	category: string
 }
-
 const Author = createRecordType<Author>('author', {
 	validator: {
 		validate(value) {
 			const author = value as Author
-			if (author.typeName !== 'author') throw Error('Invalid typeName')
-			if (!author.id.startsWith('author:')) throw Error('Invalid id')
-			if (!Number.isFinite(author.age)) throw Error('Invalid age')
-			if (author.age < 0) throw Error('Negative age')
-			if (typeof author.isActive !== 'boolean') throw Error('Invalid isActive')
+			if (author.typeName !== 'author') throw Error()
+			if (!author.id.startsWith('author:')) throw Error()
+			if (!Number.isFinite(author.age)) throw Error()
+			if (author.age < 0) throw Error()
 			return author
 		},
 	},
 	scope: 'document',
-}).withDefaultProperties(() => ({ age: 25, isActive: true, publishedBooks: 0 }))
+}).withDefaultProperties(() => ({ age: 23 }))
 
+interface Book extends BaseRecord<'book', RecordId<Book>> {
+	title: string
+	authorId: RecordId<Author>
+}
 const Book = createRecordType<Book>('book', {
 	validator: {
 		validate(value) {
 			const book = value as Book
-			if (!book.id.startsWith('book:')) throw Error('Invalid book id')
-			if (book.typeName !== 'book') throw Error('Invalid book typeName')
-			if (typeof book.title !== 'string') throw Error('Invalid title')
-			if (!book.authorId.startsWith('author')) throw Error('Invalid authorId')
-			if (!Number.isFinite(book.publishedYear)) throw Error('Invalid publishedYear')
-			if (typeof book.inStock !== 'boolean') throw Error('Invalid inStock')
+			if (!book.id.startsWith('book:')) throw Error()
+			if (book.typeName !== 'book') throw Error()
+			if (typeof book.title !== 'string') throw Error()
+			if (!book.authorId.startsWith('author')) throw Error()
 			return book
 		},
 	},
 	scope: 'document',
-}).withDefaultProperties(() => ({ rating: 0, category: 'fiction' }))
+})
 
-// Test data
 const authors = {
-	asimov: Author.create({ name: 'Isaac Asimov', age: 72, publishedBooks: 200 }),
-	gibson: Author.create({ name: 'William Gibson', age: 75, publishedBooks: 15 }),
-	herbert: Author.create({ name: 'Frank Herbert', age: 65, publishedBooks: 30 }),
-	bradbury: Author.create({ name: 'Ray Bradbury', age: 91, publishedBooks: 100, isActive: false }),
-	clarke: Author.create({ name: 'Arthur C. Clarke', age: 90, publishedBooks: 80 }),
+	tolkein: Author.create({ name: 'J.R.R. Tolkein' }),
+	bradbury: Author.create({ name: 'Ray Bradbury' }),
+	davidMitchellSerious: Author.create({ name: 'David Mitchell' }),
+	davidMitchellFunny: Author.create({ name: 'David Mitchell' }),
 }
 
 const books = {
-	foundation: Book.create({
-		title: 'Foundation',
-		authorId: authors.asimov.id,
-		publishedYear: 1951,
-		inStock: true,
-		rating: 5,
-		category: 'sci-fi',
-	}),
-	neuromancer: Book.create({
-		title: 'Neuromancer',
-		authorId: authors.gibson.id,
-		publishedYear: 1984,
-		inStock: true,
-		rating: 5,
-		category: 'cyberpunk',
-	}),
-	dune: Book.create({
-		title: 'Dune',
-		authorId: authors.herbert.id,
-		publishedYear: 1965,
-		inStock: false,
-		rating: 5,
-		category: 'sci-fi',
-	}),
-	fahrenheit451: Book.create({
-		title: 'Fahrenheit 451',
-		authorId: authors.bradbury.id,
-		publishedYear: 1953,
-		inStock: true,
-		rating: 4,
-		category: 'dystopian',
-	}),
-	childhood: Book.create({
-		title: "Childhood's End",
-		authorId: authors.clarke.id,
-		publishedYear: 1953,
-		inStock: true,
-		rating: 4,
-		category: 'sci-fi',
-	}),
-	robotSeries: Book.create({
-		title: 'I, Robot',
-		authorId: authors.asimov.id,
-		publishedYear: 1950,
-		inStock: false,
-		rating: 4,
-		category: 'sci-fi',
+	cloudAtlas: Book.create({ title: 'Cloud Atlas', authorId: authors.davidMitchellSerious.id }),
+	myLifeInComedy: Book.create({
+		title: 'My Life in Comedy',
+		authorId: authors.davidMitchellFunny.id,
 	}),
+	lotr: Book.create({ title: 'Lord of the Rings', authorId: authors.tolkein.id }),
+	farenheit: Book.create({ title: 'Farenheit 451', authorId: authors.bradbury.id }),
 }
 
 let store: Store<Author | Book>
-let queries: StoreQueries<Author | Book>
 
 beforeEach(() => {
 	store = new Store({
@@ -125,503 +71,709 @@ beforeEach(() => {
 			book: Book,
 		}),
 	})
-	queries = store.query
-
-	// Populate store with test data
-	store.put([...Object.values(authors), ...Object.values(books)])
+	store.put([
+		authors.tolkein,
+		authors.bradbury,
+		books.lotr,
+		books.farenheit,
+		authors.davidMitchellFunny,
+		authors.davidMitchellSerious,
+		books.cloudAtlas,
+		books.myLifeInComedy,
+	])
 })
 
-describe('filterHistory method', () => {
-	it('should filter changes by type correctly', () => {
-		const authorHistory = queries.filterHistory('author')
-		const initialEpoch = authorHistory.get()
+describe('filtered history (QH)', () => {
+	it('[QH1] is cached per type name', () => {
+		expect(store.query.filterHistory('author')).toBe(store.query.filterHistory('author'))
+	})
 
-		// Add a new author
-		const newAuthor = Author.create({ name: 'New Author', age: 40 })
-		store.put([newAuthor])
+	it('[QH1] contains only changes to records of the given type', () => {
+		const authorHistory = store.query.filterHistory('author')
 
-		const afterAddEpoch = authorHistory.get()
-		expect(afterAddEpoch).toBeGreaterThan(initialEpoch)
+		authorHistory.get()
 
-		// Add a book (should not affect author history)
-		const newBook = Book.create({
-			title: 'New Book',
-			authorId: newAuthor.id,
-			publishedYear: 2023,
-			inStock: true,
-			rating: 3,
-		})
-		const beforeBookAdd = authorHistory.lastChangedEpoch
-		store.put([newBook])
+		let lastChangedEpoch = authorHistory.lastChangedEpoch
 
-		// Author history should not change when book is added
-		expect(authorHistory.lastChangedEpoch).toBe(beforeBookAdd)
-	})
+		expect(authorHistory.getDiffSince(lastChangedEpoch - 1)).toBe(RESET_VALUE)
+
+		// updating an author changes the history
+		store.put([{ ...authors.davidMitchellFunny, age: 30 }])
 
-	it('should handle record updates in filtered history', () => {
-		const authorHistory = queries.filterHistory('author')
 		authorHistory.get()
 
-		const lastChangedEpoch = authorHistory.lastChangedEpoch
+		expect(lastChangedEpoch).toBeLessThan(authorHistory.lastChangedEpoch)
 
-		// Update an author
-		store.put([{ ...authors.asimov, age: 73 }])
+		expect(authorHistory.getDiffSince(lastChangedEpoch)).toMatchObject([
+			{ updated: { [authors.davidMitchellFunny.id]: [{ age: 23 }, { age: 30 }] } },
+		])
 
-		// Access the computed to trigger update
-		authorHistory.get()
+		lastChangedEpoch = authorHistory.lastChangedEpoch
 
-		expect(lastChangedEpoch).toBeLessThan(authorHistory.lastChangedEpoch)
+		// adding and removing authors shows up too
+		const newAuthor = Author.create({ name: 'Stanley Briggs' })
+		store.put([newAuthor])
+		store.remove([authors.bradbury.id])
 
-		const diff = authorHistory.getDiffSince(lastChangedEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			expect(diff[0].updated).toHaveProperty(authors.asimov.id)
-		}
+		expect(authorHistory.getDiffSince(lastChangedEpoch)).toMatchObject([
+			{
+				added: { [newAuthor.id]: { name: 'Stanley Briggs' } },
+				removed: { [authors.bradbury.id]: { name: 'Ray Bradbury' } },
+			},
+		])
 	})
 
-	it('should handle record removals in filtered history', () => {
-		const authorHistory = queries.filterHistory('author')
+	it('[QH3] changes to other types produce no observable change', () => {
+		const authorHistory = store.query.filterHistory('author')
 		authorHistory.get()
 
 		const lastChangedEpoch = authorHistory.lastChangedEpoch
 
-		// Remove an author
-		store.remove([authors.bradbury.id])
+		store.put([
+			{ ...books.lotr, title: 'The Lord of the Rings Part I: The Fellowship of the Ring' },
+		])
 
-		// Access the computed to trigger update
 		authorHistory.get()
 
-		expect(lastChangedEpoch).toBeLessThan(authorHistory.lastChangedEpoch)
+		expect(authorHistory.lastChangedEpoch).toEqual(lastChangedEpoch)
+		expect(authorHistory.getDiffSince(lastChangedEpoch)).toEqual([])
+	})
 
-		const diff = authorHistory.getDiffSince(lastChangedEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			expect(diff[0].removed).toHaveProperty(authors.bradbury.id)
-		}
+	it('[QH2] changes that cancel out in a window produce no change', () => {
+		const authorHistory = store.query.filterHistory('author')
+
+		const epoch = authorHistory.get()
+		const newAuthor = Author.create({ name: 'Stanley Briggs' })
+
+		store.put([newAuthor])
+		store.put([{ ...newAuthor, age: 38 }])
+		store.remove([newAuthor.id])
+
+		expect(authorHistory.get()).toEqual(epoch)
+
+		store.remove([authors.tolkein.id])
+		store.put([authors.tolkein])
+
+		expect(authorHistory.get()).toEqual(epoch)
+	})
+
+	it('[QH2] update entries are removed when the record is deleted', () => {
+		const authorHistory = store.query.filterHistory('author')
+
+		authorHistory.get()
+
+		const lastChangedEpoch = authorHistory.lastChangedEpoch
+
+		store.put([{ ...authors.davidMitchellFunny, age: 38 }])
+		store.put([{ ...authors.davidMitchellFunny, age: 343 }])
+		store.remove([authors.davidMitchellFunny.id])
+
+		expect(authorHistory.getDiffSince(lastChangedEpoch)).toMatchObject([
+			{
+				// shows the original, not the updated version
+				removed: { [authors.davidMitchellFunny.id]: { age: 23 } },
+			},
+		])
 	})
 
-	it('should collapse add and remove operations in same batch', () => {
-		const authorHistory = queries.filterHistory('author')
+	it('[QH2] multiple update entries collapse into one', () => {
+		const authorHistory = store.query.filterHistory('author')
+
 		authorHistory.get()
 
-		const lastEpoch = authorHistory.lastChangedEpoch
-		const tempAuthor = Author.create({ name: 'Temp Author' })
+		const lastChangedEpoch = authorHistory.lastChangedEpoch
 
-		// Add and then remove in same batch
-		store.put([tempAuthor])
-		store.remove([tempAuthor.id])
+		store.put([{ ...authors.davidMitchellFunny, age: 38 }])
+		store.put([{ ...authors.davidMitchellFunny, age: 343 }])
 
-		// Should not change history if add and remove cancel out
-		const diff = authorHistory.getDiffSince(lastEpoch)
-		expect(diff).toEqual([])
+		expect(authorHistory.getDiffSince(lastChangedEpoch)).toMatchObject([
+			{
+				updated: { [authors.davidMitchellFunny.id]: [{ age: 23 }, { age: 343 }] },
+			},
+		])
 	})
 
-	it('should handle complex diff sequences', () => {
-		const authorHistory = queries.filterHistory('author')
+	it('[QH2] an add followed by an update folds into the add', () => {
+		const authorHistory = store.query.filterHistory('author')
+
 		authorHistory.get()
 
-		const lastEpoch = authorHistory.lastChangedEpoch
-
-		// Multiple operations
-		const tempAuthor1 = Author.create({ name: 'Temp 1' })
-		const tempAuthor2 = Author.create({ name: 'Temp 2' })
-
-		store.put([tempAuthor1])
-		store.put([tempAuthor2])
-		store.put([{ ...tempAuthor1, age: 50 }]) // Update
-		store.remove([tempAuthor2.id]) // Remove
-
-		const diff = authorHistory.getDiffSince(lastEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			// Should have tempAuthor1 as added (with updated age)
-			expect(diff[0].added).toHaveProperty(tempAuthor1.id)
-			// Should not have tempAuthor2 since it was added then removed
-			expect(diff[0].added).not.toHaveProperty(tempAuthor2.id)
-			expect(diff[0].removed).not.toHaveProperty(tempAuthor2.id)
-		}
+		const lastChangedEpoch = authorHistory.lastChangedEpoch
+
+		const newAuthor = Author.create({ name: 'Stanley Briggs' })
+
+		store.put([newAuthor])
+		store.put([{ ...newAuthor, age: 38 }])
+
+		expect(authorHistory.getDiffSince(lastChangedEpoch)).toMatchObject([
+			{
+				added: { [newAuthor.id]: { age: 38 } },
+			},
+		])
 	})
 })
 
-describe('index method', () => {
-	it('should create correct index mappings', () => {
-		const nameIndex = queries.index('author', 'name')
-		const index = nameIndex.get()
+describe('indexes (QI)', () => {
+	it('[QI2] are cached per type and property', () => {
+		expect(store.query.index('author', 'name')).toBe(store.query.index('author', 'name'))
+		expect(store.query.index('author', 'name')).not.toBe(store.query.index('author', 'age'))
+	})
+
+	it('[QI1] map each property value to the ids of records with that value', () => {
+		const authorNameIndex = store.query.index('author', 'name')
+
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(new Set([authors.tolkein.id]))
+		expect(authorNameIndex.get().get('David Mitchell')).toEqual(
+			new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id])
+		)
+		expect(authorNameIndex.get().get('Nonexistent')).toBeUndefined()
 
-		expect(index.get('Isaac Asimov')).toEqual(new Set([authors.asimov.id]))
-		expect(index.get('William Gibson')).toEqual(new Set([authors.gibson.id]))
-		expect(index.get('Nonexistent')).toBeUndefined()
+		const bookTitleIndex = store.query.index('book', 'title')
+		expect(bookTitleIndex.get().get('Cloud Atlas')).toEqual(new Set([books.cloudAtlas.id]))
+		expect(bookTitleIndex.get().get('Lord of the Rings')).toEqual(new Set([books.lotr.id]))
 	})
 
-	it('should update indexes when records are added', () => {
-		const nameIndex = queries.index('author', 'name')
-		const _initialIndex = nameIndex.get()
+	it('[QI1] records whose value is undefined are not indexed', () => {
+		const newAuthor = { ...Author.create({ name: 'No Name' }), name: undefined } as any
+		const index = store.query.index('author', 'name')
+		store.put([newAuthor])
+		expect(index.get().get(undefined)).toBeUndefined()
+	})
+
+	it('[QI3] adding records updates the index, with diffs', () => {
+		const authorNameIndex = store.query.index('author', 'name')
+		// deref to make it compute once
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(new Set([authors.tolkein.id]))
 
+		let lastChangedEpoch = authorNameIndex.lastChangedEpoch
 		const newAuthor = Author.create({ name: 'New Author' })
-		const lastEpoch = nameIndex.lastChangedEpoch
 
 		store.put([newAuthor])
 
-		// Access the index to trigger the update
-		const updatedIndex = nameIndex.get()
-		expect(nameIndex.lastChangedEpoch).toBeGreaterThan(lastEpoch)
-		expect(updatedIndex.get('New Author')).toEqual(new Set([newAuthor.id]))
+		expect(authorNameIndex.get().get('New Author')).toEqual(new Set([newAuthor.id]))
 
-		const diff = nameIndex.getDiffSince(lastEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			expect(diff[0].get('New Author')).toEqual({ added: new Set([newAuthor.id]) })
-		}
-	})
+		const diff = authorNameIndex.getDiffSince(lastChangedEpoch)
+		if (diff === RESET_VALUE) throw new Error('should not be reset')
+		expect(diff).toHaveLength(1)
+		expect(diff[0].get('New Author')).toEqual({
+			added: new Set([newAuthor.id]),
+		})
+		expect(diff[0].size).toBe(1)
 
-	it('should update indexes when records are updated', () => {
-		const nameIndex = queries.index('author', 'name')
-		nameIndex.get() // Initialize
+		const moreNewAuthors = [
+			Author.create({ name: 'New Author' }),
+			Author.create({ name: 'New Author' }),
+			Author.create({ name: 'New Author' }),
+		]
 
-		const lastEpoch = nameIndex.lastChangedEpoch
+		lastChangedEpoch = authorNameIndex.lastChangedEpoch
+		store.put(moreNewAuthors)
 
-		// Update author name
-		store.put([{ ...authors.asimov, name: 'Dr. Isaac Asimov' }])
+		expect(authorNameIndex.get().get('New Author')).toEqual(
+			new Set([newAuthor.id, ...moreNewAuthors.map((a) => a.id)])
+		)
 
-		// Access the index to trigger the update
-		const updatedIndex = nameIndex.get()
-		expect(nameIndex.lastChangedEpoch).toBeGreaterThan(lastEpoch)
-		expect(updatedIndex.get('Isaac Asimov')).toBeUndefined()
-		expect(updatedIndex.get('Dr. Isaac Asimov')).toEqual(new Set([authors.asimov.id]))
+		const diff2 = authorNameIndex.getDiffSince(lastChangedEpoch)
 
-		const diff = nameIndex.getDiffSince(lastEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			expect(diff[0].get('Isaac Asimov')).toEqual({ removed: new Set([authors.asimov.id]) })
-			expect(diff[0].get('Dr. Isaac Asimov')).toEqual({ added: new Set([authors.asimov.id]) })
-		}
+		if (diff2 === RESET_VALUE) throw new Error('should not be reset')
+
+		expect(diff2).toHaveLength(1)
+		expect(diff2[0].get('New Author')).toEqual({ added: new Set(moreNewAuthors.map((a) => a.id)) })
 	})
-})
 
-describe('record method', () => {
-	it('should return single matching record', () => {
-		const asimovQuery = queries.record('author', () => ({
-			name: { eq: 'Isaac Asimov' },
-		}))
+	it('[QI3] updating a record moves its id between value sets', () => {
+		const authorNameIndex = store.query.index('author', 'name')
+
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(new Set([authors.tolkein.id]))
 
-		expect(asimovQuery.get()).toEqual(authors.asimov)
+		const lastChangedEpoch = authorNameIndex.lastChangedEpoch
+
+		store.put([{ ...authors.bradbury, name: 'J.R.R. Tolkein' }])
+
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(
+			new Set([authors.tolkein.id, authors.bradbury.id])
+		)
+
+		const diff = authorNameIndex.getDiffSince(lastChangedEpoch)
+		if (diff === RESET_VALUE) throw new Error('should not be reset')
+		expect(diff).toHaveLength(1)
+		expect(diff[0].size).toBe(2)
+		expect(diff[0].get('J.R.R. Tolkein')).toEqual({
+			added: new Set([authors.bradbury.id]),
+		})
+		expect(diff[0].get('Ray Bradbury')).toEqual({
+			removed: new Set([authors.bradbury.id]),
+		})
 	})
 
-	it('should return undefined when no match found', () => {
-		const nonexistentQuery = queries.record('author', () => ({
-			name: { eq: 'Nonexistent Author' },
-		}))
+	it('[QI3] removing records updates the index; empty value sets are dropped', () => {
+		const authorNameIndex = store.query.index('author', 'name')
+
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(new Set([authors.tolkein.id]))
+
+		let lastChangedEpoch = authorNameIndex.lastChangedEpoch
+
+		store.remove([authors.tolkein.id])
+
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(undefined)
+
+		const diff = authorNameIndex.getDiffSince(lastChangedEpoch)
+		if (diff === RESET_VALUE) throw new Error('should not be reset')
+		expect(diff).toHaveLength(1)
+		expect(diff[0].size).toBe(1)
+		expect(diff[0].get('J.R.R. Tolkein')).toEqual({
+			removed: new Set([authors.tolkein.id]),
+		})
+
+		lastChangedEpoch = authorNameIndex.lastChangedEpoch
+		store.remove([
+			authors.bradbury.id,
+			authors.davidMitchellFunny.id,
+			authors.davidMitchellSerious.id,
+		])
+
+		expect(authorNameIndex.get().get('Ray Bradbury')).toEqual(undefined)
+		expect(authorNameIndex.get().get('David Mitchell')).toEqual(undefined)
+
+		const diff2 = authorNameIndex.getDiffSince(lastChangedEpoch)
+
+		if (diff2 === RESET_VALUE) throw new Error('should not be reset')
 
-		expect(nonexistentQuery.get()).toBeUndefined()
+		expect(diff2).toHaveLength(1)
+		expect(diff2[0].size).toBe(2)
+
+		expect(diff2[0].get('Ray Bradbury')).toEqual({
+			removed: new Set([authors.bradbury.id]),
+		})
+		expect(diff2[0].get('David Mitchell')).toEqual({
+			removed: new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id]),
+		})
 	})
 
-	it('should update reactively when matching record changes', () => {
-		const query = queries.record('author', () => ({
-			name: { eq: 'Isaac Asimov' },
-		}))
+	it('[QI3] removals and additions for the same value combine in one diff', () => {
+		const authorNameIndex = store.query.index('author', 'name')
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(new Set([authors.tolkein.id]))
+
+		let lastChangedEpoch = authorNameIndex.lastChangedEpoch
+
+		// do remove first
+		store.remove([authors.tolkein.id])
+		const newAuthor = Author.create({ name: 'J.R.R. Tolkein' })
+		store.put([newAuthor])
+
+		expect(authorNameIndex.get().get('J.R.R. Tolkein')).toEqual(new Set([newAuthor.id]))
+
+		const diff = authorNameIndex.getDiffSince(lastChangedEpoch)
+
+		if (diff === RESET_VALUE) throw new Error('should not be reset')
+
+		expect(diff).toHaveLength(1)
+		expect(diff[0].size).toBe(1)
 
-		expect(query.get()?.age).toBe(72)
+		expect(diff[0].get('J.R.R. Tolkein')).toEqual({
+			removed: new Set([authors.tolkein.id]),
+			added: new Set([newAuthor.id]),
+		})
+
+		lastChangedEpoch = authorNameIndex.lastChangedEpoch
+		// do updates
+		store.put([{ ...authors.davidMitchellFunny, name: 'Ray Bradbury' }])
+		store.put([{ ...authors.bradbury, name: 'David Mitchell' }])
+
+		expect(authorNameIndex.get().get('Ray Bradbury')).toEqual(
+			new Set([authors.davidMitchellFunny.id])
+		)
+		expect(authorNameIndex.get().get('David Mitchell')).toEqual(
+			new Set([authors.bradbury.id, authors.davidMitchellSerious.id])
+		)
 
-		// Update the matching record
-		store.put([{ ...authors.asimov, age: 73 }])
+		const diff2 = authorNameIndex.getDiffSince(lastChangedEpoch)
 
-		expect(query.get()?.age).toBe(73)
+		if (diff2 === RESET_VALUE) throw new Error('should not be reset')
+
+		expect(diff2).toHaveLength(1)
+		expect(diff2[0].size).toBe(2)
+
+		expect(diff2[0].get('Ray Bradbury')).toEqual({
+			added: new Set([authors.davidMitchellFunny.id]),
+			removed: new Set([authors.bradbury.id]),
+		})
+		expect(diff2[0].get('David Mitchell')).toEqual({
+			added: new Set([authors.bradbury.id]),
+			removed: new Set([authors.davidMitchellFunny.id]),
+		})
 	})
 
-	it('should handle reactive query parameters', () => {
-		const targetName = atom('targetName', 'Isaac Asimov')
+	it('[QI4] keeps the same map object if the indexed values did not change', () => {
+		const authorNameIndex = store.query.index('author', 'name')
 
-		const query = queries.record('author', () => ({
-			name: { eq: targetName.get() },
-		}))
+		const value = authorNameIndex.get()
+		const lastChangedEpoch = authorNameIndex.lastChangedEpoch
 
-		expect(query.get()).toEqual(authors.asimov)
+		// change a property the index does not cover
+		store.put([{ ...authors.tolkein, age: 23 }])
+		store.put([{ ...authors.tolkein, age: 99 }])
 
-		targetName.set('William Gibson')
-		expect(query.get()).toEqual(authors.gibson)
+		expect(authorNameIndex.get()).toBe(value)
+		expect(authorNameIndex.lastChangedEpoch).toBe(lastChangedEpoch)
 	})
 
-	it('should handle complex query conditions', () => {
-		const query = queries.record('author', () => ({
-			age: { gt: 70 },
-			isActive: { eq: true },
-		}))
+	it('[QI5] a backslash-delimited property indexes a nested path', () => {
+		interface Doc extends BaseRecord<'doc', RecordId<Doc>> {
+			metadata: { sessionId?: string }
+		}
+		const Doc = createRecordType<Doc>('doc', { scope: 'document' })
+		const docStore = new Store({
+			props: {},
+			schema: StoreSchema.create<Doc>({ doc: Doc }),
+		})
 
-		const result = query.get()
-		expect(result).toBeDefined()
-		expect(result!.age).toBeGreaterThan(70)
-		expect(result!.isActive).toBe(true)
+		const docA = Doc.create({ metadata: { sessionId: 'alpha' } })
+		const docB = Doc.create({ metadata: { sessionId: 'beta' } })
+		const docNone = Doc.create({ metadata: {} })
+		docStore.put([docA, docB, docNone])
+
+		const index = docStore.query.index('doc', 'metadata\\sessionId')
+		expect(index.get().get('alpha')).toEqual(new Set([docA.id]))
+		expect(index.get().get('beta')).toEqual(new Set([docB.id]))
+		// missing nested values are not indexed
+		expect(index.get().get(undefined)).toBeUndefined()
+
+		// incremental updates work through the nested path
+		docStore.update(docA.id, (d) => ({ ...d, metadata: { sessionId: 'beta' } }))
+		expect(index.get().get('alpha')).toBeUndefined()
+		expect(index.get().get('beta')).toEqual(new Set([docB.id, docA.id]))
 	})
 })
 
-describe('records method', () => {
-	it('should return all records of type when no query provided', () => {
-		const allBooks = queries.records('book')
-		const books = allBooks.get()
+describe('id queries (QQ)', () => {
+	it('[QQ1] with no query, contains all ids of the type', () => {
+		const bookQuery = store.query.ids('book')
 
-		expect(books).toHaveLength(6)
-		expect(books.every((book) => book.typeName === 'book')).toBe(true)
+		expect(bookQuery.get()).toEqual(
+			new Set([books.cloudAtlas.id, books.farenheit.id, books.lotr.id, books.myLifeInComedy.id])
+		)
+
+		const authorQuery = store.query.ids('author')
+
+		expect(authorQuery.get()).toEqual(
+			new Set([
+				authors.bradbury.id,
+				authors.davidMitchellFunny.id,
+				authors.davidMitchellSerious.id,
+				authors.tolkein.id,
+			])
+		)
+
+		const newAuthor = Author.create({ name: 'J.R.R. Tolkein' })
+		const newBook = Book.create({ title: 'The Hobbit', authorId: newAuthor.id })
+		store.put([newAuthor, newBook])
+
+		expect(bookQuery.get()).toContain(newBook.id)
+		expect(authorQuery.get()).toContain(newAuthor.id)
 	})
 
-	it('should filter records by query conditions', () => {
-		const inStockBooks = queries.records('book', () => ({
-			inStock: { eq: true },
+	it('[QQ1] filters ids by the query expression', () => {
+		const jrr = store.query.ids('author', () => ({
+			name: { eq: 'J.R.R. Tolkein' },
 		}))
+		expect(jrr.get()).toEqual(new Set([authors.tolkein.id]))
 
-		const books = inStockBooks.get()
-		expect(books.every((book) => book.inStock === true)).toBe(true)
-		expect(books.length).toBeGreaterThan(0)
+		const mitchell = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
+		}))
+		expect(mitchell.get()).toEqual(
+			new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id])
+		)
+
+		store.put([{ ...authors.davidMitchellFunny, age: 30 }])
+		const mitchell30 = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
+			age: { eq: 30 },
+		}))
+		expect(mitchell30.get()).toEqual(new Set([authors.davidMitchellFunny.id]))
 	})
 
-	it('should handle multiple query conditions', () => {
-		const query = queries.records('book', () => ({
-			category: { eq: 'sci-fi' },
-			rating: { eq: 5 },
+	it('[QQ1] emits collection diffs as records change', () => {
+		const mitchell = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
 		}))
 
-		const books = query.get()
-		expect(books.every((book) => book.category === 'sci-fi' && book.rating === 5)).toBe(true)
+		mitchell.get()
+		const lastEpoch = mitchell.lastChangedEpoch
+
+		const newAuthor = Author.create({ name: 'David Mitchell' })
+		store.put([newAuthor])
+		store.remove([authors.davidMitchellFunny.id])
+
+		const diff = mitchell.getDiffSince(lastEpoch)
+		if (diff === RESET_VALUE) throw new Error('should not be reset')
+		expect(diff).toHaveLength(1)
+		expect(diff[0]).toEqual({
+			added: new Set([newAuthor.id]),
+			removed: new Set([authors.davidMitchellFunny.id]),
+		})
 	})
 
-	it('should update reactively when records are added', () => {
-		const allBooks = queries.records('book')
-		const initialCount = allBooks.get().length
+	it('[QQ2] a reactive query expression rebuilds with a correct diff when it changes', () => {
+		store.put([{ ...authors.davidMitchellFunny, age: 30 }])
+
+		const currentAuthor = atom('currentAuthor', 'David Mitchell')
+		const currentAge = atom('currentAge', 30)
+
+		const mitchell30 = store.query.ids('author', () => ({
+			name: { eq: currentAuthor.get() },
+			age: { eq: currentAge.get() },
+		}))
+
+		expect(mitchell30.get()).toEqual(new Set([authors.davidMitchellFunny.id]))
+
+		let lastChangedEpoch = mitchell30.lastChangedEpoch
+		currentAge.set(23)
+
+		expect(mitchell30.get()).toEqual(new Set([authors.davidMitchellSerious.id]))
+
+		const diff = mitchell30.getDiffSince(lastChangedEpoch)
+
+		if (diff === RESET_VALUE) throw new Error('should not be reset')
 
-		const newBook = Book.create({
-			title: 'New Book',
-			authorId: authors.asimov.id,
-			publishedYear: 2023,
-			inStock: true,
-			rating: 3,
+		expect(diff).toHaveLength(1)
+		expect(diff[0]).toEqual({
+			added: new Set([authors.davidMitchellSerious.id]),
+			removed: new Set([authors.davidMitchellFunny.id]),
 		})
 
-		store.put([newBook])
+		currentAuthor.set('J.R.R. Tolkein')
 
-		expect(allBooks.get()).toHaveLength(initialCount + 1)
-		expect(allBooks.get().some((book) => book.id === newBook.id)).toBe(true)
-	})
+		lastChangedEpoch = mitchell30.lastChangedEpoch
+
+		expect(mitchell30.get()).toEqual(new Set([authors.tolkein.id]))
 
-	it('should update reactively when records are removed', () => {
-		const allBooks = queries.records('book')
-		const initialCount = allBooks.get().length
+		const diff2 = mitchell30.getDiffSince(lastChangedEpoch)
 
-		store.remove([books.dune.id])
+		if (diff2 === RESET_VALUE) throw new Error('should not be reset')
 
-		expect(allBooks.get()).toHaveLength(initialCount - 1)
-		expect(allBooks.get().some((book) => book.id === books.dune.id)).toBe(false)
+		expect(diff2).toHaveLength(1)
+		expect(diff2[0]).toEqual({
+			added: new Set([authors.tolkein.id]),
+			removed: new Set([authors.davidMitchellSerious.id]),
+		})
 	})
 
-	it('should update reactively when records are updated', () => {
-		const inStockBooks = queries.records('book', () => ({
-			inStock: { eq: true },
+	it('[QQ1] supports not-equals matches', () => {
+		store.put([{ ...authors.davidMitchellFunny, age: 30 }])
+		const mitchell = store.query.ids('author', () => ({
+			name: { neq: 'David Mitchell' },
 		}))
 
-		const initialBooks = inStockBooks.get()
-		const initialCount = initialBooks.length
+		expect(mitchell.get()).toEqual(new Set([authors.tolkein.id, authors.bradbury.id]))
 
-		// Update a book to be out of stock
-		store.put([{ ...books.foundation, inStock: false }])
+		const ageNot23 = store.query.ids('author', () => ({
+			age: { neq: 23 },
+		}))
 
-		const updatedBooks = inStockBooks.get()
-		expect(updatedBooks).toHaveLength(initialCount - 1)
-		expect(updatedBooks.some((book) => book.id === books.foundation.id)).toBe(false)
+		expect(ageNot23.get()).toEqual(new Set([authors.davidMitchellFunny.id]))
 	})
 
-	it('should handle reactive query parameters', () => {
-		const targetCategory = atom('targetCategory', 'sci-fi')
-
-		const query = queries.records('book', () => ({
-			category: { eq: targetCategory.get() },
+	it('[QQ1] updates as records are added, removed, and updated', () => {
+		const mitchell = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
+			age: { neq: 30 },
 		}))
 
-		const sciFiBooks = query.get()
-		expect(sciFiBooks.every((book) => book.category === 'sci-fi')).toBe(true)
+		expect(mitchell.get()).toEqual(
+			new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id])
+		)
 
-		targetCategory.set('cyberpunk')
-		const cyberpunkBooks = query.get()
-		expect(cyberpunkBooks.every((book) => book.category === 'cyberpunk')).toBe(true)
-		expect(cyberpunkBooks).toHaveLength(1)
-		expect(cyberpunkBooks[0]).toEqual(books.neuromancer)
-	})
-})
+		store.put([{ ...authors.davidMitchellFunny, age: 30 }])
+		expect(mitchell.get()).toEqual(new Set([authors.davidMitchellSerious.id]))
 
-describe('ids method', () => {
-	it('should return set of all record IDs when no query provided', () => {
-		const allBookIds = queries.ids('book')
-		const ids = allBookIds.get()
+		store.put([{ ...authors.davidMitchellFunny, age: 23 }])
+		expect(mitchell.get()).toEqual(
+			new Set([authors.davidMitchellSerious.id, authors.davidMitchellFunny.id])
+		)
 
-		expect(ids).toBeInstanceOf(Set)
-		expect(ids.size).toBe(6)
-		Object.values(books).forEach((book) => {
-			expect(ids.has(book.id)).toBe(true)
-		})
+		store.remove([authors.davidMitchellFunny.id])
+		expect(mitchell.get()).toEqual(new Set([authors.davidMitchellSerious.id]))
+
+		const newAuthor = Author.create({ name: 'David Mitchell' })
+		store.put([newAuthor])
+		expect(mitchell.get()).toEqual(new Set([authors.davidMitchellSerious.id, newAuthor.id]))
 	})
 
-	it('should filter IDs by query conditions', () => {
-		const highRatedIds = queries.ids('book', () => ({
-			rating: { eq: 5 },
+	it('[QQ3] does not change if unrelated records are added, updated, or removed', () => {
+		const mitchell = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
 		}))
 
-		const ids = highRatedIds.get()
-		expect(ids).toBeInstanceOf(Set)
+		expect(mitchell.get()).toEqual(
+			new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id])
+		)
 
-		// Verify all returned IDs match the criteria
-		ids.forEach((id) => {
-			const book = store.get(id)!
-			expect(book.rating).toBe(5)
-		})
+		const lastChangedEpoch = mitchell.lastChangedEpoch
+
+		const newAuthor = Author.create({ name: 'William Shakespeare' })
+		store.put([newAuthor])
+
+		mitchell.get()
+		expect(mitchell.lastChangedEpoch).toEqual(lastChangedEpoch)
+
+		store.remove([authors.tolkein.id])
+
+		mitchell.get()
+		expect(mitchell.lastChangedEpoch).toEqual(lastChangedEpoch)
 	})
 
-	it('should update with collection diffs when records change', () => {
-		const inStockIds = queries.ids('book', () => ({
-			inStock: { eq: true },
+	it('[QQ3] does not change if matching records change in irrelevant ways', () => {
+		const mitchell = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
 		}))
 
-		const _initialIds = inStockIds.get()
-		const lastEpoch = inStockIds.lastChangedEpoch
+		expect(mitchell.get()).toEqual(
+			new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id])
+		)
 
-		// Add a new book
-		const newBook = Book.create({
-			title: 'New In-Stock Book',
-			authorId: authors.asimov.id,
-			publishedYear: 2023,
-			inStock: true,
-			rating: 4,
-		})
-		store.put([newBook])
+		const lastChangedEpoch = mitchell.lastChangedEpoch
 
-		const updatedIds = inStockIds.get()
-		expect(updatedIds.has(newBook.id)).toBe(true)
+		store.put([{ ...authors.davidMitchellFunny, age: 30 }])
 
-		const diff = inStockIds.getDiffSince(lastEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			expect(diff[0].added?.has(newBook.id)).toBe(true)
-		}
-	})
+		mitchell.get()
+		expect(mitchell.lastChangedEpoch).toEqual(lastChangedEpoch)
 
-	it('should handle reactive query parameters with from-scratch rebuild', () => {
-		const targetYear = atom('targetYear', 1950)
+		// a change that does affect the query, just to check
+		store.put([{ ...authors.davidMitchellFunny, name: 'steve' }])
 
-		const query = queries.ids('book', () => ({
-			publishedYear: { gt: targetYear.get() },
+		mitchell.get()
+		expect(mitchell.lastChangedEpoch).toBeGreaterThan(lastChangedEpoch)
+	})
+
+	it('[QQ3] round trips (remove/add-back, add/remove) leave the set unchanged', () => {
+		const mitchell = store.query.ids('author', () => ({
+			name: { eq: 'David Mitchell' },
 		}))
 
-		const initialIds = query.get()
-		const initialSize = initialIds.size
+		expect(mitchell.get()).toEqual(
+			new Set([authors.davidMitchellFunny.id, authors.davidMitchellSerious.id])
+		)
 
-		// Change query parameter should trigger from-scratch rebuild
-		const lastEpoch = query.lastChangedEpoch
-		targetYear.set(1970)
+		const lastChangedEpoch = mitchell.lastChangedEpoch
 
-		const updatedIds = query.get()
-		expect(query.lastChangedEpoch).toBeGreaterThan(lastEpoch)
+		store.remove([authors.davidMitchellFunny.id])
+		store.put([authors.davidMitchellFunny])
 
-		// Should have fewer results with higher year threshold
-		expect(updatedIds.size).toBeLessThan(initialSize)
+		mitchell.get()
+		expect(mitchell.lastChangedEpoch).toEqual(lastChangedEpoch)
 
-		updatedIds.forEach((id) => {
-			const book = store.get(id)!
-			expect(book.publishedYear).toBeGreaterThan(1970)
-		})
+		const newMitchell = Author.create({ name: 'David Mitchell' })
+		store.put([newMitchell])
+		store.remove([newMitchell.id])
+
+		mitchell.get()
+		expect(mitchell.lastChangedEpoch).toEqual(lastChangedEpoch)
 	})
+})
+
+const bookComparator = (a: Book, b: Book) => a.title.localeCompare(b.title)
+
+describe('record queries (QQ)', () => {
+	it('[QQ4] records() returns all matching records', () => {
+		const allBooks = store.query.records('book')
+
+		expect(allBooks.get().sort(bookComparator)).toEqual(
+			[books.cloudAtlas, books.farenheit, books.lotr, books.myLifeInComedy].sort(bookComparator)
+		)
 
-	it('should efficiently handle incremental updates', () => {
-		const query = queries.ids('book', () => ({
-			inStock: { eq: true },
+		const farenheit = store.query.records('book', () => ({
+			title: { eq: 'Farenheit 451' },
 		}))
+		expect(farenheit.get()).toEqual([books.farenheit])
 
-		query.get() // Initialize
-		const lastEpoch = query.lastChangedEpoch
+		const funnyGuide = Book.create({
+			title: 'How to be a funny man',
+			authorId: authors.davidMitchellFunny.id,
+		})
+		store.put([funnyGuide])
+		const mitchell = store.query.records('book', () => ({
+			authorId: { eq: authors.davidMitchellFunny.id },
+		}))
+		expect(mitchell.get().sort(bookComparator)).toEqual(
+			[books.myLifeInComedy, funnyGuide].sort(bookComparator)
+		)
+	})
 
-		// Update a book's stock status
-		store.put([{ ...books.dune, inStock: true }])
+	it('[QQ4] records() keeps the same array when the members did not change', () => {
+		const allBooks = store.query.records('book')
+		const value = allBooks.get()
 
-		const diff = query.getDiffSince(lastEpoch)
-		expect(diff).not.toBe(RESET_VALUE)
-		if (diff !== RESET_VALUE) {
-			expect(diff).toHaveLength(1)
-			expect(diff[0].added?.has(books.dune.id)).toBe(true)
-		}
+		// updating an author does not change the book array members
+		store.put([{ ...authors.tolkein, age: 50 }])
+		expect(allBooks.get()).toBe(value)
 	})
-})
 
-describe('exec method', () => {
-	it('should execute non-reactive queries', () => {
-		const result = queries.exec('author', {
-			isActive: { eq: true },
-		})
+	it('[QQ4] records() supports reactive query expressions', () => {
+		const currentAuthor = atom('currentAuthor', authors.davidMitchellFunny.id)
+		const booksQuery = store.query.records('book', () => ({
+			authorId: { eq: currentAuthor.get() },
+		}))
+
+		expect(booksQuery.get()).toEqual([books.myLifeInComedy])
+
+		currentAuthor.set(authors.tolkein.id)
 
-		expect(Array.isArray(result)).toBe(true)
-		expect(result.every((author) => author.isActive === true)).toBe(true)
+		expect(booksQuery.get()).toEqual([books.lotr])
 	})
 
-	it('should handle complex query conditions', () => {
-		const result = queries.exec('book', {
-			rating: { eq: 5 },
-			category: { eq: 'sci-fi' },
-		})
+	it('[QQ4] record() returns one matching record or undefined', () => {
+		const farenheit = store.query.record('book', () => ({
+			title: { eq: 'Farenheit 451' },
+		}))
+		expect(farenheit.get()).toEqual(books.farenheit)
 
-		expect(result.every((book) => book.rating === 5 && book.category === 'sci-fi')).toBe(true)
-		expect(result.length).toBeGreaterThan(0)
+		const nonexistent = store.query.record('book', () => ({
+			title: { eq: 'No Such Book' },
+		}))
+		expect(nonexistent.get()).toBeUndefined()
 	})
-})
 
-describe('integration with reactive state', () => {
-	it('should work with computed values', () => {
-		const booksByCategory = computed('books-by-category', () => {
-			const categoryIndex = queries.index('book', 'category')
-			const sciFiBooks = categoryIndex.get().get('sci-fi') || new Set()
-			return sciFiBooks.size
-		})
+	it('[QQ4] record() updates reactively', () => {
+		const tolkein = store.query.record('author', () => ({
+			name: { eq: 'J.R.R. Tolkein' },
+		}))
+		expect(tolkein.get()?.age).toBe(23)
 
-		const initialCount = booksByCategory.get()
-		expect(initialCount).toBeGreaterThan(0)
-
-		// Add a sci-fi book
-		const newSciFiBook = Book.create({
-			title: 'New Sci-Fi',
-			authorId: authors.asimov.id,
-			publishedYear: 2023,
-			inStock: true,
-			rating: 4,
-			category: 'sci-fi',
-		})
-		store.put([newSciFiBook])
+		store.put([{ ...authors.tolkein, age: 81 }])
+		expect(tolkein.get()?.age).toBe(81)
 
-		expect(booksByCategory.get()).toBe(initialCount + 1)
+		store.remove([authors.tolkein.id])
+		expect(tolkein.get()).toBeUndefined()
 	})
 
-	it('should propagate changes through multiple reactive layers', () => {
-		const authorBookCounts = computed('author-book-counts', () => {
-			const authorIndex = queries.index('book', 'authorId')
-			const counts = new Map()
-
-			for (const [authorId, bookIds] of authorIndex.get()) {
-				counts.set(authorId, bookIds.size)
-			}
+	it('[QQ5] exec runs a one-shot, non-reactive query', () => {
+		const mitchells = store.query.exec('author', { name: { eq: 'David Mitchell' } })
+		expect(new Set(mitchells)).toEqual(
+			new Set([authors.davidMitchellFunny, authors.davidMitchellSerious])
+		)
 
-			return counts
-		})
+		// not reactive: subsequent store changes don't affect the returned array
+		store.put([Author.create({ name: 'David Mitchell' })])
+		expect(mitchells).toHaveLength(2)
+	})
 
-		const asimovInitialCount = authorBookCounts.get().get(authors.asimov.id) || 0
+	it('[QQ5] exec returns the shared empty array when nothing matches', () => {
+		expect(store.query.exec('author', { name: { eq: 'No Such Author' } })).toBe(EMPTY_ARRAY)
+	})
+})
 
-		// Add book by Asimov
-		const newAsimovBook = Book.create({
-			title: 'New Asimov Book',
-			authorId: authors.asimov.id,
-			publishedYear: 2023,
-			inStock: true,
-			rating: 4,
+describe('integration with reactive state (QI, QQ)', () => {
+	it('[QI3] computed values see index updates', () => {
+		const tolkeinBookCount = computed('tolkein-books', () => {
+			const byAuthor = store.query.index('book', 'authorId')
+			return byAuthor.get().get(authors.tolkein.id)?.size ?? 0
 		})
-		store.put([newAsimovBook])
 
-		expect(authorBookCounts.get().get(authors.asimov.id)).toBe(asimovInitialCount + 1)
+		expect(tolkeinBookCount.get()).toBe(1)
+
+		store.put([Book.create({ title: 'The Hobbit', authorId: authors.tolkein.id })])
+		expect(tolkeinBookCount.get()).toBe(2)
 	})
 })