@tldraw/store 5.4.0-next.ebc95cf01337 → 5.4.0

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)
 			}
 		}
 	}