@contember/bindx 0.1.45 → 0.1.47

package/src/undo/rekeyJournalEntry.ts

@@ -0,0 +1,145 @@
+import type { RekeyContext } from '../store/RekeyOrchestrator.js'
+import { createEntitySnapshot } from '../store/snapshots.js'
+import type { EntitySnapshot } from '../store/snapshots.js'
+import type { StoredHasManyState } from '../store/RelationStore.js'
+import type { JournalEntry, JournalCellImage } from './UndoJournal.js'
+
+/**
+ * Rewrites a journal entry for a temp→persisted rekey so stored cells stay valid
+ * after persist:
+ *   - owner keys move from the temp prefix to the persisted prefix;
+ *   - embedded id references (snapshot ids, relation currentId/serverId, has-many
+ *     members) are remapped oldId→newId;
+ *   - the create is SEALED: an "absent" pre-image of the now-persisted entity (or
+ *     its owned relations) is dropped, so undo can no longer delete the
+ *     server-backed row — only later edits to it remain undoable.
+ */
+/**
+ * Looks up the live server-member ids of a has-many list by its key. Lets the
+ * rekey rebase a pre-image when the just-persisted create has become a permanent
+ * member of that list.
+ */
+export type LiveServerIdsLookup = (relationKey: string) => Set<string>
+
+export function rekeyJournalEntry(
+	entry: JournalEntry,
+	ctx: RekeyContext,
+	liveServerIds: LiveServerIdsLookup,
+): JournalEntry {
+	const cells: JournalCellImage[] = []
+	for (const cell of entry.cells) {
+		const rewritten = rekeyCell(cell, ctx, liveServerIds)
+		if (rewritten) cells.push(rewritten)
+	}
+	return { cells }
+}
+
+function rekeyKey(key: string, ctx: RekeyContext): string {
+	if (key === ctx.oldKey) return ctx.newKey
+	if (key.startsWith(ctx.oldKeyPrefix)) return ctx.newKeyPrefix + key.slice(ctx.oldKeyPrefix.length)
+	return key
+}
+
+function isOwnedByRekeyed(key: string, ctx: RekeyContext): boolean {
+	return key === ctx.oldKey || key.startsWith(ctx.oldKeyPrefix)
+}
+
+function rekeyCell(
+	cell: JournalCellImage,
+	ctx: RekeyContext,
+	liveServerIds: LiveServerIdsLookup,
+): JournalCellImage | null {
+	// Seal: an absent pre-image of the rekeyed entity (or a relation it owns) would
+	// un-create a now server-backed row on undo. Drop it.
+	if (!cell.present && isOwnedByRekeyed(cell.key, ctx)) {
+		return null
+	}
+
+	if (cell.kind === 'entity') {
+		const key = rekeyKey(cell.key, ctx)
+		if (!cell.snapshot) return { ...cell, key }
+		return { ...cell, key, snapshot: rekeySnapshotId(cell.snapshot, ctx) }
+	}
+
+	if (cell.kind === 'relation') {
+		const key = rekeyKey(cell.key, ctx)
+		if (!cell.state) return { ...cell, key }
+		return {
+			...cell,
+			key,
+			state: {
+				...cell.state,
+				currentId: cell.state.currentId === ctx.oldId ? ctx.newId : cell.state.currentId,
+				serverId: cell.state.serverId === ctx.oldId ? ctx.newId : cell.state.serverId,
+			},
+		}
+	}
+
+	const key = rekeyKey(cell.key, ctx)
+	if (!cell.state) return { ...cell, key }
+	let state = rekeyHasManyState(cell.state, ctx)
+	// Membership rebase: when the just-persisted create became a permanent member of
+	// this live list, fold it into the (older) pre-image so undo keeps it instead of
+	// dropping it. Default order picks it up automatically; an explicit order needs
+	// the id appended.
+	if (liveServerIds(key).has(ctx.newId) && !state.serverIds.has(ctx.newId)) {
+		const serverIds = new Set(state.serverIds)
+		serverIds.add(ctx.newId)
+		let orderedIds = state.orderedIds
+		if (orderedIds && !orderedIds.includes(ctx.newId)) {
+			orderedIds = [...orderedIds, ctx.newId]
+		}
+		state = { ...state, serverIds, orderedIds }
+	}
+	return { ...cell, key, state }
+}
+
+function rekeySnapshotId(snapshot: EntitySnapshot, ctx: RekeyContext): EntitySnapshot {
+	if (snapshot.id !== ctx.oldId) return snapshot
+	return createEntitySnapshot(
+		ctx.newId,
+		snapshot.entityType,
+		{ ...(snapshot.data as Record<string, unknown>), id: ctx.newId },
+		{ ...(snapshot.serverData as Record<string, unknown>), id: ctx.newId },
+		snapshot.version,
+	)
+}
+
+function swapInSet(set: Set<string>, oldId: string, newId: string): Set<string> {
+	if (!set.has(oldId)) return set
+	const next = new Set(set)
+	next.delete(oldId)
+	next.add(newId)
+	return next
+}
+
+function rekeyHasManyState(state: StoredHasManyState, ctx: RekeyContext): StoredHasManyState {
+	const serverIds = swapInSet(state.serverIds, ctx.oldId, ctx.newId)
+
+	let orderedIds = state.orderedIds
+	if (orderedIds) {
+		const idx = orderedIds.indexOf(ctx.oldId)
+		if (idx !== -1) {
+			orderedIds = [...orderedIds]
+			orderedIds[idx] = ctx.newId
+		}
+	}
+
+	let plannedAdditions = state.plannedAdditions
+	const additionKind = plannedAdditions.get(ctx.oldId)
+	if (additionKind !== undefined) {
+		plannedAdditions = new Map(plannedAdditions)
+		plannedAdditions.delete(ctx.oldId)
+		plannedAdditions.set(ctx.newId, additionKind)
+	}
+
+	let plannedRemovals = state.plannedRemovals
+	const removalType = plannedRemovals.get(ctx.oldId)
+	if (removalType !== undefined) {
+		plannedRemovals = new Map(plannedRemovals)
+		plannedRemovals.delete(ctx.oldId)
+		plannedRemovals.set(ctx.newId, removalType)
+	}
+
+	return { serverIds, orderedIds, plannedRemovals, plannedAdditions, version: state.version }
+}

package/src/undo/types.ts

@@ -1,58 +1,3 @@
-import type { StoreAffectedKeys } from '../core/actionClassification.js'
-import type { EntitySnapshot } from '../store/snapshots.js'
-import type {
-	StoredRelationState,
-	StoredHasManyState,
-	EntityMeta,
-} from '../store/SnapshotStore.js'
-
-/**
- * Partial snapshot of store state.
- * Contains only the data affected by an action or group of actions.
- */
-export interface PartialStoreSnapshot {
-	/** Entity snapshots (frozen, immutable) */
-	entitySnapshots: Map<string, EntitySnapshot>
-	/** Has-one relation states */
-	relationStates: Map<string, StoredRelationState>
-	/** Has-many list states */
-	hasManyStates: Map<string, StoredHasManyState>
-	/** Entity metadata (existsOnServer, deletion flags) */
-	entityMetas: Map<string, EntityMeta>
-}
-
-/**
- * A single undo/redo entry.
- * Contains the snapshot of state BEFORE the action(s) were applied.
- */
-export interface UndoEntry {
-	/** Unique identifier for this entry */
-	id: string
-	/** Optional human-readable label */
-	label?: string
-	/** Snapshot of state BEFORE the action(s) */
-	beforeSnapshot: PartialStoreSnapshot
-	/** Keys that were affected (for redo snapshot capture) */
-	affectedKeys: StoreAffectedKeys
-	/** When this entry was created */
-	timestamp: number
-}
-
-/**
- * Pending entry during debounce window.
- * Accumulates affected keys while waiting for debounce to complete.
- */
-export interface PendingUndoEntry {
-	/** Snapshot captured before the first action in the group */
-	beforeSnapshot: PartialStoreSnapshot
-	/** Accumulated affected keys */
-	affectedKeys: StoreAffectedKeys
-	/** When the first action occurred */
-	timestamp: number
-	/** Optional label for manual grouping */
-	label?: string
-}
-
 /**
  * Configuration options for UndoManager.
  */
@@ -79,6 +24,3 @@ export interface UndoState {
 	/** Number of entries in redo stack */
 	redoCount: number
 }
-
-// Re-export StoreAffectedKeys for convenience
-export type { StoreAffectedKeys } from '../core/actionClassification.js'

package/dist/core/actionClassification.d.ts

@@ -1,48 +0,0 @@
-import type { Action } from './actions.js';
-/**
- * Keys in the store that are affected by an action.
- * Used for partial snapshot capture/restore.
- */
-export interface StoreAffectedKeys {
-    /** Entity keys in format "entityType:id" */
-    entityKeys: string[];
-    /** Relation keys in format "entityType:id:fieldName" */
-    relationKeys: string[];
-    /** Has-many keys in format "entityType:id:fieldName" */
-    hasManyKeys: string[];
-}
-/**
- * Checks if an action should be tracked for undo/redo.
- * Server data loads (SET_ENTITY_DATA with isServerData=true) are not tracked.
- */
-export declare function isTrackableAction(action: Action): boolean;
-/**
- * Checks if an action should be skipped for undo/redo.
- */
-export declare function isSkippedAction(action: Action): boolean;
-/**
- * Creates an entity key from type and id.
- */
-export declare function createEntityKey(entityType: string, entityId: string): string;
-/**
- * Creates a relation key from parent type, id and field name.
- */
-export declare function createRelationKey(entityType: string, entityId: string, fieldName: string): string;
-/**
- * Extracts the store keys affected by an action.
- * Returns entity keys, relation keys, and has-many keys.
- */
-export declare function getAffectedKeys(action: Action): StoreAffectedKeys;
-/**
- * Merges two StoreAffectedKeys objects, deduplicating keys.
- */
-export declare function mergeAffectedKeys(target: StoreAffectedKeys, source: StoreAffectedKeys): void;
-/**
- * Creates an empty StoreAffectedKeys object.
- */
-export declare function createEmptyAffectedKeys(): StoreAffectedKeys;
-/**
- * Checks if StoreAffectedKeys is empty.
- */
-export declare function isEmptyAffectedKeys(keys: StoreAffectedKeys): boolean;
-//# sourceMappingURL=actionClassification.d.ts.map

package/dist/core/actionClassification.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"actionClassification.d.ts","sourceRoot":"","sources":["../../src/core/actionClassification.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IACjC,4CAA4C;IAC5C,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,wDAAwD;IACxD,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,wDAAwD;IACxD,WAAW,EAAE,MAAM,EAAE,CAAA;CACrB;AAyCD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CASzD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GACf,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAsDjE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,iBAAiB,GACvB,IAAI,CAgBN;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAM3D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAMpE"}

package/src/core/actionClassification.ts

@@ -1,199 +0,0 @@
-import type { Action } from './actions.js'
-
-/**
- * Keys in the store that are affected by an action.
- * Used for partial snapshot capture/restore.
- */
-export interface StoreAffectedKeys {
-	/** Entity keys in format "entityType:id" */
-	entityKeys: string[]
-	/** Relation keys in format "entityType:id:fieldName" */
-	relationKeys: string[]
-	/** Has-many keys in format "entityType:id:fieldName" */
-	hasManyKeys: string[]
-}
-
-/**
- * Action types that should be tracked for undo/redo.
- * These are user-initiated data mutations.
- */
-const TRACKABLE_ACTION_TYPES = new Set<Action['type']>([
-	'SET_FIELD',
-	'SET_ENTITY_DATA',
-	'SET_PLACEHOLDER_DATA',
-	'CONNECT_RELATION',
-	'DISCONNECT_RELATION',
-	'DELETE_RELATION',
-	'RESET_ENTITY',
-	'RESET_RELATION',
-	'CONNECT_TO_LIST',
-	'ADD_TO_LIST',
-	'REMOVE_FROM_LIST',
-	'MOVE_IN_LIST',
-])
-
-/**
- * Action types that should be skipped for undo/redo.
- * These are operational, commit, or error actions.
- */
-const SKIP_ACTION_TYPES = new Set<Action['type']>([
-	'SET_LOAD_STATE',
-	'SET_PERSISTING',
-	'COMMIT_ENTITY',
-	'COMMIT_RELATION',
-	// Error actions are skipped as errors are ephemeral state
-	'ADD_FIELD_ERROR',
-	'CLEAR_FIELD_ERRORS',
-	'ADD_ENTITY_ERROR',
-	'CLEAR_ENTITY_ERRORS',
-	'ADD_RELATION_ERROR',
-	'CLEAR_RELATION_ERRORS',
-	'CLEAR_ALL_SERVER_ERRORS',
-	'CLEAR_ALL_ERRORS',
-])
-
-/**
- * Checks if an action should be tracked for undo/redo.
- * Server data loads (SET_ENTITY_DATA with isServerData=true) are not tracked.
- */
-export function isTrackableAction(action: Action): boolean {
-	if (!TRACKABLE_ACTION_TYPES.has(action.type)) {
-		return false
-	}
-	// Server data loads are not user-initiated mutations
-	if (action.type === 'SET_ENTITY_DATA' && action.isServerData) {
-		return false
-	}
-	return true
-}
-
-/**
- * Checks if an action should be skipped for undo/redo.
- */
-export function isSkippedAction(action: Action): boolean {
-	return SKIP_ACTION_TYPES.has(action.type)
-}
-
-/**
- * Creates an entity key from type and id.
- */
-export function createEntityKey(entityType: string, entityId: string): string {
-	return `${entityType}:${entityId}`
-}
-
-/**
- * Creates a relation key from parent type, id and field name.
- */
-export function createRelationKey(
-	entityType: string,
-	entityId: string,
-	fieldName: string,
-): string {
-	return `${entityType}:${entityId}:${fieldName}`
-}
-
-/**
- * Extracts the store keys affected by an action.
- * Returns entity keys, relation keys, and has-many keys.
- */
-export function getAffectedKeys(action: Action): StoreAffectedKeys {
-	const entityKeys: string[] = []
-	const relationKeys: string[] = []
-	const hasManyKeys: string[] = []
-
-	switch (action.type) {
-		case 'SET_FIELD':
-		case 'SET_ENTITY_DATA':
-		case 'REFRESH_SERVER_DATA':
-		case 'RESET_ENTITY':
-		case 'COMMIT_ENTITY':
-			entityKeys.push(createEntityKey(action.entityType, action.entityId))
-			break
-
-		case 'CONNECT_RELATION':
-		case 'DISCONNECT_RELATION':
-		case 'DELETE_RELATION':
-		case 'RESET_RELATION':
-		case 'COMMIT_RELATION':
-		case 'SET_PLACEHOLDER_DATA':
-			relationKeys.push(
-				createRelationKey(action.entityType, action.entityId, action.fieldName),
-			)
-			break
-
-		case 'CONNECT_TO_LIST':
-		case 'ADD_TO_LIST':
-		case 'REMOVE_FROM_LIST':
-		case 'MOVE_IN_LIST':
-			hasManyKeys.push(
-				createRelationKey(action.entityType, action.entityId, action.fieldName),
-			)
-			break
-
-		case 'SET_LOAD_STATE':
-		case 'SET_PERSISTING':
-		case 'ADD_FIELD_ERROR':
-		case 'CLEAR_FIELD_ERRORS':
-		case 'ADD_ENTITY_ERROR':
-		case 'CLEAR_ENTITY_ERRORS':
-		case 'ADD_RELATION_ERROR':
-		case 'CLEAR_RELATION_ERRORS':
-		case 'CLEAR_ALL_SERVER_ERRORS':
-		case 'CLEAR_ALL_ERRORS':
-			// These don't affect undo-able state
-			break
-
-		default: {
-			const _exhaustive: never = action
-			throw new Error(`Unknown action type: ${(_exhaustive as Action).type}`)
-		}
-	}
-
-	return { entityKeys, relationKeys, hasManyKeys }
-}
-
-/**
- * Merges two StoreAffectedKeys objects, deduplicating keys.
- */
-export function mergeAffectedKeys(
-	target: StoreAffectedKeys,
-	source: StoreAffectedKeys,
-): void {
-	for (const key of source.entityKeys) {
-		if (!target.entityKeys.includes(key)) {
-			target.entityKeys.push(key)
-		}
-	}
-	for (const key of source.relationKeys) {
-		if (!target.relationKeys.includes(key)) {
-			target.relationKeys.push(key)
-		}
-	}
-	for (const key of source.hasManyKeys) {
-		if (!target.hasManyKeys.includes(key)) {
-			target.hasManyKeys.push(key)
-		}
-	}
-}
-
-/**
- * Creates an empty StoreAffectedKeys object.
- */
-export function createEmptyAffectedKeys(): StoreAffectedKeys {
-	return {
-		entityKeys: [],
-		relationKeys: [],
-		hasManyKeys: [],
-	}
-}
-
-/**
- * Checks if StoreAffectedKeys is empty.
- */
-export function isEmptyAffectedKeys(keys: StoreAffectedKeys): boolean {
-	return (
-		keys.entityKeys.length === 0 &&
-		keys.relationKeys.length === 0 &&
-		keys.hasManyKeys.length === 0
-	)
-}