@parhelia/core 0.3.12763 → 0.3.12768

package/dist/editor/client/operations.js

@@ -4,6 +4,7 @@ import { executeEditOperation, executeRedo, executeUndo, executeWorkflowCommand,
 import { DeleteItemsWarning } from "../DeleteItemsWarning";
 import React, { useCallback, useMemo, useRef, useState, } from "react";
 import { handleErrorResult } from "./helpers";
+import { isMissingEditOperationResult } from "./editHistoryReconciliation";
 import { useDebouncedCallback } from "use-debounce";
 import { createOrUpdateSuggestedEdit, deleteSuggestedEdit, } from "../services/suggestedEditsService";
 import { hasSuggestionContentChange, shouldRemoveNoOpSuggestion, } from "../reviews/suggestionContentChange";
@@ -14,10 +15,10 @@ import { isWorkflowMetadataField } from "../workflowFields";
 import { ExternalChangesWarningContent, TreeOperationConfirmContent, UndoDifferentItemContent, } from "./OperationDialogContent";
 import { isSuggestedEditRemoved, markSuggestedEditRemoved, upsertSuggestedEdit, } from "../reviews/suggestedEditState";
 import { logFieldValueDiagnostic, summarizeFieldDescriptor, summarizeFieldValue, } from "../fieldValueDiagnostics";
+import { getSuggestedEditItemLanguage, getSuggestedEditItemVersion, getSuggestionFieldIdentityKey, } from "../reviews/suggestionDisplayValue";
+import { enqueueSuggestedEditFieldTask, waitForSuggestedEditFieldTasks, } from "./suggestedEditFieldQueue";
 /** When true, the delete dialog shows "permanently delete (bypass recycle bin)". */
 const ENABLE_HARD_DELETE_IN_DELETE_DIALOG = false;
-// Track pending suggested edit save requests to prevent race conditions
-const pendingSuggestedEditSaves = new Map();
 // Track pending suggested edits to prevent creating duplicates before server response
 const pendingSuggestedEdits = new Map();
 const SUGGESTED_EDIT_SAVE_DEBOUNCE_MS = 500;
@@ -79,28 +80,23 @@ function fieldsMatchForLock(left, right) {
 // Helper function to clean up pending operations for a deleted suggested edit
 export function cleanupPendingSuggestedEditOperations(suggestedEdit, user) {
     const userKey = user?.name || "unknown";
-    const pendingFieldKey = `${suggestedEdit.itemId}:${suggestedEdit.mainItemLanguage}:${suggestedEdit.mainItemVersion}:${suggestedEdit.fieldId}:${userKey}`;
-    const saveKey = `${suggestedEdit.itemId}:${suggestedEdit.mainItemLanguage}:${suggestedEdit.mainItemVersion}:${suggestedEdit.fieldId}`;
+    const pendingFieldKey = `${getSuggestionFieldIdentityKey({
+        itemId: suggestedEdit.itemId,
+        language: getSuggestedEditItemLanguage(suggestedEdit),
+        version: getSuggestedEditItemVersion(suggestedEdit),
+        fieldId: suggestedEdit.fieldId,
+    })}:${userKey}`;
     // Remove from pending operations
     pendingSuggestedEdits.delete(pendingFieldKey);
-    pendingSuggestedEditSaves.delete(saveKey);
 }
 export async function waitForPendingSuggestedEditSave(suggestedEdit) {
-    const saveKey = `${suggestedEdit.itemId}:${suggestedEdit.mainItemLanguage}:${suggestedEdit.mainItemVersion}:${suggestedEdit.fieldId}`;
-    const pendingSave = pendingSuggestedEditSaves.get(saveKey);
-    if (!pendingSave)
-        return;
-    try {
-        await pendingSave;
-    }
-    catch (error) {
-        console.warn("Pending suggested edit save failed before apply:", error);
-    }
-    finally {
-        if (pendingSuggestedEditSaves.get(saveKey) === pendingSave) {
-            pendingSuggestedEditSaves.delete(saveKey);
-        }
-    }
+    const saveKey = getSuggestionFieldIdentityKey({
+        itemId: suggestedEdit.itemId,
+        language: getSuggestedEditItemLanguage(suggestedEdit),
+        version: getSuggestedEditItemVersion(suggestedEdit),
+        fieldId: suggestedEdit.fieldId,
+    });
+    await waitForSuggestedEditFieldTasks(saveKey);
 }
 export function getOperationsContext(state, ui) {
     const [editOperationExecuted, setEditOperationExecuted] = useState();
@@ -286,10 +282,10 @@ export function getOperationsContext(state, ui) {
             throw new Error("Failed to update personalization rules");
         }
     }, [executeOp]);
-    const updateRenderingRules = useCallback(async (componentId, rules) => {
-        const pageItem = stateRef.current.page?.item?.descriptor;
+    const updateRenderingRules = useCallback(async (componentId, rules, targetPageItem) => {
+        const pageItem = targetPageItem ?? stateRef.current.page?.item?.descriptor;
         if (!pageItem) {
-            return;
+            throw new Error("Cannot update personalization without a page item");
         }
         const op = {
             type: "update-rendering-rules",
@@ -302,7 +298,10 @@ export function getOperationsContext(state, ui) {
         };
         // waitForQuietPeriod debounces the iframe refresh so rapid auto-saves
         // (typing in a parameter input) don't make the page flicker on every keystroke.
-        await executeOp(op, { refresh: "waitForQuietPeriod" });
+        const result = await executeOp(op, { refresh: "waitForQuietPeriod" });
+        if (result.executionStatus === "failed") {
+            throw new Error("Failed to update personalization rules");
+        }
     }, [executeOp]);
     const handleResult = (result, options) => {
         if (handleErrorResult(result, ui, stateRef.current)) {
@@ -480,6 +479,9 @@ export function getOperationsContext(state, ui) {
     }, [itemsRepository, executeOp]);
     const lastEditField = useRef(undefined);
     const pendingFieldSaves = useRef(new Map());
+    const fieldEditGeneration = useRef(0);
+    const completedFieldSaveGeneration = useRef(0);
+    const latestSavedFieldEditOperationId = useRef(undefined);
     const getFieldSaveKey = (field) => {
         const database = field.item.database || "master";
         return `${field.item.id}:${field.item.language}:${field.item.version}:${database}:${field.fieldId}`.toLowerCase();
@@ -524,10 +526,17 @@ export function getOperationsContext(state, ui) {
             originatingSlotId,
             undoing: undoing.current,
         });
+        fieldEditGeneration.current += 1;
         if (effectiveMode === "suggestions" &&
             (stateRef.current.page || stateRef.current.currentItemDescriptor)) {
             // Create a unique key for this field to track pending saves
-            const fieldKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}`;
+            const fieldKey = getSuggestionFieldIdentityKey({
+                itemId: field.item.id,
+                language: field.item.language,
+                version: field.item.version,
+                fieldId: field.fieldId,
+            });
+            const pendingFieldKey = `${fieldKey}:${stateRef.current.user?.name || "unknown"}`;
             const op = await getOrMergeSuggestedEditOp(field, rawValue, value, {
                 page: stateRef.current.page,
                 currentItemDescriptor: stateRef.current.currentItemDescriptor,
@@ -550,26 +559,12 @@ export function getOperationsContext(state, ui) {
                 });
                 // Keep local suggestion state in step with typing immediately, then
                 // serialize persistence behind any in-flight save for this field.
-                const existingPromise = pendingSuggestedEditSaves.get(fieldKey);
-                if (existingPromise) {
-                    try {
-                        await existingPromise;
-                    }
-                    catch (error) {
-                        // Continue processing even if the previous save failed
-                        console.warn("Previous suggested edit save failed:", error);
-                    }
-                    // Clean up any stale entries that may not have been properly removed
-                    if (pendingSuggestedEditSaves.get(fieldKey) === existingPromise) {
-                        pendingSuggestedEditSaves.delete(fieldKey);
-                    }
-                }
                 // Create and track the save promise. useDebouncedCallback can return
                 // undefined before the trailing call runs, so this path uses a real
                 // promise that resolves after the delayed save completes.
                 const saveSnapshot = { ...op };
                 const expectedNewValue = saveSnapshot.newValue;
-                const savePromise = createDelayedSuggestedEditSave(saveSnapshot)
+                const savePromise = enqueueSuggestedEditFieldTask(fieldKey, () => createDelayedSuggestedEditSave(saveSnapshot))
                     .then((result) => {
                     // Update the suggested edits state with the result from the server
                     if (result.type === "success" && result.data) {
@@ -589,6 +584,18 @@ export function getOperationsContext(state, ui) {
                             source: "save-ack",
                         }));
                     }
+                    else if (result.type === "conflict") {
+                        if (result.suggestion) {
+                            stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, result.suggestion, {
+                                source: "save-ack",
+                            }));
+                            if (result.suggestion.status !== "pending" &&
+                                pendingSuggestedEdits.get(pendingFieldKey)?.id ===
+                                    result.suggestion.id) {
+                                pendingSuggestedEdits.delete(pendingFieldKey);
+                            }
+                        }
+                    }
                     else if (result.type === "error" ||
                         result.type === "unauthorized") {
                         // Show error toast for failed suggested edit save — unless the
@@ -605,20 +612,14 @@ export function getOperationsContext(state, ui) {
                     return result;
                 })
                     .finally(() => {
-                    // Remove from pending saves when complete
-                    if (pendingSuggestedEditSaves.get(fieldKey) === savePromise) {
-                        pendingSuggestedEditSaves.delete(fieldKey);
-                    }
                     // Also remove from pending edits once this exact value is
                     // persisted. If the user typed again, keep the newer draft.
-                    const pendingFieldKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}:${stateRef.current.user?.name || "unknown"}`;
                     const pendingEdit = pendingSuggestedEdits.get(pendingFieldKey);
                     if (pendingEdit?.id === saveSnapshot.id &&
                         pendingEdit.newValue === saveSnapshot.newValue) {
                         pendingSuggestedEdits.delete(pendingFieldKey);
                     }
                 });
-                pendingSuggestedEditSaves.set(fieldKey, savePromise);
                 await savePromise;
             }
             logFieldValueDiagnostic("operations", "suggestions edit complete", {
@@ -747,6 +748,10 @@ export function getOperationsContext(state, ui) {
                 isWorkflowMetadataField(op.fieldId, op.fieldName)) {
                 refreshWorkboxAfterWorkflowChange();
             }
+            if (result.executionStatus !== "failed") {
+                latestSavedFieldEditOperationId.current = op.id;
+                completedFieldSaveGeneration.current += 1;
+            }
             itemsRepository.onFieldSaved(field, val, saveSequence || 0, fieldModificationStore);
         }
         catch (error) {
@@ -784,6 +789,20 @@ export function getOperationsContext(state, ui) {
             fieldModificationStore,
         }));
     }, stateRef.current.configuration.debounceFieldEditsInterval * 2, { trailing: true });
+    const flushPendingFieldEdits = useCallback(async () => {
+        const completedGenerationBeforeFlush = completedFieldSaveGeneration.current;
+        const hadPendingDebouncedEdit = executeEditFieldDebounced.isPending();
+        if (hadPendingDebouncedEdit) {
+            await executeEditFieldDebounced.flush();
+        }
+        const inFlightSaves = Array.from(pendingFieldSaves.current.values());
+        if (inFlightSaves.length > 0) {
+            await Promise.allSettled(inFlightSaves);
+        }
+        return completedFieldSaveGeneration.current > completedGenerationBeforeFlush
+            ? latestSavedFieldEditOperationId.current
+            : undefined;
+    }, [executeEditFieldDebounced]);
     // Note: We intentionally keep a single save debounce window here.
     async function getEditOP(field, rawValue, value) {
         const item = await itemsRepository.getItem(field.item);
@@ -852,10 +871,14 @@ export function getOperationsContext(state, ui) {
         const result = await executeUndo(stateRef.current.sessionId, ops.map((x) => x.id));
         // Update state only AFTER API call completes - no optimistic update
         // This ensures the UI only changes when the operation truly completes
-        handleResult(result, { refresh: "immediate" });
+        const operationWasRemoved = isMissingEditOperationResult(result);
+        if (!operationWasRemoved) {
+            handleResult(result, { refresh: "immediate" });
+        }
         if (result.type === "success") {
-            for (const op of ops) {
-                recentlyUndoneIds.current.add(op.id);
+            for (const executedOp of result.data) {
+                recentlyUndoneIds.current.add(executedOp.id);
+                recentlyRedoneIds.current.delete(executedOp.id);
             }
             // Check if any operations are executing in background (long-running undo)
             const executingOps = result.data.filter((x) => x.executionStatus === "executing");
@@ -892,18 +915,11 @@ export function getOperationsContext(state, ui) {
                 .flat()
                 .filter((x) => x != null);
             await itemsRepository.refreshItems(itemsToRefresh);
-            // NOTE: We no longer call requestRefresh here because handleResult (line 716) already
-            // triggers an immediate refresh. Calling it again caused duplicate/flooding refreshes
-            // which overwhelmed the iframe's requestRefresh and caused race conditions.
-            // The handleResult refresh combined with itemsRepository.refreshItems above is sufficient.
+            // handleResult already triggers the single immediate page refresh.
+            // Avoid a second request here, which can flood a busy rendering host.
             return true;
         }
         else {
-            ui.showErrorToast({
-                summary: result.summary,
-                details: result.details,
-                rawDetails: result.rawDetails,
-            });
             // Refresh history so toolbar state matches server (fixes inconsistent UI under load)
             stateRef.current.refreshHistory?.(stateRef.current.historyMode, stateRef.current.showOnlyMyChanges);
             return false;
@@ -953,6 +969,10 @@ export function getOperationsContext(state, ui) {
         }
         undoing.current = true;
         try {
+            const pendingFieldOperationId = await flushPendingFieldEdits();
+            if (pendingFieldOperationId) {
+                operationId = pendingFieldOperationId;
+            }
             const currentItem = stateRef.current.item?.descriptor;
             const filterBySession = stateRef.current.showOnlyMyChanges;
             const historyMode = stateRef.current.historyMode;
@@ -1181,14 +1201,20 @@ export function getOperationsContext(state, ui) {
             undoing.current = false;
             console.log("undoing flag reset");
         }
-    }, [ui, executeUndoOperation]);
+    }, [ui, executeUndoOperation, flushPendingFieldEdits]);
     const executeRedoOperation = useCallback(async (op) => {
         const result = await executeRedo(stateRef.current.sessionId, op.id);
         // NOTE: We no longer update editHistory here. The single source of truth is EditorShell,
         // which merges server responses + websocket updates while enforcing scope filtering.
-        handleResult(result, { refresh: "immediate" });
+        const operationWasRemoved = isMissingEditOperationResult(result);
+        if (!operationWasRemoved) {
+            handleResult(result, { refresh: "immediate" });
+        }
         if (result.type === "success") {
-            recentlyRedoneIds.current.add(op.id);
+            for (const executedOp of result.data) {
+                recentlyRedoneIds.current.add(executedOp.id);
+                recentlyUndoneIds.current.delete(executedOp.id);
+            }
             // Check if the operation is executing in background (long-running redo)
             const executingOps = result.data.filter((x) => x.executionStatus === "executing");
             if (executingOps.length > 0) {
@@ -1217,11 +1243,6 @@ export function getOperationsContext(state, ui) {
             return true;
         }
         else {
-            ui.showErrorToast({
-                summary: result.summary,
-                details: result.details,
-                rawDetails: result.rawDetails,
-            });
             stateRef.current.refreshHistory?.(stateRef.current.historyMode, stateRef.current.showOnlyMyChanges);
             return false;
         }
@@ -1237,6 +1258,7 @@ export function getOperationsContext(state, ui) {
         }
         undoing.current = true;
         try {
+            await flushPendingFieldEdits();
             const currentItem = stateRef.current.item?.descriptor;
             if (!currentItem)
                 return false;
@@ -1410,7 +1432,7 @@ export function getOperationsContext(state, ui) {
             // Always reset the flag
             undoing.current = false;
         }
-    }, [ui, itemsRepository, executeRedoOperation]);
+    }, [ui, itemsRepository, executeRedoOperation, flushPendingFieldEdits]);
     const deleteItems = useCallback(async (items, options) => {
         if (items.length === 0)
             return;
@@ -1689,10 +1711,23 @@ export function getOperationsContext(state, ui) {
         return result;
     }, [executeOp]);
     const onFieldBlur = useCallback(() => {
+        const editGenerationAtBlur = fieldEditGeneration.current;
+        const pendingSave = executeEditFieldDebounced.isPending()
+            ? executeEditFieldDebounced.flush()
+            : undefined;
+        if (pendingSave) {
+            void Promise.resolve(pendingSave).finally(() => {
+                // Preserve a newer edit that started while the blurred field was saving.
+                if (fieldEditGeneration.current === editGenerationAtBlur) {
+                    lastOp.current = undefined;
+                }
+            });
+            return;
+        }
         // Reset the last operation to force creation of a new operation
-        // when the user returns to edit any field after losing focus
+        // when the user returns to edit any field after losing focus.
         lastOp.current = undefined;
-    }, []);
+    }, [executeEditFieldDebounced]);
     // Extract state values to avoid object reference changes
     const mode = stateRef.current.mode;
     const page = stateRef.current.page;
@@ -1810,18 +1845,12 @@ function removeSuggestedEditFromState(edit, state, keys) {
     // removal is settling (e.g. an edit queued behind the in-flight save) would
     // otherwise fire after an early release and resurrect the suggestion.
     markSuggestedEditRemoved(edit.id);
-    // The saves map is keyed by the field's own item descriptor (which can have
-    // a different version/language than the page the suggestion is stored
-    // under), so the caller passes the exact keys it used.
-    const pendingSave = pendingSuggestedEditSaves.get(keys.saveKey);
     pendingSuggestedEdits.delete(keys.pendingFieldKey);
     cleanupPendingSuggestedEditOperations(edit, state.user);
     state.setSuggestedEdits((current) => current.filter((candidate) => candidate.id !== edit.id));
     // Delete on the server only after any in-flight save settles, otherwise the
     // delete can race ahead of a pending create and the suggestion comes back.
-    void Promise.resolve(pendingSave)
-        .catch(() => undefined)
-        .then(() => deleteSuggestedEdit(edit))
+    void enqueueSuggestedEditFieldTask(keys.saveKey, () => deleteSuggestedEdit(edit))
         .then((result) => {
         if (result.type !== "success") {
             console.warn("Failed to delete no-op suggestion:", result.summary, result.details);
@@ -1856,7 +1885,12 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
     // key format as editField (the field's own item descriptor — NOT the
     // suggestion's mainItem fields, which hold the page's language/version and
     // diverge for datasource items).
-    const saveKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}`;
+    const saveKey = getSuggestionFieldIdentityKey({
+        itemId: field.item.id,
+        language: field.item.language,
+        version: field.item.version,
+        fieldId: field.fieldId,
+    });
     const fieldKey = `${saveKey}:${state.user?.name || "unknown"}`;
     const shouldRemoveAsNoOp = (edit, nextValue) => 
     // Comments load asynchronously; deleting on the strength of a not-yet-
@@ -1888,6 +1922,8 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         // Update the pending edit instead of creating a new one.
         const updatedEdit = {
             ...pendingEdit,
+            itemLanguage: field.item.language,
+            itemVersion: field.item.version,
             newValue: nextValue,
             updated: new Date().toISOString(),
             updatedBy: state.user?.name || "unknown",
@@ -1899,6 +1935,9 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
     const matchingSuggestions = state.suggestedEdits.filter((edit) => edit.mainItemId === pageDescriptor.id &&
         edit.mainItemLanguage === pageDescriptor.language &&
         edit.itemId === item.id &&
+        getSuggestedEditItemLanguage(edit) === field.item.language &&
+        (getSuggestedEditItemVersion(edit) === 0 ||
+            getSuggestedEditItemVersion(edit) === field.item.version) &&
         edit.fieldId === field.fieldId);
     // Attempt to find an existing suggested edit by the same user for this field.
     // Tombstoned ids are skipped: the state snapshot can still contain a
@@ -1908,6 +1947,9 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         edit.mainItemLanguage === pageDescriptor.language &&
         edit.mainItemVersion === pageDescriptor.version &&
         edit.itemId === item.id &&
+        getSuggestedEditItemLanguage(edit) === field.item.language &&
+        (getSuggestedEditItemVersion(edit) === 0 ||
+            getSuggestedEditItemVersion(edit) === field.item.version) &&
         edit.fieldId === field.fieldId &&
         edit.author === (state.user?.name || "unknown") &&
         edit.status === "pending" && // or any status that indicates it's open for further editing.
@@ -1924,6 +1966,8 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         // Update the existing suggestion.
         const updatedEdit = {
             ...existing,
+            itemLanguage: field.item.language,
+            itemVersion: field.item.version,
             newValue: nextValue,
             updated: new Date().toISOString(),
             updatedBy: state.user?.name || "unknown",
@@ -1944,6 +1988,8 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
             mainItemLanguage: pageDescriptor.language,
             mainItemVersion: pageDescriptor.version,
             itemId: item.id,
+            itemLanguage: field.item.language,
+            itemVersion: field.item.version,
             fieldId: field.fieldId,
             oldValue: fieldItem.rawValue || "",
             newValue: newVal || "",