@contember/bindx 0.1.49 → 0.1.51

package/src/store/HasOneStore.ts

@@ -1,7 +1,9 @@
 import type { HasOneRelationState } from '../handles/types.js'
 import type { EntitySnapshot } from './snapshots.js'
 import { parentKeyFromOwnerPrefix, parentKeyFromRelationKey } from './relationKey.js'
+import { PlannedDeleteIndex } from './PlannedDeleteIndex.js'
 import { RelationEdgeIndex } from './RelationEdgeIndex.js'
+import { RelationOwnerIndex } from './RelationOwnerIndex.js'
 
 /**
  * Relation state stored in SnapshotStore
@@ -40,6 +42,7 @@ function cloneRelationState(state: StoredRelationState): StoredRelationState {
 export class HasOneStore {
 	/** Relation states keyed by "parentType:parentId:fieldName" */
 	private readonly relationStates = new Map<string, StoredRelationState>()
+	private readonly owners = new RelationOwnerIndex()
 
 	/**
 	 * Bidirectional live-edge index, maintained by {@link writeRelation} /
@@ -48,6 +51,12 @@ export class HasOneStore {
 	 */
 	private readonly edges = new RelationEdgeIndex()
 
+	/**
+	 * Targets this store plans to delete through their parent's mutation, maintained
+	 * by {@link writeRelation} / {@link deleteRelation}, like {@link edges}.
+	 */
+	private readonly plannedDeletes = new PlannedDeleteIndex()
+
 	private mutationVersion = 0
 
 	/**
@@ -73,14 +82,17 @@ export class HasOneStore {
 	 * tracking the reverse direction itself.
 	 */
 	private writeRelation(key: string, state: StoredRelationState): void {
-		const oldChild = liveHasOneChildId(this.relationStates.get(key))
+		const previous = this.relationStates.get(key)
+		const oldChild = liveHasOneChildId(previous)
 		const newChild = liveHasOneChildId(state)
 		this.relationStates.set(key, state)
+		if (!previous) this.owners.add(key)
 		if (oldChild !== newChild) {
 			const parentKey = parentKeyFromRelationKey(key)
 			if (oldChild !== null) this.edges.removeEdge(parentKey, oldChild)
 			if (newChild !== null) this.edges.addEdge(parentKey, newChild)
 		}
+		this.reconcilePlannedDelete(plannedDeleteChildId(previous), plannedDeleteChildId(state))
 		this.mutationVersion++
 	}
 
@@ -94,9 +106,23 @@ export class HasOneStore {
 		const child = liveHasOneChildId(existing)
 		if (child !== null) this.edges.removeEdge(parentKeyFromRelationKey(key), child)
 		this.relationStates.delete(key)
+		this.owners.delete(key)
+		this.reconcilePlannedDelete(plannedDeleteChildId(existing), null)
 		this.mutationVersion++
 	}
 
+	/** Applies one relation's planned-delete diff to the refcounted index. */
+	private reconcilePlannedDelete(previous: string | null, next: string | null): void {
+		if (previous === next) return
+		if (previous !== null) this.plannedDeletes.release(previous)
+		if (next !== null) this.plannedDeletes.retain(next)
+	}
+
+	/** Whether this store plans to delete {@link childId} through its parent. */
+	isPlannedForDelete(childId: string): boolean {
+		return this.plannedDeletes.has(childId)
+	}
+
 	/**
 	 * Gets or creates relation state.
 	 */
@@ -289,8 +315,8 @@ export class HasOneStore {
 	 * Collects the field names of dirty has-one relations for an entity.
 	 */
 	collectDirtyRelations(keyPrefix: string, dirtyRelations: string[]): void {
-		for (const [key, state] of this.relationStates) {
-			if (!key.startsWith(keyPrefix)) continue
+		for (const key of this.owners.get(parentKeyFromOwnerPrefix(keyPrefix))) {
+			const state = this.relationStates.get(key)!
 			const fieldName = key.slice(keyPrefix.length)
 
 			if (
@@ -375,7 +401,9 @@ export class HasOneStore {
 	 */
 	clear(): void {
 		this.relationStates.clear()
+		this.owners.clear()
 		this.edges.clear()
+		this.plannedDeletes.clear()
 		this.mutationVersion++
 	}
 }
@@ -390,6 +418,16 @@ function liveHasOneChildId(state: StoredRelationState | undefined): string | nul
 	return state.currentId !== null && state.state !== 'deleted' ? state.currentId : null
 }
 
+/**
+ * The id the parent's `{ delete: true }` removes — `serverId`, not `currentId`,
+ * because that is the row MutationCollector deletes for a `deleted` relation, and a
+ * null serverId emits no delete at all.
+ */
+function plannedDeleteChildId(state: StoredRelationState | undefined): string | null {
+	if (!state || state.state !== 'deleted') return null
+	return state.serverId
+}
+
 interface HasOneReconciliation {
 	state: StoredRelationState
 	result: ReconciliationResult

package/src/store/PlannedDeleteIndex.ts

@@ -0,0 +1,33 @@
+/**
+ * Refcounted multiset of entity ids whose row a parent relation plans to delete
+ * through its own mutation ({@link HasManyStore} `plannedRemovals` of type `delete`,
+ * {@link HasOneStore} state `deleted`).
+ *
+ * Refcounted because more than one relation may plan the same child's deletion, so
+ * the id stays planned until the last of them drops it. Like {@link RelationEdgeIndex},
+ * the index knows nothing about the rules: turning relation state into a planned-delete
+ * id is the owning sub-store's job, done once per write in its chokepoint by diffing
+ * the previous state against the next.
+ */
+export class PlannedDeleteIndex {
+	private readonly counts = new Map<string, number>()
+
+	retain(childId: string): void {
+		this.counts.set(childId, (this.counts.get(childId) ?? 0) + 1)
+	}
+
+	release(childId: string): void {
+		const count = this.counts.get(childId)
+		if (count === undefined) return
+		if (count > 1) this.counts.set(childId, count - 1)
+		else this.counts.delete(childId)
+	}
+
+	has(childId: string): boolean {
+		return this.counts.has(childId)
+	}
+
+	clear(): void {
+		this.counts.clear()
+	}
+}

package/src/store/RekeyOrchestrator.ts

@@ -42,6 +42,7 @@ export interface Rekeyable {
 export class RekeyOrchestrator {
 	/** "entityType:tempId" → persistedId. The single identity-redirect map. */
 	private readonly tempToPersisted = new Map<string, string>()
+	private mutationVersion = 0
 	private readonly participants: Rekeyable[] = []
 	private readonly participantSet = new Set<Rekeyable>()
 
@@ -66,6 +67,10 @@ export class RekeyOrchestrator {
 		return persisted !== undefined ? `${entityType}:${persisted}` : `${entityType}:${id}`
 	}
 
+	getMutationVersion(): number {
+		return this.mutationVersion
+	}
+
 	/** Resolves an entity id to its persisted id if it has been rekeyed. */
 	resolveId(entityType: string, id: string): string {
 		return this.tempToPersisted.get(`${entityType}:${id}`) ?? id
@@ -111,6 +116,7 @@ export class RekeyOrchestrator {
 		}
 
 		this.tempToPersisted.set(ctx.oldKey, persistedId)
+		this.mutationVersion++
 
 		for (const participant of this.participants) {
 			participant.rekey(ctx)
@@ -119,5 +125,6 @@ export class RekeyOrchestrator {
 
 	clear(): void {
 		this.tempToPersisted.clear()
+		this.mutationVersion++
 	}
 }

package/src/store/RelationOwnerIndex.ts

@@ -0,0 +1,31 @@
+import { parentKeyFromRelationKey } from './relationKey.js'
+
+export class RelationOwnerIndex {
+	private readonly keysByOwner = new Map<string, Set<string>>()
+
+	add(key: string): void {
+		const owner = parentKeyFromRelationKey(key)
+		let keys = this.keysByOwner.get(owner)
+		if (!keys) {
+			keys = new Set()
+			this.keysByOwner.set(owner, keys)
+		}
+		keys.add(key)
+	}
+
+	delete(key: string): void {
+		const owner = parentKeyFromRelationKey(key)
+		const keys = this.keysByOwner.get(owner)
+		if (!keys) return
+		keys.delete(key)
+		if (keys.size === 0) this.keysByOwner.delete(owner)
+	}
+
+	get(owner: string): Iterable<string> {
+		return this.keysByOwner.get(owner) ?? []
+	}
+
+	clear(): void {
+		this.keysByOwner.clear()
+	}
+}

package/src/store/RelationStore.ts

@@ -158,6 +158,16 @@ export class RelationStore implements Rekeyable {
 		return this.hasMany.getHasManyOrderedIds(key)
 	}
 
+	/**
+	 * Whether some relation plans to delete {@link childId} through its parent's
+	 * mutation — a has-many `delete` removal or a has-one target marked `deleted`.
+	 * Such a row goes away with the parent's update, so the child must not be
+	 * written on its own (see issue #91).
+	 */
+	isPlannedForDeleteByParent(childId: string): boolean {
+		return this.hasOne.isPlannedForDelete(childId) || this.hasMany.isPlannedForDelete(childId)
+	}
+
 	// ==================== Reachability / Reverse Lookup ====================
 
 	/**

package/src/store/SnapshotStore.ts

@@ -1,6 +1,6 @@
 import type { EntitySnapshot, LoadStatus } from './snapshots.js'
 import { createEntitySnapshot } from './snapshots.js'
-import type { FieldError } from '../errors/types.js'
+import type { FieldError, FieldErrorFilter } from '../errors/types.js'
 import { SubscriptionManager, type SnapshotVersionBumper } from './SubscriptionManager.js'
 import { ErrorStore } from './ErrorStore.js'
 import {
@@ -194,6 +194,11 @@ export class SnapshotStore implements SnapshotVersionBumper, JournalTarget {
 		return this.rekeyOrchestrator.resolveId(entityType, id)
 	}
 
+	/** Identity caches only need reconciliation when redirects change, including on clear. */
+	getRekeyVersion(): number {
+		return this.rekeyOrchestrator.getMutationVersion()
+	}
+
 	/** Attaches identity-keyed state to the store's single rekey fan-out. */
 	attachRekeyParticipant(participant: Rekeyable): void {
 		this.rekeyOrchestrator.registerParticipant(participant)
@@ -577,6 +582,15 @@ export class SnapshotStore implements SnapshotVersionBumper, JournalTarget {
 		return this.relations.getHasMany(key)?.plannedRemovals
 	}
 
+	/**
+	 * Whether some relation plans to delete {@link entityId} through its parent, i.e.
+	 * the row goes away with the parent's update rather than with a mutation of its
+	 * own (see issue #91).
+	 */
+	isPlannedForDeleteByParent(entityId: string): boolean {
+		return this.relations.isPlannedForDeleteByParent(entityId)
+	}
+
 	planHasManyConnection(
 		parentType: string,
 		parentId: string,
@@ -814,10 +828,10 @@ export class SnapshotStore implements SnapshotVersionBumper, JournalTarget {
 		entityType: string,
 		id: string,
 		fieldName: string,
-		source?: 'client' | 'server',
+		filter?: FieldErrorFilter,
 	): void {
 		const key = this.getRelationKey(entityType, id, fieldName)
-		this.errors.clearFieldErrors(key, source)
+		this.errors.clearFieldErrors(key, filter)
 		this.notifyEntitySubscribers(this.getEntityKey(entityType, id))
 	}