@contember/bindx 0.1.49 → 0.1.50

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 {
@@ -577,6 +577,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 +823,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))
 	}