@contember/bindx 0.1.29 → 0.1.31

package/src/persistence/MutationCollector.ts

@@ -32,6 +32,8 @@ export interface EntityMutationResult {
 export class MutationCollector implements MutationDataCollector {
 	private excludedEntityIds: ReadonlySet<string> = new Set()
 	private readonly _nestedEntityIds: Set<string> = new Set()
+	/** Maps nested entity temp IDs to their entity types for post-persist processing */
+	private readonly _nestedEntityTypes: Map<string, string> = new Map()
 
 	constructor(
 		private readonly store: SnapshotStore,
@@ -46,6 +48,7 @@ export class MutationCollector implements MutationDataCollector {
 	setExcludedEntities(ids: ReadonlySet<string>): void {
 		this.excludedEntityIds = ids
 		this._nestedEntityIds.clear()
+		this._nestedEntityTypes.clear()
 	}
 
 	/**
@@ -57,6 +60,14 @@ export class MutationCollector implements MutationDataCollector {
 		return this._nestedEntityIds
 	}
 
+	/**
+	 * Returns a map of nested entity temp IDs to their entity types.
+	 * Used by BatchPersister to commit and map IDs for nested entities after persist.
+	 */
+	getNestedEntityTypes(): ReadonlyMap<string, string> {
+		return this._nestedEntityTypes
+	}
+
 	// ==================== Main Collection Methods ====================
 
 	/**
@@ -175,23 +186,22 @@ export class MutationCollector implements MutationDataCollector {
 			}
 		}
 
-		// Collect relation values
+		// Materialize embedded relation data into store entities,
+		// then collect from store for consistent tracking and post-persist ID mapping
+		this.materializeEntityRelations(entityType, entityId)
+
+		// Collect relation values from store
 		const relationFields = this.schemaProvider.getRelationFields(entityType)
 		for (const fieldName of relationFields) {
-			const value = data[fieldName]
 			const relationType = this.schemaProvider.getRelationType(entityType, fieldName)
 
 			if (relationType === 'hasOne') {
-				// Check embedded data first, then fall back to RelationStore
-				const relationOp = this.collectCreateOneRelation(value)
-					?? this.collectHasOneOperation(entityType, entityId, fieldName)
+				const relationOp = this.collectHasOneOperation(entityType, entityId, fieldName)
 				if (relationOp !== null) {
 					createData[fieldName] = relationOp
 				}
 			} else if (relationType === 'hasMany') {
-				// Try embedded data first, then fall back to RelationStore
-				const relationOps = this.collectCreateManyRelation(value)
-					?? this.collectHasManyOperations(entityType, entityId, fieldName)
+				const relationOps = this.collectHasManyOperations(entityType, entityId, fieldName)
 				if (relationOps !== null && relationOps.length > 0) {
 					createData[fieldName] = relationOps
 				}
@@ -332,6 +342,7 @@ export class MutationCollector implements MutationDataCollector {
 						this._nestedEntityIds.add(currentId)
 						const targetType = this.schemaProvider.getRelationTarget(entityType, fieldName)
 						if (targetType) {
+							this._nestedEntityTypes.set(currentId, targetType)
 							const createData = this.collectCreateData(targetType, currentId)
 							return { create: createData ?? {} }
 						}
@@ -437,20 +448,13 @@ export class MutationCollector implements MutationDataCollector {
 			}
 		}
 
-		// Created entities -> create (using entity snapshot data)
+		// Created entities -> create (using collectCreateData for full recursive collection)
 		if (targetType) {
 			for (const tempId of hasManyState.createdEntities) {
 				this._nestedEntityIds.add(tempId)
-				const itemSnapshot = this.store.getEntitySnapshot(targetType, tempId)
-				if (itemSnapshot) {
-					const createData = { ...itemSnapshot.data as Record<string, unknown> }
-					delete createData['id']
-					if (Object.keys(createData).length > 0) {
-						operations.push({ create: this.processNestedData(createData), alias: tempId })
-					} else {
-						operations.push({ create: {}, alias: tempId })
-					}
-				}
+				this._nestedEntityTypes.set(tempId, targetType)
+				const createData = this.collectCreateData(targetType, tempId)
+				operations.push({ create: createData ?? {}, alias: tempId })
 			}
 		}
 
@@ -587,4 +591,148 @@ export class MutationCollector implements MutationDataCollector {
 	private isExistingEntity(id: string): boolean {
 		return isPersistedId(id)
 	}
+
+	// ==================== Embedded Data Materialization ====================
+
+	/**
+	 * Materializes embedded relation data in an entity's snapshot into proper
+	 * store entities and relations. This normalizes inline objects (e.g.
+	 * `reviews: [{ reviewType: 'expert' }]`) into tracked entities with temp IDs,
+	 * enabling proper post-persist ID mapping and commit.
+	 */
+	private materializeEntityRelations(entityType: string, entityId: string): void {
+		if (!this.schemaProvider.hasEntity(entityType)) return
+
+		const snapshot = this.store.getEntitySnapshot(entityType, entityId)
+		if (!snapshot) return
+
+		const data = snapshot.data as Record<string, unknown>
+		const relationFields = this.schemaProvider.getRelationFields(entityType)
+
+		for (const fieldName of relationFields) {
+			const value = data[fieldName]
+			if (value === null || value === undefined) continue
+
+			const relationType = this.schemaProvider.getRelationType(entityType, fieldName)
+
+			if (relationType === 'hasOne' && typeof value === 'object' && !Array.isArray(value)) {
+				this.materializeEmbeddedHasOne(entityType, entityId, fieldName, value as Record<string, unknown>)
+			} else if (relationType === 'hasMany' && Array.isArray(value) && value.length > 0) {
+				this.materializeEmbeddedHasMany(entityType, entityId, fieldName, value)
+			}
+		}
+	}
+
+	/**
+	 * Materializes an embedded hasMany array into store entities.
+	 * Skips if the hasMany state already has store-managed entities.
+	 */
+	private materializeEmbeddedHasMany(
+		entityType: string,
+		entityId: string,
+		fieldName: string,
+		items: unknown[],
+	): void {
+		const targetType = this.schemaProvider.getRelationTarget(entityType, fieldName)
+		if (!targetType) return
+
+		// Skip if store already has managed entities for this relation
+		const existing = this.store.getHasMany(entityType, entityId, fieldName)
+		if (existing && (existing.createdEntities.size > 0 || existing.plannedConnections.size > 0)) {
+			return
+		}
+
+		this.store.getOrCreateHasMany(entityType, entityId, fieldName, [])
+
+		for (const item of items) {
+			if (typeof item !== 'object' || item === null) continue
+			const obj = item as Record<string, unknown>
+			const id = obj['id'] as string | undefined
+
+			if (id && !isTempId(id) && isPersistedId(id)) {
+				// Existing entity — add as a planned connection (not created)
+				this.store.connectExistingToHasMany(entityType, entityId, fieldName, id)
+				continue
+			}
+
+			// Create store entity from embedded data
+			const entityData = { ...obj }
+			delete entityData['id']
+			const tempId = this.store.createEntity(targetType, entityData)
+			this.store.addToHasMany(entityType, entityId, fieldName, tempId)
+
+			// Recursively materialize nested relations in the new entity
+			this.materializeEntityRelations(targetType, tempId)
+		}
+
+		// Clear embedded array from parent snapshot
+		this.clearEmbeddedField(entityType, entityId, fieldName, [])
+	}
+
+	/**
+	 * Materializes an embedded hasOne object into a store entity and relation.
+	 * Skips if a relation already exists in the store for this field.
+	 */
+	private materializeEmbeddedHasOne(
+		entityType: string,
+		entityId: string,
+		fieldName: string,
+		obj: Record<string, unknown>,
+	): void {
+		// Skip if relation already exists in store
+		const existingRelation = this.store.getRelation(entityType, entityId, fieldName)
+		if (existingRelation) return
+
+		const targetType = this.schemaProvider.getRelationTarget(entityType, fieldName)
+		if (!targetType) return
+
+		const id = obj['id'] as string | undefined
+
+		if (id && !isTempId(id) && isPersistedId(id)) {
+			// Existing entity — create a connect relation
+			this.store.getOrCreateRelation(entityType, entityId, fieldName, {
+				currentId: id,
+				serverId: null,
+				state: 'connected',
+				serverState: 'disconnected',
+				placeholderData: {},
+			})
+		} else {
+			// New entity — create store entity and connect
+			const entityData = { ...obj }
+			delete entityData['id']
+			const tempId = this.store.createEntity(targetType, entityData)
+
+			this.store.getOrCreateRelation(entityType, entityId, fieldName, {
+				currentId: tempId,
+				serverId: null,
+				state: 'connected',
+				serverState: 'disconnected',
+				placeholderData: {},
+			})
+
+			// Recursively materialize nested relations
+			this.materializeEntityRelations(targetType, tempId)
+		}
+
+		// Clear embedded data from parent snapshot
+		this.clearEmbeddedField(entityType, entityId, fieldName, null)
+	}
+
+	/**
+	 * Clears an embedded field value from an entity's snapshot data.
+	 */
+	private clearEmbeddedField(
+		entityType: string,
+		entityId: string,
+		fieldName: string,
+		emptyValue: unknown,
+	): void {
+		const snapshot = this.store.getEntitySnapshot(entityType, entityId)
+		if (!snapshot) return
+
+		const data = { ...(snapshot.data as Record<string, unknown>) }
+		data[fieldName] = emptyValue
+		this.store.setEntityData(entityType, entityId, data, false)
+	}
 }

package/src/persistence/types.ts

@@ -150,6 +150,12 @@ export interface TransactionMutationResult {
 	readonly persistedId?: string
 	readonly errorMessage?: string
 	readonly mutationResult?: ContemberMutationResult
+	/**
+	 * Results for entities created inline within this mutation's data.
+	 * Each entry maps a nested entity's temp ID (used as alias in the mutation)
+	 * to its server-assigned ID. Recursive for deeply nested creates.
+	 */
+	readonly nestedResults?: readonly TransactionMutationResult[]
 }
 
 /**

package/src/store/EntityMetaStore.ts

@@ -115,6 +115,35 @@ export class EntityMetaStore {
 		return !this.tempToPersistedId.has(key)
 	}
 
+	/**
+	 * Moves all metadata from oldKey to newKey.
+	 */
+	rekey(oldKey: string, newKey: string): void {
+		const meta = this.entityMetas.get(oldKey)
+		if (meta) {
+			this.entityMetas.delete(oldKey)
+			this.entityMetas.set(newKey, meta)
+		}
+
+		const loadState = this.loadStates.get(oldKey)
+		if (loadState) {
+			this.loadStates.delete(oldKey)
+			this.loadStates.set(newKey, loadState)
+		}
+
+		if (this.persistingEntities.has(oldKey)) {
+			this.persistingEntities.delete(oldKey)
+			this.persistingEntities.add(newKey)
+		}
+
+		// Move temp ID mapping
+		const persistedId = this.tempToPersistedId.get(oldKey)
+		if (persistedId !== undefined) {
+			this.tempToPersistedId.delete(oldKey)
+			this.tempToPersistedId.set(newKey, persistedId)
+		}
+	}
+
 	// ==================== Bulk Operations ====================
 
 	exportMetas(keys: string[]): Map<string, EntityMeta> {

package/src/store/EntitySnapshotStore.ts

@@ -218,6 +218,29 @@ export class EntitySnapshotStore {
 		return keys
 	}
 
+	/**
+	 * Moves a snapshot from oldKey to newKey, updating the id in the snapshot data.
+	 */
+	rekey(oldKey: string, newKey: string, newId: string): void {
+		const snapshot = this.snapshots.get(oldKey)
+		if (!snapshot) return
+
+		// Update id field in data and serverData
+		const data = { ...snapshot.data as Record<string, unknown>, id: newId }
+		const serverData = { ...snapshot.serverData as Record<string, unknown>, id: newId }
+
+		const newSnapshot = createEntitySnapshot(
+			newId,
+			snapshot.entityType,
+			data,
+			serverData,
+			snapshot.version + 1,
+		)
+
+		this.snapshots.delete(oldKey)
+		this.snapshots.set(newKey, newSnapshot)
+	}
+
 	keys(): IterableIterator<string> {
 		return this.snapshots.keys()
 	}

package/src/store/ErrorStore.ts

@@ -248,4 +248,34 @@ export class ErrorStore {
 		this.entityErrors.clear()
 		this.relationErrors.clear()
 	}
+
+	/**
+	 * Rekeys all errors from oldKeyPrefix to newKeyPrefix.
+	 */
+	rekey(oldEntityKey: string, newEntityKey: string, oldKeyPrefix: string, newKeyPrefix: string): void {
+		this.rekeyMap(this.entityErrors, oldEntityKey, newEntityKey)
+		this.rekeyByPrefix(this.fieldErrors, oldKeyPrefix, newKeyPrefix)
+		this.rekeyByPrefix(this.relationErrors, oldKeyPrefix, newKeyPrefix)
+	}
+
+	private rekeyMap(map: Map<string, ErrorState>, oldKey: string, newKey: string): void {
+		const value = map.get(oldKey)
+		if (value) {
+			map.delete(oldKey)
+			map.set(newKey, value)
+		}
+	}
+
+	private rekeyByPrefix(map: Map<string, ErrorState>, oldPrefix: string, newPrefix: string): void {
+		const toMove: [string, ErrorState][] = []
+		for (const [key, value] of map) {
+			if (key.startsWith(oldPrefix)) {
+				toMove.push([key, value])
+			}
+		}
+		for (const [oldKey, value] of toMove) {
+			map.delete(oldKey)
+			map.set(newPrefix + oldKey.slice(oldPrefix.length), value)
+		}
+	}
 }

package/src/store/RelationStore.ts

@@ -365,6 +365,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 +685,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

@@ -52,12 +52,30 @@ export class SnapshotStore implements SnapshotVersionBumper {
 
 	// ==================== 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 ====================
@@ -218,9 +236,37 @@ 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 and touched state
+		this.errors.rekey(oldKey, newKey, oldKeyPrefix, newKeyPrefix)
+		this.touched.rekey(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 +418,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,