@contember/bindx 0.1.51 → 0.1.53

package/src/core/ActionDispatcher.ts

@@ -360,7 +360,6 @@ export class ActionDispatcher {
 					action.fieldName,
 					action.itemKey,
 					action.removalType,
-					action.alias,
 				)
 				break
 

package/src/core/EntityLoader.ts

@@ -60,6 +60,13 @@ export interface LoadEntityListOptions<TEntity = unknown> {
 /**
  * Non-React service for loading entities.
  * Can be used in any JavaScript environment.
+ *
+ * It writes each response as it arrives, without uniting the occurrences of one
+ * entity within it (see `SnapshotStore.indexServerResponse`): that needs the
+ * selection and the schema, and the loader has only a `QuerySpec`. A query that
+ * reaches one entity through two paths with different sub-selections can
+ * therefore lose the wider one's fields, as described in
+ * https://github.com/contember/bindx/issues/123. The React hooks do not go through it.
  */
 export class EntityLoader {
 	constructor(
@@ -124,13 +131,13 @@ export class EntityLoader {
 				}
 			}
 
-			// Store each entity in snapshot store
-			for (const item of result.data) {
-				const record = item as Record<string, unknown>
-				if (typeof record['id'] === 'string') {
-					this.store.setEntityData(entityType, record['id'], record, true)
+			this.store.batchNotifications(() => {
+				for (const record of result.data) {
+					if (typeof record['id'] === 'string') {
+						this.store.setEntityData(entityType, record['id'], record, true)
+					}
 				}
-			}
+			})
 
 			return { status: 'success', data: result.data as T[] }
 		} catch (error) {

package/src/core/actions.ts

@@ -165,7 +165,6 @@ export interface RemoveFromListAction {
 	readonly fieldName: string
 	readonly itemKey: string
 	readonly removalType: 'disconnect' | 'delete'
-	readonly alias?: string
 }
 
 /**
@@ -581,9 +580,8 @@ export function removeFromList(
 	fieldName: string,
 	itemKey: string,
 	removalType: 'disconnect' | 'delete',
-	alias?: string,
 ): RemoveFromListAction {
-	return { type: 'REMOVE_FROM_LIST', entityType, entityId, fieldName, itemKey, removalType, alias }
+	return { type: 'REMOVE_FROM_LIST', entityType, entityId, fieldName, itemKey, removalType }
 }
 
 /**

package/src/dataview/types.ts

@@ -60,9 +60,9 @@ export interface BooleanFilterArtifact {
 /**
  * Enum filter artifact
  */
-export interface EnumFilterArtifact {
-	readonly values?: readonly string[]
-	readonly notValues?: readonly string[]
+export interface EnumFilterArtifact<TValue extends string = string> {
+	readonly values?: readonly TValue[]
+	readonly notValues?: readonly TValue[]
 	readonly nullCondition?: boolean
 }
 
@@ -78,9 +78,9 @@ export interface RelationFilterArtifact {
 /**
  * Enum list filter artifact - for array enum fields (uses 'includes' condition)
  */
-export interface EnumListFilterArtifact {
-	readonly values?: readonly string[]
-	readonly notValues?: readonly string[]
+export interface EnumListFilterArtifact<TValue extends string = string> {
+	readonly values?: readonly TValue[]
+	readonly notValues?: readonly TValue[]
 	readonly nullCondition?: boolean
 }
 

package/src/handles/EntityHandle.ts

@@ -13,6 +13,7 @@ import {
 } from '../core/actions.js'
 import { FIELD_REF_META, type FieldRefMeta, type FieldAccessor, type HasOneAccessor, type HasManyAccessor, type EntityFieldsAccessor, type Unsubscribe, type EntityAccessor } from './types.js'
 import { deepEqual } from '../utils/deepEqual.js'
+import { canHasManyParamsExcludeMembers } from '../utils/aliasGenerator.js'
 import { createClientError, type ErrorInput, type FieldError } from '../errors/types.js'
 import type {
 	EventTypeMap,
@@ -511,6 +512,16 @@ export class EntityHandle<T extends object = object, TSelected = T> extends Enti
 					// Has-many relation - return HasManyListHandle.
 					// Thread the selected alias so the handle reads data stored under the
 					// auto-generated alias (e.g. `tags_<hash>`) for params-bearing relations.
+					// The alias is a hash of the params, so the store cannot tell a filtered
+					// view from one that only orders — say so here, where the params are.
+					if (fieldMeta && fieldMeta.alias !== schemaFieldName) {
+						this.store.declareHasManyViewMembership(
+							this.entityType,
+							schemaFieldName,
+							fieldMeta.alias,
+							canHasManyParamsExcludeMembers(fieldMeta.hasManyParams) ? 'partial' : 'total',
+						)
+					}
 					return this.hasMany(schemaFieldName, fieldMeta?.alias, nestedSelection)
 				}
 

package/src/handles/HasManyListHandle.ts

@@ -284,7 +284,8 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 	 * Only called when parent's embedded data has changed (re-fetch detected).
 	 */
 	private ensureItemSnapshots(listData: Array<Record<string, unknown>>): void {
-		for (const itemData of listData) {
+		for (const embeddedItem of listData) {
+			const itemData = this.store.resolveServerOccurrence(embeddedItem)
 			const itemId = itemData['id'] as string
 			if (!itemId) continue
 
@@ -406,23 +407,18 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 
 	/**
 	 * Checks if the list is dirty (items added/removed/moved/connected/disconnected).
+	 *
+	 * Pending writes belong to the relation, not to this view, so a sibling view's
+	 * unsaved change reports here too — persisting either view sends the whole
+	 * relation, and a view claiming to be clean while pushing its sibling's writes
+	 * would be incoherent. Only the manual ordering is this view's own.
 	 */
 	get isDirty(): boolean {
 		this.materializeEmbeddedItems()
 
-		const state = this.store.getHasMany(
-			this.entityType,
-			this.entityId,
-			this.fieldName,
-			this.alias,
-		)
-
-		if (!state) return false
-
 		return (
-			state.plannedRemovals.size > 0 ||
-			state.plannedAdditions.size > 0 ||
-			state.orderedIds !== null
+			this.store.hasPendingHasManyWrites(this.entityType, this.entityId, this.fieldName)
+			|| this.store.hasExplicitHasManyOrder(this.entityType, this.entityId, this.fieldName, this.alias)
 		)
 	}
 
@@ -452,7 +448,7 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 	disconnect(itemId: string): void {
 		this.materializeEmbeddedItems()
 		this.dispatcher.dispatch(
-			removeFromList(this.entityType, this.entityId, this.fieldName, itemId, 'disconnect', this.alias),
+			removeFromList(this.entityType, this.entityId, this.fieldName, itemId, 'disconnect'),
 		)
 	}
 
@@ -464,7 +460,7 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 	delete(itemId: string): void {
 		this.materializeEmbeddedItems()
 		this.dispatcher.dispatch(
-			removeFromList(this.entityType, this.entityId, this.fieldName, itemId, 'delete', this.alias),
+			removeFromList(this.entityType, this.entityId, this.fieldName, itemId, 'delete'),
 		)
 	}
 
@@ -503,7 +499,7 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 	remove(itemId: string): void {
 		this.materializeEmbeddedItems()
 		this.dispatcher.dispatch(
-			removeFromList(this.entityType, this.entityId, this.fieldName, itemId, this.resolveRemovalType(), this.alias),
+			removeFromList(this.entityType, this.entityId, this.fieldName, itemId, this.resolveRemovalType()),
 		)
 	}
 
@@ -541,6 +537,9 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 	/**
 	 * Resets the has-many relation to server state.
 	 * Clears all planned connections and removals.
+	 *
+	 * Relation-level, like {@link isDirty}: planned removals carry no view, so a
+	 * per-view reset could not know which of them to drop.
 	 */
 	reset(): void {
 		this.materializeEmbeddedItems()
@@ -548,7 +547,6 @@ export class HasManyListHandle<TEntity extends object = object, TSelected = TEnt
 			this.entityType,
 			this.entityId,
 			this.fieldName,
-			this.alias,
 		)
 	}
 

package/src/handles/HasOneHandle.ts

@@ -418,11 +418,13 @@ export class HasOneHandle<TEntity extends object = object, TSelected = TEntity>
 			return
 		}
 
+		const occurrence = this.store.resolveServerOccurrence(embeddedData as Record<string, unknown>)
+
 		// Skip if embedded data values match existing serverData — avoids overwriting
 		// unpersisted local mutations when a re-fetch returns the same server data
 		// (e.g. polling). A new reference with identical values means no actual change.
 		const existing = this.store.getEntitySnapshot(this.targetType, id)
-		if (existing?.serverData && embeddedDataMatchesSnapshot(embeddedData as Record<string, unknown>, existing.serverData as Record<string, unknown>)) {
+		if (existing?.serverData && embeddedDataMatchesSnapshot(occurrence, existing.serverData as Record<string, unknown>)) {
 			this.store.markEmbeddedDataPropagated(this.entityType, this.entityId, this.dataFieldName, embeddedData)
 			return
 		}
@@ -435,7 +437,7 @@ export class HasOneHandle<TEntity extends object = object, TSelected = TEntity>
 		this.store.refreshServerData(
 			this.targetType,
 			id,
-			embeddedData as Record<string, unknown>,
+			occurrence,
 			true, // skipNotify - called during render, data already exists embedded in parent
 		)
 		this.store.markEmbeddedDataPropagated(this.entityType, this.entityId, this.dataFieldName, embeddedData)

package/src/index.ts

@@ -250,6 +250,12 @@ export type {
 export type {
 	StoredRelationState,
 	StoredHasManyState,
+	HasManyView,
+	HasManyViewMembership,
+	PlannedHasManyAddition,
+	HasManyAdditionKind,
+	HasManyRelationProjection,
+	HasManyViewProjection,
 	EntityMeta,
 } from './store/SnapshotStore.js'
 

package/src/persistence/BatchPersister.ts

@@ -327,16 +327,18 @@ export class BatchPersister {
 			}
 
 			const transactionResult = await this.executeTransaction(execution, options?.signal)
-			result = this.processExecutionResult(execution, transactionResult, options)
+			result = this.store.batchNotifications(() => this.processExecutionResult(execution, transactionResult, options))
 			result = this.mergeCancelled(result, execution.vetoed)
 			return result
 
 		} finally {
-			this.releaseEntities([...claimed.values()])
-			this.undoManager?.unblock()
-			if (result?.success) {
-				this.store.sweepUnreachableCreated()
-			}
+			this.store.batchNotifications(() => {
+				this.releaseEntities([...claimed.values()])
+				this.undoManager?.unblock()
+				if (result?.success) {
+					this.store.sweepUnreachableCreated()
+				}
+			})
 		}
 
 		// Unreachable, but keeps the return type explicit when control-flow analysis changes.
@@ -991,11 +993,13 @@ export class BatchPersister {
 		const fresh = entities.filter(entity => !claimed.has(entityIdentityKey(entity.entityType, entity.entityId)))
 		if (fresh.length === 0) return
 		this.changeRegistry.markInFlight(fresh)
-		for (const entity of fresh) {
-			claimed.set(entityIdentityKey(entity.entityType, entity.entityId), entity)
-			this.dispatcher.dispatch(setPersisting(entity.entityType, entity.entityId, true, updateMode === 'pessimistic'))
-			this.dispatcher.dispatch(clearAllServerErrors(entity.entityType, entity.entityId))
-		}
+		this.store.batchNotifications(() => {
+			for (const entity of fresh) {
+				claimed.set(entityIdentityKey(entity.entityType, entity.entityId), entity)
+				this.dispatcher.dispatch(setPersisting(entity.entityType, entity.entityId, true, updateMode === 'pessimistic'))
+				this.dispatcher.dispatch(clearAllServerErrors(entity.entityType, entity.entityId))
+			}
+		})
 	}
 
 	private releaseEntities(entities: readonly DirtyEntity[]): void {