@contember/bindx 0.1.30 → 0.1.31

package/dist/store/SubscriptionManager.d.ts

@@ -25,8 +25,17 @@ export declare class SubscriptionManager {
     private readonly globalSubscribers;
     /** Parent-child relationships: childKey -> Set of parentKeys */
     private readonly childToParents;
+    /** Maps old keys → new keys after rekey, so unsubscribe closures can find migrated callbacks */
+    private readonly rekeyedKeys;
     /** Global version number for change detection */
     private globalVersion;
+    /**
+     * 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;
     /**
      * Subscribe to changes on a specific entity.
      * Returns unsubscribe function.
@@ -85,6 +94,12 @@ export declare class SubscriptionManager {
      * Bumps global version and notifies global subscribers.
      */
     notifyGlobal(): void;
+    /**
+     * 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;
 }
 export {};
 //# sourceMappingURL=SubscriptionManager.d.ts.map

package/dist/store/SubscriptionManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SubscriptionManager.d.ts","sourceRoot":"","sources":["../../src/store/SubscriptionManager.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAE5B;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5C;AAED;;;;;;;;;GASG;AACH,qBAAa,mBAAmB;IAC/B,iCAAiC;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;IAEvE,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqC;IAEzE,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;IAE1D,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAEhE,iDAAiD;IACjD,OAAO,CAAC,aAAa,CAAI;IAEzB;;;OAGG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAYhE;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAYlE;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;;OAGG;IACH,MAAM,IAAI,IAAI;IASd;;;OAGG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS9D;;OAEG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYhE;;;OAGG;IACH,uBAAuB,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,qBAAqB,EAC7B,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,IAAI;IAiCP;;;;OAIG;IACH,yBAAyB,CACxB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,GAC3B,IAAI;IA4BP;;;OAGG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASrC;;;OAGG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASvC;;OAEG;IACH,YAAY,IAAI,IAAI;CAMpB"}
+{"version":3,"file":"SubscriptionManager.d.ts","sourceRoot":"","sources":["../../src/store/SubscriptionManager.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAE5B;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5C;AAED;;;;;;;;;GASG;AACH,qBAAa,mBAAmB;IAC/B,iCAAiC;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;IAEvE,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqC;IAEzE,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;IAE1D,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAEhE,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IAExD,iDAAiD;IACjD,OAAO,CAAC,aAAa,CAAI;IAEzB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAUlB;;;OAGG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAahE;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAalE;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;;OAGG;IACH,MAAM,IAAI,IAAI;IASd;;;OAGG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS9D;;OAEG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYhE;;;OAGG;IACH,uBAAuB,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,qBAAqB,EAC7B,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,IAAI;IAiCP;;;;OAIG;IACH,yBAAyB,CACxB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,GAC3B,IAAI;IA4BP;;;OAGG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASrC;;;OAGG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASvC;;OAEG;IACH,YAAY,IAAI,IAAI;IAOpB;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;CAqDvF"}

package/dist/store/TouchedStore.d.ts

@@ -19,6 +19,10 @@ export declare class TouchedStore {
      * Clears all touched state for an entity.
      */
     clearForEntity(keyPrefix: string): void;
+    /**
+     * Rekeys all touched fields from oldKeyPrefix to newKeyPrefix.
+     */
+    rekey(oldKeyPrefix: string, newKeyPrefix: string): void;
     clear(): void;
 }
 //# sourceMappingURL=TouchedStore.d.ts.map

package/dist/store/TouchedStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TouchedStore.d.ts","sourceRoot":"","sources":["../../src/store/TouchedStore.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,YAAY;IACxB,uDAAuD;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIpC;;;OAGG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAOvD;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQvC,KAAK,IAAI,IAAI;CAGb"}
+{"version":3,"file":"TouchedStore.d.ts","sourceRoot":"","sources":["../../src/store/TouchedStore.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,YAAY;IACxB,uDAAuD;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIpC;;;OAGG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAOvD;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQvC;;OAEG;IACH,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAavD,KAAK,IAAI,IAAI;CAGb"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@contember/bindx",
-	"version": "0.1.30",
+	"version": "0.1.31",
 	"description": "Type-safe data binding framework (core)",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -17,7 +17,7 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@contember/bindx-client": "0.1.30",
+		"@contember/bindx-client": "0.1.31",
 		"@contember/graphql-builder": "^2.1.0-beta.1",
 		"@contember/graphql-client": "^2.1.0-beta.1"
 	},

package/src/adapter/ContemberAdapter.ts

@@ -11,6 +11,7 @@ import {
 	buildUpdateArgs,
 	buildDeleteArgs,
 	buildMutationSelection,
+	buildNodeSelectionFromMutationData,
 	mutationFragments,
 	unwrapPaginateResult,
 } from '@contember/bindx-client'
@@ -119,19 +120,24 @@ export class ContemberAdapter implements BackendAdapter {
 		changes: Record<string, unknown>,
 	): Promise<PersistResult> {
 		const args = buildUpdateArgs(entityType, { by: { id }, data: changes })
-		const selectionSet = buildMutationSelection('update')
+		const nodeSelection = buildNodeSelectionFromMutationData(changes)
+		const selectionSet = buildMutationSelection('update', nodeSelection)
 
 		const mutation = new ContentOperation(
 			'mutation',
 			`update${entityType}`,
 			args,
 			selectionSet,
-			value => value as { ok: boolean; errorMessage: string | null; errors: unknown[]; validation: unknown },
+			value => value as { ok: boolean; errorMessage: string | null; errors: unknown[]; validation: unknown; node: unknown },
 		)
 
 		try {
 			const result = await this.contentClient.mutate(mutation)
-			return { ok: true }
+			const typedResult = result as { node: Record<string, unknown> | null }
+			return {
+				ok: true,
+				data: typedResult.node as Record<string, unknown> | undefined,
+			}
 		} catch (e) {
 			if (e instanceof Error && 'result' in e) {
 				const mutResult = (e as { result: Record<string, unknown> }).result
@@ -150,8 +156,8 @@ export class ContemberAdapter implements BackendAdapter {
 		data: Record<string, unknown>,
 	): Promise<CreateResult> {
 		const args = buildCreateArgs(entityType, { data })
-		// Select id on created node
-		const nodeSelection = [new GraphQlField(null, 'id')]
+		// Select id on created node + nested created entity IDs
+		const nodeSelection = buildNodeSelectionFromMutationData(data)
 		const selectionSet = buildMutationSelection('create', nodeSelection)
 
 		const mutation = new ContentOperation(

package/src/adapter/types.ts

@@ -80,6 +80,8 @@ export type QueryResult = GetQueryResult | ListQueryResult
 export interface PersistResult {
 	readonly ok: boolean
 	readonly errorMessage?: string
+	/** The entity node data after mutation (when ok is true). Contains nested entity IDs for inline creates. */
+	readonly data?: Record<string, unknown>
 	/** Detailed mutation result for error mapping (Contember-specific) */
 	readonly mutationResult?: ContemberMutationResult
 }
@@ -128,6 +130,8 @@ export interface TransactionMutationResult {
 	readonly persistedId?: string
 	readonly errorMessage?: string
 	readonly mutationResult?: ContemberMutationResult
+	/** Results for entities created inline within this mutation's data. */
+	readonly nestedResults?: readonly TransactionMutationResult[]
 }
 
 /**

package/src/core/ActionDispatcher.ts

@@ -218,6 +218,7 @@ export class ActionDispatcher {
 						state: 'connected',
 					},
 				)
+				this.store.registerParentChild(action.entityType, action.entityId, action.targetType, action.targetId)
 				break
 
 			case 'DISCONNECT_RELATION':
@@ -293,6 +294,7 @@ export class ActionDispatcher {
 					action.itemId,
 					action.alias,
 				)
+				this.store.registerParentChild(action.entityType, action.entityId, action.targetType, action.itemId)
 				break
 
 			case 'ADD_TO_LIST': {
@@ -306,6 +308,7 @@ export class ActionDispatcher {
 					itemId,
 					action.alias,
 				)
+				this.store.registerParentChild(action.entityType, action.entityId, action.targetType, itemId)
 				break
 			}
 

package/src/core/actions.ts

@@ -61,6 +61,7 @@ export interface ConnectRelationAction {
 	readonly entityId: string
 	readonly fieldName: string
 	readonly targetId: string
+	readonly targetType: string
 }
 
 /**
@@ -126,6 +127,7 @@ export interface ConnectToListAction {
 	readonly entityId: string
 	readonly fieldName: string
 	readonly itemId: string
+	readonly targetType: string
 	readonly alias?: string
 }
 
@@ -355,8 +357,9 @@ export function connectRelation(
 	entityId: string,
 	fieldName: string,
 	targetId: string,
+	targetType: string,
 ): ConnectRelationAction {
-	return { type: 'CONNECT_RELATION', entityType, entityId, fieldName, targetId }
+	return { type: 'CONNECT_RELATION', entityType, entityId, fieldName, targetId, targetType }
 }
 
 /**
@@ -517,9 +520,10 @@ export function connectToList(
 	entityId: string,
 	fieldName: string,
 	itemId: string,
+	targetType: string,
 	alias?: string,
 ): ConnectToListAction {
-	return { type: 'CONNECT_TO_LIST', entityType, entityId, fieldName, itemId, alias }
+	return { type: 'CONNECT_TO_LIST', entityType, entityId, fieldName, itemId, targetType, alias }
 }
 
 /**

package/src/handles/HasManyListHandle.ts

@@ -304,10 +304,8 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 	connect(itemId: string): void {
 		this.assertNotDisposed()
 		this.dispatcher.dispatch(
-			connectToList(this.entityType, this.entityId, this.fieldName, itemId, this.alias),
+			connectToList(this.entityType, this.entityId, this.fieldName, itemId, this.itemType, this.alias),
 		)
-		// Register parent-child so that changes to the connected entity propagate to the parent
-		this.store.registerParentChild(this.entityType, this.entityId, this.itemType, itemId)
 	}
 
 	/**
@@ -350,9 +348,6 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 			addToList(this.entityType, this.entityId, this.fieldName, this.itemType, tempId, this.alias),
 		)
 
-		// Register parent-child so that changes to the new entity propagate to the parent
-		this.store.registerParentChild(this.entityType, this.entityId, this.itemType, tempId)
-
 		return tempId
 	}
 

package/src/handles/HasOneHandle.ts

@@ -353,13 +353,27 @@ export class HasOneHandle<TEntity extends object = object, TSelected = TEntity>
 		)
 	}
 
+	/**
+	 * Creates a new entity of the target type and connects it to this relation.
+	 * Returns the temp ID of the created entity.
+	 * Accessible via proxy as `$create()`.
+	 */
+	create(data?: Partial<TEntity>): string {
+		this.assertNotDisposed()
+		const tempId = this.store.createEntity(this.targetType, data as Record<string, unknown>)
+		this.dispatcher.dispatch(
+			connectRelation(this.entityType, this.entityId, this.fieldName, tempId, this.targetType),
+		)
+		return tempId
+	}
+
 	/**
 	 * Connects the relation to an entity.
 	 */
 	connect(targetId: string): void {
 		this.assertNotDisposed()
 		this.dispatcher.dispatch(
-			connectRelation(this.entityType, this.entityId, this.fieldName, targetId),
+			connectRelation(this.entityType, this.entityId, this.fieldName, targetId, this.targetType),
 		)
 	}
 

package/src/handles/types.ts

@@ -228,6 +228,7 @@ export interface HasOneRefInterface<
 	readonly __entityType: TEntity
 	readonly __selected?: TSelected
 	readonly __brands?: Set<symbol>
+	$create(data?: Partial<TEntity>): string
 	$connect(id: string): void
 	$disconnect(): void
 	$delete(): void

package/src/persistence/BatchPersister.ts

@@ -12,6 +12,7 @@ import type {
 	PersistenceResult,
 	PersistScope,
 	TransactionMutation,
+	TransactionMutationResult,
 	TransactionResult,
 	UpdateMode,
 } from './types.js'
@@ -603,11 +604,15 @@ export class BatchPersister {
 					if (this.adapter.create && mutation.data) {
 						const result = await this.adapter.create(mutation.entityType, mutation.data)
 						const persistedId = result.data?.['id'] as string | undefined
+						const nestedResults = result.ok && result.data && mutation.data
+							? this.extractNestedResultsFromNode(mutation.data, result.data, mutation.entityType, mutation.entityId)
+							: undefined
 						results.push({
 							entityType: mutation.entityType,
 							entityId: mutation.entityId,
 							ok: result.ok,
 							persistedId,
+							nestedResults,
 							errorMessage: result.errorMessage,
 							mutationResult: result.mutationResult,
 						})
@@ -621,10 +626,14 @@ export class BatchPersister {
 							mutation.entityId,
 							mutation.data,
 						)
+						const nestedResults = result.ok && result.data && mutation.data
+							? this.extractNestedResultsFromNode(mutation.data, result.data, mutation.entityType, mutation.entityId)
+							: undefined
 						results.push({
 							entityType: mutation.entityType,
 							entityId: mutation.entityId,
 							ok: result.ok,
+							nestedResults,
 							errorMessage: result.errorMessage,
 							mutationResult: result.mutationResult,
 						})
@@ -700,6 +709,11 @@ export class BatchPersister {
 						)
 					}
 
+					// Process nested results (inline-created entities within this mutation)
+					if (mutationResult.nestedResults) {
+						this.commitNestedResults(mutationResult.nestedResults)
+					}
+
 					results.push({
 						entityType: entity.entityType,
 						entityId: entity.entityId,
@@ -710,6 +724,11 @@ export class BatchPersister {
 					successCount++
 				}
 			}
+
+			// Commit nested entities that don't have explicit results from the adapter.
+			// These entities were nested inside a parent mutation's data and exist on the server,
+			// but the adapter may not provide individual results for them.
+			this.commitUnresolvedNestedEntities(entities)
 		} else {
 			// Transaction failed - map errors and optionally rollback
 			// For pessimistic mode, entities are already at server state, no rollback needed
@@ -919,6 +938,224 @@ export class BatchPersister {
 		}
 	}
 
+	/**
+	 * Recursively commits nested entity results and maps their server IDs.
+	 * Called when the adapter provides nestedResults in the transaction response.
+	 * Uses the MutationCollector's nestedEntityTypes map to resolve entity types,
+	 * since the adapter may not know the correct entity type for nested entities.
+	 */
+	private commitNestedResults(nestedResults: readonly TransactionMutationResult[]): void {
+		const nestedTypes = this.mutationCollector instanceof MutationCollector
+			? this.mutationCollector.getNestedEntityTypes()
+			: null
+
+		for (const nested of nestedResults) {
+			if (!nested.ok) continue
+
+			// Resolve entity type from collector's tracking (adapter may report 'Unknown')
+			const entityType = nestedTypes?.get(nested.entityId) ?? nested.entityType
+			const snapshot = this.store.getEntitySnapshot(entityType, nested.entityId)
+			if (!snapshot) continue
+
+			// Commit the nested entity
+			this.dispatcher.dispatch(commitEntity(entityType, nested.entityId))
+			this.store.commitAllRelations(entityType, nested.entityId)
+			this.store.setExistsOnServer(entityType, nested.entityId, true)
+
+			// Map temp ID to server-assigned ID
+			if (nested.persistedId) {
+				this.store.mapTempIdToPersistedId(
+					entityType,
+					nested.entityId,
+					nested.persistedId,
+				)
+			}
+
+			// Recurse for deeper nesting
+			if (nested.nestedResults) {
+				this.commitNestedResults(nested.nestedResults)
+			}
+		}
+	}
+
+	/**
+	 * Commits nested entities that were part of the transaction but don't have
+	 * explicit results from the adapter. These entities were created inline
+	 * inside a parent mutation and exist on the server after a successful persist.
+	 */
+	private commitUnresolvedNestedEntities(entities: DirtyEntity[]): void {
+		if (!(this.mutationCollector instanceof MutationCollector)) return
+
+		const nestedTypes = this.mutationCollector.getNestedEntityTypes()
+		if (nestedTypes.size === 0) return
+
+		// Find nested entities that are in the entities list but weren't committed
+		// by the main result processing (they had no matching result from the adapter)
+		for (const entity of entities) {
+			if (entity.changeType !== 'create') continue
+			if (!nestedTypes.has(entity.entityId)) continue
+
+			// Check if this entity was already committed (has server data)
+			if (this.store.existsOnServer(entity.entityType, entity.entityId)) continue
+
+			// Commit it — the parent mutation succeeded, so this entity exists on the server
+			this.dispatcher.dispatch(commitEntity(entity.entityType, entity.entityId))
+			this.store.commitAllRelations(entity.entityType, entity.entityId)
+			this.store.setExistsOnServer(entity.entityType, entity.entityId, true)
+		}
+
+		// Also commit materialized entities that may not be in the entities list
+		// (they were created during mutation building by materializeEmbeddedHasMany/HasOne)
+		for (const [tempId, entityType] of nestedTypes) {
+			if (this.store.existsOnServer(entityType, tempId)) continue
+
+			const snapshot = this.store.getEntitySnapshot(entityType, tempId)
+			if (!snapshot) continue
+
+			this.dispatcher.dispatch(commitEntity(entityType, tempId))
+			this.store.commitAllRelations(entityType, tempId)
+			this.store.setExistsOnServer(entityType, tempId, true)
+		}
+	}
+
+	/**
+	 * Extracts nested entity results from a mutation's node response data.
+	 * Walks the mutation data structure to find inline create operations,
+	 * then matches them against the node response to extract server-assigned IDs.
+	 *
+	 * For hasOne creates: looks up the temp ID from the store's relation state
+	 * for the parent entity, then gets the server ID from the response node field.
+	 * For hasMany creates: filters new IDs from the response array by excluding
+	 * known pre-existing IDs, matching to temp IDs (aliases) by position.
+	 */
+	private extractNestedResultsFromNode(
+		mutationData: Record<string, unknown>,
+		nodeData: Record<string, unknown>,
+		parentEntityType: string,
+		parentEntityId: string,
+	): TransactionMutationResult[] {
+		const results: TransactionMutationResult[] = []
+		const nestedTypes = this.mutationCollector instanceof MutationCollector
+			? this.mutationCollector.getNestedEntityTypes()
+			: null
+
+		const makeResult = (
+			tempId: string,
+			createData: Record<string, unknown>,
+			nodeItem: Record<string, unknown>,
+		): TransactionMutationResult => {
+			const childResults = this.extractNestedResultsFromNode(
+				createData, nodeItem,
+				nestedTypes?.get(tempId) ?? 'Unknown', tempId,
+			)
+			return {
+				entityType: nestedTypes?.get(tempId) ?? 'Unknown',
+				entityId: tempId,
+				ok: true,
+				persistedId: nodeItem['id'] as string,
+				nestedResults: childResults.length > 0 ? childResults : undefined,
+			}
+		}
+
+		for (const [fieldName, fieldValue] of Object.entries(mutationData)) {
+			if (fieldValue === null || fieldValue === undefined) continue
+
+			if (Array.isArray(fieldValue)) {
+				const nodeItems = nodeData[fieldName]
+				if (!Array.isArray(nodeItems)) continue
+
+				// Separate create ops from known IDs (connect/update)
+				const knownIds = new Set<string>()
+				const createOps: Array<{ alias: string; createData: Record<string, unknown> }> = []
+
+				for (const op of fieldValue) {
+					if (typeof op !== 'object' || op === null) continue
+					const opObj = op as Record<string, unknown>
+
+					if ('connect' in opObj) {
+						const connectBy = opObj['connect'] as Record<string, unknown>
+						if (connectBy['id']) knownIds.add(connectBy['id'] as string)
+					} else if ('update' in opObj) {
+						const by = (opObj['update'] as Record<string, unknown>)['by'] as Record<string, unknown> | undefined
+						if (by?.['id']) knownIds.add(by['id'] as string)
+					} else if ('create' in opObj && opObj['alias']) {
+						createOps.push({
+							alias: opObj['alias'] as string,
+							createData: opObj['create'] as Record<string, unknown>,
+						})
+					}
+				}
+
+				// Include pre-existing server IDs
+				const hasManyState = this.store.getHasMany(parentEntityType, parentEntityId, fieldName)
+				if (hasManyState) {
+					for (const id of hasManyState.serverIds) knownIds.add(id)
+				}
+
+				// Filter response to new items only, then content-match to create ops.
+				// Contember API does not guarantee hasMany ordering in node response,
+				// so we match by scalar field values instead of position.
+				// Unmatched creates keep their temp IDs until the next fetch.
+				const unmatchedItems = (nodeItems as Record<string, unknown>[])
+					.filter(it => typeof it === 'object' && it !== null && !knownIds.has(it['id'] as string))
+
+				for (const createOp of createOps) {
+					const idx = unmatchedItems.findIndex(it => this.isCreateDataMatchingNode(createOp.createData, it))
+					if (idx < 0) continue
+					results.push(makeResult(createOp.alias, createOp.createData, unmatchedItems.splice(idx, 1)[0]!))
+				}
+			} else if (typeof fieldValue === 'object') {
+				const opObj = fieldValue as Record<string, unknown>
+				const nodeField = nodeData[fieldName]
+
+				if ('create' in opObj && typeof nodeField === 'object' && nodeField !== null) {
+					const serverId = (nodeField as Record<string, unknown>)['id'] as string | undefined
+					if (!serverId) continue
+
+					const relationState = this.store.getRelation(parentEntityType, parentEntityId, fieldName)
+					if (!relationState?.currentId) continue
+
+					results.push(makeResult(
+						relationState.currentId,
+						opObj['create'] as Record<string, unknown>,
+						nodeField as Record<string, unknown>,
+					))
+				}
+			}
+		}
+
+		return results
+	}
+
+	/**
+	 * Content-based matching: checks whether create data matches a response node
+	 * by comparing scalars and hasOne relation IDs. Same approach as the legacy
+	 * binding's TreeAugmenter.isEntityMatching.
+	 */
+	private isCreateDataMatchingNode(
+		createData: Record<string, unknown>,
+		nodeItem: Record<string, unknown>,
+	): boolean {
+		for (const [key, value] of Object.entries(createData)) {
+			if (value === null || value === undefined) continue
+
+			if (typeof value !== 'object') {
+				if (nodeItem[key] !== value) return false
+			} else if (!Array.isArray(value)) {
+				const op = value as Record<string, unknown>
+				const nodeField = nodeItem[key]
+				if (!nodeField || typeof nodeField !== 'object') continue
+
+				if ('connect' in op) {
+					if ((op['connect'] as Record<string, unknown>)['id'] !== (nodeField as Record<string, unknown>)['id']) return false
+				} else if ('create' in op) {
+					if (!this.isCreateDataMatchingNode(op['create'] as Record<string, unknown>, nodeField as Record<string, unknown>)) return false
+				}
+			}
+		}
+		return true
+	}
+
 	/**
 	 * Cancels all in-flight operations.
 	 */