@contember/bindx 0.1.29 → 0.1.31

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