@tldraw/store 5.4.0-next.ef99ab47e5ce → 5.4.0

package/src/lib/ImmutableMap.ts

@@ -74,7 +74,7 @@ function cachedHashString(string: string) {
 		hashed = hashString(string)
 		if (stringHashCacheCount === STRING_HASH_CACHE_SIZE) {
 			stringHashCacheCount = 0
-			stringHashCache = {}
+			stringHashCache = Object.create(null)
 		}
 		stringHashCache[string] = hashed
 		stringHashCacheCount++
@@ -144,7 +144,9 @@ const symbolMap = Object.create(null)
 
 let _objHashUID = 0
 
-let stringHashCache: Record<string, number> = {}
+// Null-prototype so that keys named after `Object.prototype` members ('constructor', 'toString',
+// '__proto__', ...) miss the cache instead of returning the inherited member as their "hash".
+let stringHashCache: Record<string, number> = Object.create(null)
 let stringHashCacheCount = 0
 const STRING_HASH_CACHE_SIZE = 24_000
 
@@ -176,6 +178,12 @@ function arrCopy<I>(arr: Array<I>, offset = 0): Array<I> {
 	return arr.slice(offset)
 }
 
+// Key equality is SameValueZero, as in upstream Immutable.js and native `Map`: `NaN` equals `NaN`
+// and `0` equals `-0`.
+function is(a: unknown, b: unknown) {
+	return a === b || (a !== a && b !== b)
+}
+
 class OwnerID {}
 
 /**
@@ -470,7 +478,7 @@ class ArrayMapNode<K, V> {
 	get(_shift: unknown, _keyHash: unknown, key: K, notSetValue?: V) {
 		const entries = this.entries
 		for (let ii = 0, len = entries.length; ii < len; ii++) {
-			if (Object.is(key, entries[ii][0])) {
+			if (is(key, entries[ii][0])) {
 				return entries[ii][1]
 			}
 		}
@@ -492,7 +500,7 @@ class ArrayMapNode<K, V> {
 		let idx = 0
 		const len = entries.length
 		for (; idx < len; idx++) {
-			if (Object.is(key, entries[idx][0])) {
+			if (is(key, entries[idx][0])) {
 				break
 			}
 		}
@@ -710,7 +718,7 @@ class HashCollisionNode<K, V> {
 	get(shift: number, keyHash: number, key: K, notSetValue?: V) {
 		const entries = this.entries
 		for (let ii = 0, len = entries.length; ii < len; ii++) {
-			if (Object.is(key, entries[ii][0])) {
+			if (is(key, entries[ii][0])) {
 				return entries[ii][1]
 			}
 		}
@@ -745,7 +753,7 @@ class HashCollisionNode<K, V> {
 		let idx = 0
 		const len = entries.length
 		for (; idx < len; idx++) {
-			if (Object.is(key, entries[idx][0])) {
+			if (is(key, entries[idx][0])) {
 				break
 			}
 		}
@@ -796,7 +804,7 @@ class ValueNode<K, V> {
 	) {}
 
 	get(shift: number, keyHash: number, key: K, notSetValue?: V) {
-		return Object.is(key, this.entry[0]) ? this.entry[1] : notSetValue
+		return is(key, this.entry[0]) ? this.entry[1] : notSetValue
 	}
 
 	update(
@@ -809,7 +817,7 @@ class ValueNode<K, V> {
 		didAlter?: Ref
 	) {
 		const removed = value === NOT_SET
-		const keyMatch = Object.is(key, this.entry[0])
+		const keyMatch = is(key, this.entry[0])
 		if (keyMatch ? value === this.entry[1] : removed) {
 			return this
 		}

package/src/lib/IncrementalSetConstructor.test.ts

@@ -104,3 +104,13 @@ describe('IncrementalSetConstructor (ISC)', () => {
 		})
 	})
 })
+
+describe('IncrementalSetConstructor: diff shape (ISC)', () => {
+	it('[ISC2] an add/remove round trip does not leave an empty set in the diff', () => {
+		const constructor = new IncrementalSetConstructor(new Set(['a']))
+		constructor.add('b')
+		constructor.remove('b')
+		constructor.remove('a')
+		expect(constructor.get()).toEqual({ value: new Set(), diff: { removed: new Set(['a']) } })
+	})
+})

package/src/lib/IncrementalSetConstructor.ts

@@ -74,6 +74,10 @@ export class IncrementalSetConstructor<T> {
 		if (numRemoved === 0 && numAdded === 0) {
 			return undefined
 		}
+		// An add/remove round trip leaves an empty set behind; drop it so that consumers can treat
+		// the presence of `added`/`removed` as "there are additions/removals".
+		if (numAdded === 0) delete this.diff!.added
+		if (numRemoved === 0) delete this.diff!.removed
 		return { value: this.nextValue!, diff: this.diff! }
 	}
 

package/src/lib/RecordsDiff.test.ts

@@ -148,3 +148,30 @@ describe('squashing diffs (D)', () => {
 		expect(mutableTarget).toEqual(immutableResult)
 	})
 })
+
+describe('diff ownership (D)', () => {
+	it('[D2] reverseRecordsDiff does not share its collections with the input', () => {
+		const input = diff({ 'book:1': book('book:1', 'Added') })
+		const reversed = reverseRecordsDiff(input)
+		squashRecordDiffsMutable(reversed, [diff({ 'book:1': book('book:1', 'Older') })])
+		expect(input).toEqual(diff({ 'book:1': book('book:1', 'Added') }))
+	})
+
+	it('[D4] mutateFirstDiff with no diffs returns an empty diff', () => {
+		expect(squashRecordDiffs([], { mutateFirstDiff: true })).toEqual(createEmptyRecordsDiff())
+	})
+
+	it('[D4] mutateFirstDiff does not mutate the [from, to] tuples of the first diff in place', () => {
+		const v1 = book('book:1', 'v1')
+		const v2 = book('book:1', 'v2')
+		const v3 = book('book:1', 'v3')
+		const tuple: [Book, Book] = [v1, v2]
+		const first = diff({}, { 'book:1': tuple })
+		const result = squashRecordDiffs([first, diff({}, { 'book:1': [v2, v3] })], {
+			mutateFirstDiff: true,
+		})
+		expect(result).toBe(first)
+		expect(result.updated['book:1' as RecordId<Book>]).toEqual([v1, v3])
+		expect(tuple).toEqual([v1, v2])
+	})
+})

package/src/lib/RecordsDiff.ts

@@ -78,7 +78,13 @@ export function createEmptyRecordsDiff<R extends UnknownRecord>(): RecordsDiff<R
  * @public
  */
 export function reverseRecordsDiff(diff: RecordsDiff<any>) {
-	const result: RecordsDiff<any> = { added: diff.removed, removed: diff.added, updated: {} }
+	// Copy the collections rather than aliasing them: callers squash into the reversed diff
+	// (`squashRecordDiffsMutable`), which would otherwise write through to the input.
+	const result: RecordsDiff<any> = {
+		added: { ...diff.removed },
+		removed: { ...diff.added },
+		updated: {},
+	}
 	for (const [from, to] of objectMapValues(diff.updated)) {
 		result.updated[from.id] = [to, from]
 	}
@@ -162,6 +168,14 @@ export function squashRecordDiffs<T extends UnknownRecord>(
 ): RecordsDiff<T> {
 	if (options?.mutateFirstDiff) {
 		const result = diffs[0]
+		if (!result) return createEmptyRecordsDiff()
+		// The squash mutates the target's `[from, to]` tuples in place, which is only safe when the
+		// target owns them. The first diff's tuples may be shared with other holders, so copy them.
+		for (const _id in result.updated) {
+			const id = _id as IdOf<T>
+			const [from, to] = result.updated[id]
+			result.updated[id] = [from, to]
+		}
 		squashRecordDiffsMutable(result, diffs, 1)
 		return result
 	}
@@ -181,6 +195,10 @@ export function squashRecordDiffs<T extends UnknownRecord>(
  * - Updated records: Chain updates together, preserving the original 'from' state
  * - Removed records: If the record was added in this sequence, cancel both operations
  *
+ * The target's `updated` tuples are mutated in place, so the target must own them: start from
+ * `createEmptyRecordsDiff()` (or a diff built by earlier squashes into it) rather than a diff whose
+ * tuples are shared with another holder.
+ *
  * @param target - The diff to modify in-place (will be mutated)
  * @param diffs - Array of diffs to apply to the target
  * @example

package/src/lib/Store.ts

@@ -1079,6 +1079,12 @@ export class Store<R extends UnknownRecord = UnknownRecord, Props = unknown> {
 						if (!changed) changed = { ...existing } as R
 						;(changed as any)[key] = value
 					}
+					// a key the update removed (present before, absent in `to`) is a change too
+					for (const key of Object.keys(existing)) {
+						if (type.ephemeralKeySet.has(key) || Object.hasOwn(to, key)) continue
+						if (!changed) changed = { ...existing } as R
+						delete (changed as any)[key]
+					}
 					if (changed) toPut.push(changed)
 				} else {
 					toPut.push(to)
@@ -1204,11 +1210,10 @@ export class Store<R extends UnknownRecord = UnknownRecord, Props = unknown> {
 
 			if (!this.pendingAfterEvents) {
 				this.sideEffects.handleOperationComplete(source)
-			} else {
-				// if the side effects triggered by a remote operation resulted in more effects,
-				// those extra effects should not be marked as originating remotely.
-				source = 'user'
 			}
+			// Whatever the after-handlers or the operation-complete handlers changed in response to
+			// a remote operation is not itself remote: later rounds are attributed to 'user'.
+			source = 'user'
 		}
 	}
 	private _isInAtomicOp = false

package/src/lib/StoreListeners.test.ts

@@ -460,3 +460,25 @@ describe('applying diffs (H)', () => {
 		})
 	})
 })
+
+describe('applying diffs with ignoreEphemeralKeys (H)', () => {
+	it('[H10] ignoreEphemeralKeys also applies the removal of a non-ephemeral key', () => {
+		const visitId = Visit.createId('jane')
+		const visit = Visit.create({ id: visitId, visitorName: 'Jane', lastActive: 100 })
+		store.put([visit])
+
+		const { visitorName: _dropped, ...withoutName } = visit
+		store.applyDiff(
+			{
+				added: {},
+				updated: { [visitId]: [visit, withoutName as Visit] },
+				removed: {},
+			} as RecordsDiff<LibraryType>,
+			{ ignoreEphemeralKeys: true }
+		)
+
+		const result = store.get(visitId) as Visit
+		expect('visitorName' in result).toBe(false)
+		expect(result.lastActive).toBe(100)
+	})
+})

package/src/lib/StoreQueries.test.ts

@@ -801,3 +801,17 @@ describe('integration with reactive state (QI, QQ)', () => {
 		expect(tolkeinBookCount.get()).toBe(2)
 	})
 })
+
+describe('queries across rolled-back transactions (QH, QQ)', () => {
+	it('[QQ2] the query creator is called without arguments', () => {
+		const args: unknown[][] = []
+		const ids = store.query.ids('book', (...rest: unknown[]) => {
+			args.push(rest)
+			return {}
+		})
+		ids.get()
+		store.put([Book.create({ title: 'Another', authorId: authors.bradbury.id })])
+		ids.get()
+		for (const call of args) expect(call).toEqual([])
+	})
+})

package/src/lib/StoreQueries.ts

@@ -530,7 +530,10 @@ export class StoreQueries<R extends UnknownRecord> {
 				return prevValue
 			}
 		}
-		const cachedQuery = computed('ids_query:' + name, queryCreator, {
+		// Wrapped rather than passed straight through: a computed's derive function receives
+		// `(previousValue, lastComputedEpoch)`, which a queryCreator with optional parameters
+		// would otherwise misread.
+		const cachedQuery = computed('ids_query:' + name, () => queryCreator(), {
 			isEqual,
 		})
 

package/src/lib/StoreSchema.test.ts

@@ -993,6 +993,51 @@ describe('migrateStorage (MA)', () => {
 		expect(storage.setCalls).toEqual([])
 	})
 
+	it('[MA7] removes non-document records without deleting during its own entries() iteration', () => {
+		// better-sqlite3 throws on any write while a statement iterator is still open, so a delete
+		// issued from inside `for (const [id] of storage.entries())` fails on that backend
+		const SessionRecordType = createRecordType<BaseRecord<'sess', RecordId<any>>>('sess', {
+			scope: 'session',
+		})
+		// the cleanup only runs when there is something to migrate
+		const migrations = [
+			createMigrationSequence({
+				sequenceId: 'foo',
+				sequence: [{ id: 'foo/1', scope: 'record', up: () => {} }],
+			}),
+		]
+		const schema = StoreSchema.create(
+			{ test: TestRecordType, sess: SessionRecordType },
+			{ migrations }
+		)
+		const doc = makeTestRecord({ schemaVersion: 2, sequences: {} })
+		const sess = SessionRecordType.create({})
+		const storage = makeStorage<any>(
+			[
+				[doc.id, doc],
+				[sess.id, sess],
+			],
+			schema.serializeEarliestVersion()
+		)
+		let openIterators = 0
+		storage.entries = function* () {
+			openIterators++
+			try {
+				yield* Array.from(storage.map.entries())
+			} finally {
+				openIterators--
+			}
+		}
+		storage.delete = (id) => {
+			if (openIterators > 0) throw new Error('This database connection is busy executing a query')
+			storage.map.delete(id)
+		}
+
+		schema.migrateStorage(storage as any)
+
+		expect([...storage.map.keys()]).toEqual([doc.id])
+	})
+
 	it('[MA4] storage-scope migrations receive the storage and may read and write records', () => {
 		// exercised end-to-end via Store.loadStoreSnapshot in Store.test.ts; here we check the
 		// storage object passed to the migrator is the one we provided

package/src/lib/StoreSchema.ts

@@ -626,11 +626,16 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 		}
 		// Clean up by filtering out any non-document records.
 		// This is mainly legacy support for extremely early days tldraw.
+		// Collect first: as above, deleting during a live iterator can throw on SQLite backends.
+		const idsToDelete: string[] = []
 		for (const [id, state] of storage.entries()) {
 			if (this.getType(state.typeName).scope !== 'document') {
-				storage.delete(id)
+				idsToDelete.push(id)
 			}
 		}
+		for (const id of idsToDelete) {
+			storage.delete(id)
+		}
 	}
 
 	/**

package/src/lib/StoreSideEffects.test.ts

@@ -626,3 +626,34 @@ describe('atomic operations (AO)', () => {
 		])
 	})
 })
+
+describe('remote attribution (AO)', () => {
+	it('[AO8] changes made by operationComplete handlers after a remote operation are attributed to user', () => {
+		store.put([book1, book2])
+		const log: string[] = []
+		store.addHistoryInterceptor((_entry, source) => log.push('history:' + source))
+		store.sideEffects.registerAfterChangeHandler('book', (_prev, _next, source) =>
+			log.push('afterChange:' + source)
+		)
+		let once = true
+		store.sideEffects.registerOperationCompleteHandler((source) => {
+			log.push('operationComplete:' + source)
+			if (once) {
+				once = false
+				store.put([{ ...book2, title: 'renamed' }])
+			}
+		})
+
+		store.mergeRemoteChanges(() => store.remove([book1Id]))
+
+		expect(log).toEqual([
+			'history:remote',
+			'operationComplete:remote',
+			'history:user',
+			'afterChange:user',
+			'operationComplete:user',
+			// the integrity check after the merge is its own (empty) user operation
+			'operationComplete:user',
+		])
+	})
+})

package/src/lib/migrate.test.ts

@@ -375,3 +375,18 @@ describe('sortMigrations (MS)', () => {
 		).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: bar/1]`)
 	})
 })
+
+describe('sortMigrations: redundant dependencies (MS)', () => {
+	const sort = (migrations: Migration[]) => sortMigrations(migrations).map((mig) => mig.id)
+
+	it('[MS2] an explicit dependency on the implicit predecessor is not a cycle', () => {
+		expect(sort([m('foo/2', { dependsOn: ['foo/1'] }), m('foo/1')])).toEqual(['foo/1', 'foo/2'])
+	})
+
+	it('[MS2] a dependency listed twice counts once', () => {
+		expect(sort([m('bar/1', { dependsOn: ['foo/1', 'foo/1'] }), m('foo/1')])).toEqual([
+			'foo/1',
+			'bar/1',
+		])
+	})
+})

package/src/lib/migrate.ts

@@ -360,11 +360,15 @@ export function sortMigrations(migrations: Migration[]): Migration[] {
 		// Explicit dependencies
 		if (m.dependsOn) {
 			for (const depId of m.dependsOn) {
-				if (byId.has(depId)) {
-					dependents.get(depId)!.add(m.id)
-					explicitDeps.get(m.id)!.add(depId)
-					inDegree.set(m.id, inDegree.get(m.id)! + 1)
-				}
+				if (!byId.has(depId)) continue
+				explicitDeps.get(m.id)!.add(depId)
+				// A dependency that is also the implicit predecessor, or that is listed twice, must
+				// only count once: the edge is only ever removed once, so a double-counted in-degree
+				// would leave the migration unprocessed and be reported as a circular dependency.
+				const dependentsOfDep = dependents.get(depId)!
+				if (dependentsOfDep.has(m.id)) continue
+				dependentsOfDep.add(m.id)
+				inDegree.set(m.id, inDegree.get(m.id)! + 1)
 			}
 		}
 	}