@contember/bindx 0.1.30 → 0.1.32

package/src/store/RelationStore.ts

@@ -1,6 +1,14 @@
 import type { HasOneRelationState } from '../handles/types.js'
 import type { EntitySnapshot } from './snapshots.js'
 
+function setsEqual<T>(a: Set<T>, b: Set<T>): boolean {
+	if (a.size !== b.size) return false
+	for (const item of a) {
+		if (!b.has(item)) return false
+	}
+	return true
+}
+
 /**
  * Removal type for has-many items
  */
@@ -150,7 +158,8 @@ export class RelationStore {
 	 * Gets or creates has-many list state.
 	 */
 	getOrCreateHasMany(key: string, serverIds?: string[]): StoredHasManyState {
-		if (!this.hasManyStates.has(key)) {
+		const existing = this.hasManyStates.get(key)
+		if (!existing) {
 			this.hasManyStates.set(key, {
 				serverIds: new Set(serverIds ?? []),
 				orderedIds: null,
@@ -159,6 +168,16 @@ export class RelationStore {
 				createdEntities: new Set(),
 				version: 0,
 			})
+		} else if (serverIds !== undefined) {
+			const newServerIds = new Set(serverIds)
+			if (!setsEqual(existing.serverIds, newServerIds)) {
+				this.hasManyStates.set(key, {
+					...existing,
+					serverIds: newServerIds,
+					orderedIds: null,
+					version: existing.version + 1,
+				})
+			}
 		}
 
 		return this.hasManyStates.get(key)!
@@ -365,6 +384,37 @@ export class RelationStore {
 		}
 	}
 
+	/**
+	 * Connects an existing (persisted) entity to a has-many relation.
+	 * Unlike addToHasMany, does NOT add to createdEntities — used for
+	 * materializing embedded connect references to existing entities.
+	 */
+	connectExistingToHasMany(key: string, itemId: string): void {
+		const existing = this.hasManyStates.get(key)
+
+		if (!existing) {
+			this.hasManyStates.set(key, {
+				serverIds: new Set(),
+				orderedIds: [itemId],
+				plannedRemovals: new Map(),
+				plannedConnections: new Set([itemId]),
+				createdEntities: new Set(),
+				version: 0,
+			})
+		} else {
+			const newPlannedConnections = new Set(existing.plannedConnections)
+			newPlannedConnections.add(itemId)
+			const currentOrderedIds = existing.orderedIds ?? computeDefaultOrderedIds(existing)
+			const newOrderedIds = [...currentOrderedIds, itemId]
+			this.hasManyStates.set(key, {
+				...existing,
+				orderedIds: newOrderedIds,
+				plannedConnections: newPlannedConnections,
+				version: existing.version + 1,
+			})
+		}
+	}
+
 	/**
 	 * Removes an entity from a has-many relation.
 	 * For newly created entities (via add()), cancels the connection.
@@ -654,6 +704,112 @@ export class RelationStore {
 		return keys
 	}
 
+	/**
+	 * Replaces all occurrences of oldId with newId across relation and hasMany states.
+	 * Used after persist to rekey temp IDs to server-assigned IDs.
+	 */
+	replaceEntityId(oldId: string, newId: string): void {
+		// Replace in has-one relation states: currentId, serverId
+		for (const [key, state] of this.relationStates) {
+			let changed = false
+			let currentId = state.currentId
+			let serverId = state.serverId
+
+			if (currentId === oldId) { currentId = newId; changed = true }
+			if (serverId === oldId) { serverId = newId; changed = true }
+
+			if (changed) {
+				this.relationStates.set(key, { ...state, currentId, serverId, version: state.version + 1 })
+			}
+		}
+
+		// Replace in has-many states: serverIds, orderedIds, plannedConnections, createdEntities, plannedRemovals
+		for (const [key, state] of this.hasManyStates) {
+			let changed = false
+
+			let serverIds = state.serverIds
+			if (serverIds.has(oldId)) {
+				serverIds = new Set(serverIds)
+				serverIds.delete(oldId)
+				serverIds.add(newId)
+				changed = true
+			}
+
+			let orderedIds = state.orderedIds
+			if (orderedIds) {
+				const idx = orderedIds.indexOf(oldId)
+				if (idx !== -1) {
+					orderedIds = [...orderedIds]
+					orderedIds[idx] = newId
+					changed = true
+				}
+			}
+
+			let plannedConnections = state.plannedConnections
+			if (plannedConnections.has(oldId)) {
+				plannedConnections = new Set(plannedConnections)
+				plannedConnections.delete(oldId)
+				plannedConnections.add(newId)
+				changed = true
+			}
+
+			let createdEntities = state.createdEntities
+			if (createdEntities.has(oldId)) {
+				createdEntities = new Set(createdEntities)
+				createdEntities.delete(oldId)
+				createdEntities.add(newId)
+				changed = true
+			}
+
+			let plannedRemovals = state.plannedRemovals
+			if (plannedRemovals.has(oldId)) {
+				const removalType = plannedRemovals.get(oldId)!
+				plannedRemovals = new Map(plannedRemovals)
+				plannedRemovals.delete(oldId)
+				plannedRemovals.set(newId, removalType)
+				changed = true
+			}
+
+			if (changed) {
+				this.hasManyStates.set(key, {
+					serverIds,
+					orderedIds,
+					plannedRemovals,
+					plannedConnections,
+					createdEntities,
+					version: state.version + 1,
+				})
+			}
+		}
+	}
+
+	/**
+	 * Rekeys relation/hasMany entries owned by an entity (changes the parent ID in the key).
+	 */
+	rekeyOwner(oldKeyPrefix: string, newKeyPrefix: string): void {
+		const toMoveRelations: [string, StoredRelationState][] = []
+		for (const [key, value] of this.relationStates) {
+			if (key.startsWith(oldKeyPrefix)) {
+				toMoveRelations.push([key, value])
+			}
+		}
+		for (const [oldKey, value] of toMoveRelations) {
+			this.relationStates.delete(oldKey)
+			this.relationStates.set(newKeyPrefix + oldKey.slice(oldKeyPrefix.length), value)
+		}
+
+		const toMoveHasMany: [string, StoredHasManyState][] = []
+		for (const [key, value] of this.hasManyStates) {
+			if (key.startsWith(oldKeyPrefix)) {
+				toMoveHasMany.push([key, value])
+			}
+		}
+		for (const [oldKey, value] of toMoveHasMany) {
+			this.hasManyStates.delete(oldKey)
+			this.hasManyStates.set(newKeyPrefix + oldKey.slice(oldKeyPrefix.length), value)
+		}
+	}
+
 	/**
 	 * Clears all relation data.
 	 */

package/src/store/SnapshotStore.ts

@@ -46,18 +46,44 @@ export class SnapshotStore implements SnapshotVersionBumper {
 	private readonly touched = new TouchedStore()
 	private readonly dirtyTracker: DirtyTracker
 
+	/**
+	 * Tracks the last embedded data reference propagated from parent to child.
+	 * Used to detect whether the parent was re-fetched (new reference) vs. stale
+	 * embedded data that should not overwrite committed child state.
+	 * Keyed by "parentType:parentId:fieldName".
+	 */
+	private readonly lastPropagatedData = new Map<string, unknown>()
+
 	constructor() {
 		this.dirtyTracker = new DirtyTracker(this.entitySnapshots, this.meta, this.relations)
 	}
 
 	// ==================== Key Generation ====================
 
+	/** Maps temp ID entity keys to their persisted ID entity keys for transparent resolution */
+	private readonly rekeyedEntities = new Map<string, string>()
+
 	private getEntityKey(entityType: string, id: string): string {
-		return `${entityType}:${id}`
+		const key = `${entityType}:${id}`
+		return this.rekeyedEntities.get(key) ?? key
 	}
 
 	private getRelationKey(parentType: string, parentId: string, fieldName: string): string {
-		return `${parentType}:${parentId}:${fieldName}`
+		const resolvedParentId = this.resolveId(parentType, parentId)
+		return `${parentType}:${resolvedParentId}:${fieldName}`
+	}
+
+	/**
+	 * Resolves an ID to its persisted ID if it has been rekeyed.
+	 */
+	private resolveId(entityType: string, id: string): string {
+		const key = `${entityType}:${id}`
+		const rekeyed = this.rekeyedEntities.get(key)
+		if (rekeyed) {
+			// Extract the ID from the rekeyed key (format: "EntityType:id")
+			return rekeyed.slice(entityType.length + 1)
+		}
+		return id
 	}
 
 	// ==================== SnapshotVersionBumper ====================
@@ -80,6 +106,49 @@ export class SnapshotStore implements SnapshotVersionBumper {
 		}
 	}
 
+	// ==================== Embedded Data Propagation Tracking ====================
+
+	/**
+	 * Returns true if the embedded data reference differs from what was last propagated.
+	 * Uses reference identity — a new reference means the parent was re-fetched.
+	 */
+	hasEmbeddedDataChanged(parentType: string, parentId: string, fieldName: string, currentData: unknown): boolean {
+		const key = this.getRelationKey(parentType, parentId, fieldName)
+		return this.lastPropagatedData.get(key) !== currentData
+	}
+
+	/**
+	 * Records the embedded data reference that was propagated to the child.
+	 */
+	markEmbeddedDataPropagated(parentType: string, parentId: string, fieldName: string, data: unknown): void {
+		const key = this.getRelationKey(parentType, parentId, fieldName)
+		this.lastPropagatedData.set(key, data)
+	}
+
+	/**
+	 * Removes all propagation tracking entries for a given parent entity.
+	 */
+	clearPropagatedDataForEntity(parentType: string, parentId: string): void {
+		const prefix = `${parentType}:${this.resolveId(parentType, parentId)}:`
+		for (const key of this.lastPropagatedData.keys()) {
+			if (key.startsWith(prefix)) {
+				this.lastPropagatedData.delete(key)
+			}
+		}
+	}
+
+	/**
+	 * Rekeys propagation tracking entries when a temp ID is replaced by a persisted ID.
+	 */
+	private rekeyPropagatedData(oldPrefix: string, newPrefix: string): void {
+		for (const [key, value] of this.lastPropagatedData) {
+			if (key.startsWith(oldPrefix)) {
+				this.lastPropagatedData.delete(key)
+				this.lastPropagatedData.set(newPrefix + key.slice(oldPrefix.length), value)
+			}
+		}
+	}
+
 	// ==================== Entity Snapshots ====================
 
 	getEntitySnapshot<T extends object>(entityType: string, id: string): EntitySnapshot<T> | undefined {
@@ -154,6 +223,7 @@ export class SnapshotStore implements SnapshotVersionBumper {
 		const key = this.getEntityKey(entityType, id)
 		this.entitySnapshots.remove(key)
 		this.meta.clearLoadState(key)
+		this.clearPropagatedDataForEntity(entityType, id)
 		this.notifyEntitySubscribers(key)
 	}
 
@@ -218,9 +288,38 @@ export class SnapshotStore implements SnapshotVersionBumper {
 	}
 
 	mapTempIdToPersistedId(entityType: string, tempId: string, persistedId: string): void {
-		const key = this.getEntityKey(entityType, tempId)
-		this.meta.mapTempIdToPersistedId(key, persistedId)
-		this.notifyEntitySubscribers(key)
+		// Use raw keys (bypass resolveId) since we're the ones creating the mapping
+		const oldKey = `${entityType}:${tempId}`
+		const newKey = `${entityType}:${persistedId}`
+		const oldKeyPrefix = `${entityType}:${tempId}:`
+		const newKeyPrefix = `${entityType}:${persistedId}:`
+
+		// Register redirect so future lookups by temp ID resolve to persisted key
+		this.rekeyedEntities.set(oldKey, newKey)
+
+		// Rekey entity snapshot (moves data, updates id field)
+		this.entitySnapshots.rekey(oldKey, newKey, persistedId)
+
+		// Rekey metadata FIRST, then set persisted mapping (which sets existsOnServer)
+		this.meta.rekey(oldKey, newKey)
+		this.meta.mapTempIdToPersistedId(newKey, persistedId)
+
+		// Rekey subscriptions, parent-child relationships, and relation subscribers
+		this.subscriptions.rekey(oldKey, newKey, oldKeyPrefix, newKeyPrefix)
+
+		// Rekey relations/hasMany owned by this entity (parent key changes)
+		this.relations.rekeyOwner(oldKeyPrefix, newKeyPrefix)
+
+		// Replace tempId with persistedId in all relation/hasMany VALUE references
+		this.relations.replaceEntityId(tempId, persistedId)
+
+		// Rekey errors, touched state, and propagation tracking
+		this.errors.rekey(oldKey, newKey, oldKeyPrefix, newKeyPrefix)
+		this.touched.rekey(oldKeyPrefix, newKeyPrefix)
+		this.rekeyPropagatedData(oldKeyPrefix, newKeyPrefix)
+
+		// Notify on the NEW key so React picks up the change
+		this.notifyEntitySubscribers(newKey)
 	}
 
 	getPersistedId(entityType: string, id: string): string | null {
@@ -372,6 +471,17 @@ export class SnapshotStore implements SnapshotVersionBumper {
 		this.notifyRelationSubscribers(key)
 	}
 
+	connectExistingToHasMany(
+		parentType: string,
+		parentId: string,
+		fieldName: string,
+		itemId: string,
+	): void {
+		const key = this.getRelationKey(parentType, parentId, fieldName)
+		this.relations.connectExistingToHasMany(key, itemId)
+		this.notifyRelationSubscribers(key)
+	}
+
 	removeFromHasMany(
 		parentType: string,
 		parentId: string,
@@ -760,6 +870,7 @@ export class SnapshotStore implements SnapshotVersionBumper {
 		this.relations.clear()
 		this.errors.clear()
 		this.touched.clear()
+		this.lastPropagatedData.clear()
 
 		this.subscriptions.notify()
 	}

package/src/store/SubscriptionManager.ts

@@ -31,9 +31,28 @@ export class SubscriptionManager {
 	/** Parent-child relationships: childKey -> Set of parentKeys */
 	private readonly childToParents = new Map<string, Set<string>>()
 
+	/** Maps old keys → new keys after rekey, so unsubscribe closures can find migrated callbacks */
+	private readonly rekeyedKeys = new Map<string, string>()
+
 	/** Global version number for change detection */
 	private globalVersion = 0
 
+	/**
+	 * Resolves a key through the rekey redirect chain.
+	 * The rekey() method collapses chains (A→C instead of A→B→C), so this should
+	 * always resolve in one hop. The loop with depth limit is a safety net in case
+	 * chain collapsing has a bug — prevents infinite loops instead of silently hanging.
+	 */
+	private resolveKey(key: string): string {
+		let resolved = key
+		for (let depth = 0; depth < 10; depth++) {
+			const next = this.rekeyedKeys.get(resolved)
+			if (!next || next === resolved) return resolved
+			resolved = next
+		}
+		return resolved
+	}
+
 	/**
 	 * Subscribe to changes on a specific entity.
 	 * Returns unsubscribe function.
@@ -46,7 +65,8 @@ export class SubscriptionManager {
 		this.entitySubscribers.get(key)!.add(callback)
 
 		return () => {
-			this.entitySubscribers.get(key)?.delete(callback)
+			const resolvedKey = this.resolveKey(key)
+			this.entitySubscribers.get(resolvedKey)?.delete(callback)
 		}
 	}
 
@@ -62,7 +82,8 @@ export class SubscriptionManager {
 		this.relationSubscribers.get(key)!.add(callback)
 
 		return () => {
-			this.relationSubscribers.get(key)?.delete(callback)
+			const resolvedKey = this.resolveKey(key)
+			this.relationSubscribers.get(resolvedKey)?.delete(callback)
 		}
 	}
 
@@ -238,4 +259,63 @@ export class SubscriptionManager {
 			sub()
 		}
 	}
+
+	/**
+	 * Moves subscriptions and parent-child relationships from oldKey to newKey.
+	 * Also rekeys relation subscribers under oldKeyPrefix to newKeyPrefix.
+	 * Registers redirects so unsubscribe closures can find migrated callbacks.
+	 */
+	rekey(oldKey: string, newKey: string, oldKeyPrefix: string, newKeyPrefix: string): void {
+		// Register redirect for entity key (update existing chains first)
+		for (const [fromKey, toKey] of this.rekeyedKeys) {
+			if (toKey === oldKey) {
+				this.rekeyedKeys.set(fromKey, newKey)
+			}
+		}
+		this.rekeyedKeys.set(oldKey, newKey)
+
+		// Move entity subscribers
+		const entitySubs = this.entitySubscribers.get(oldKey)
+		if (entitySubs) {
+			this.entitySubscribers.delete(oldKey)
+			this.entitySubscribers.set(newKey, entitySubs)
+		}
+
+		// Move relation subscribers by prefix (e.g. "Entity:tempId:" → "Entity:persistedId:")
+		const toMoveRelations: [string, Set<Subscriber>][] = []
+		for (const [key, subs] of this.relationSubscribers) {
+			if (key.startsWith(oldKeyPrefix)) {
+				toMoveRelations.push([key, subs])
+			}
+		}
+		for (const [oldRelKey, subs] of toMoveRelations) {
+			const newRelKey = newKeyPrefix + oldRelKey.slice(oldKeyPrefix.length)
+
+			// Register redirect for relation key (update existing chains first)
+			for (const [fromKey, toKey] of this.rekeyedKeys) {
+				if (toKey === oldRelKey) {
+					this.rekeyedKeys.set(fromKey, newRelKey)
+				}
+			}
+			this.rekeyedKeys.set(oldRelKey, newRelKey)
+
+			this.relationSubscribers.delete(oldRelKey)
+			this.relationSubscribers.set(newRelKey, subs)
+		}
+
+		// Move parent-child: update child→parent mappings
+		const parents = this.childToParents.get(oldKey)
+		if (parents) {
+			this.childToParents.delete(oldKey)
+			this.childToParents.set(newKey, parents)
+		}
+
+		// Update parent-child: replace oldKey in any parent sets that reference it
+		for (const parentSet of this.childToParents.values()) {
+			if (parentSet.has(oldKey)) {
+				parentSet.delete(oldKey)
+				parentSet.add(newKey)
+			}
+		}
+	}
 }

package/src/store/TouchedStore.ts

@@ -36,6 +36,22 @@ export class TouchedStore {
 		}
 	}
 
+	/**
+	 * Rekeys all touched fields from oldKeyPrefix to newKeyPrefix.
+	 */
+	rekey(oldKeyPrefix: string, newKeyPrefix: string): void {
+		const toMove: [string, boolean][] = []
+		for (const [key, value] of this.touchedFields) {
+			if (key.startsWith(oldKeyPrefix)) {
+				toMove.push([key, value])
+			}
+		}
+		for (const [oldKey, value] of toMove) {
+			this.touchedFields.delete(oldKey)
+			this.touchedFields.set(newKeyPrefix + oldKey.slice(oldKeyPrefix.length), value)
+		}
+	}
+
 	clear(): void {
 		this.touchedFields.clear()
 	}