@open-mercato/core 0.6.6-develop.6205.1.109e4b6a84 → 0.6.6-develop.6227.1.2695efff30

package/dist/modules/planner/components/AvailabilityRulesEditor.js

@@ -16,6 +16,7 @@ import {
 import { LoadingMessage, ErrorMessage } from "@open-mercato/ui/backend/detail";
 import { apiCall, apiCallOrThrow, withScopedApiRequestHeaders } from "@open-mercato/ui/backend/utils/apiCall";
 import { createCrud, deleteCrud, updateCrud } from "@open-mercato/ui/backend/utils/crud";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
 import { buildOptimisticLockHeader } from "@open-mercato/ui/backend/utils/optimisticLock";
 import { flash } from "@open-mercato/ui/backend/FlashMessages";
 import { Spinner } from "@open-mercato/ui/primitives/spinner";
@@ -28,6 +29,7 @@ import {
 import { useT } from "@open-mercato/shared/lib/i18n/context";
 import { useConfirmDialog } from "@open-mercato/ui/backend/confirm-dialog";
 import { normalizeCrudServerError } from "@open-mercato/ui/backend/utils/serverErrors";
+import { surfaceRecordConflict } from "@open-mercato/ui/backend/conflicts";
 import { parseAvailabilityRuleWindow } from "@open-mercato/core/modules/planner/lib/availabilitySchedule";
 import { deleteAvailabilityRuleSet } from "@open-mercato/core/modules/planner/lib/deleteAvailabilityRuleSet";
 import { CrudForm } from "@open-mercato/ui/backend/CrudForm";
@@ -43,6 +45,22 @@ function withOptimisticLockForRule(rule, mutation) {
 function withOptimisticLockForRuleSet(ruleSet, mutation) {
   return withScopedApiRequestHeaders(buildOptimisticLockHeader(ruleSet?.updatedAt ?? ruleSet?.updated_at ?? null), mutation);
 }
+function resolveDateSpecificLockToken(rules) {
+  let latestMs = Number.NEGATIVE_INFINITY;
+  let latestIso = null;
+  for (const rule of rules) {
+    const raw = rule.updatedAt ?? rule.updated_at ?? null;
+    if (!raw) continue;
+    const ms = Date.parse(raw);
+    if (!Number.isFinite(ms) || ms <= latestMs) continue;
+    latestMs = ms;
+    latestIso = raw;
+  }
+  return latestIso;
+}
+function withOptimisticLockForDateSpecific(rules, mutation) {
+  return withScopedApiRequestHeaders(buildOptimisticLockHeader(resolveDateSpecificLockToken(rules)), mutation);
+}
 const DAY_LABELS = [
   { code: "SU", short: "S", nameKey: "schedule.weekday.sunday", fallback: "Sunday" },
   { code: "MO", short: "M", nameKey: "schedule.weekday.monday", fallback: "Monday" },
@@ -289,6 +307,19 @@ function AvailabilityRulesEditor({
 }) {
   const t = useT();
   const { confirm, ConfirmDialogElement } = useConfirmDialog();
+  const mutationContextId = "planner-availability-rules-editor";
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: mutationContextId,
+    blockedMessage: t("ui.forms.flash.saveBlocked", "Save blocked by validation")
+  });
+  const mutationContext = React.useMemo(
+    () => ({
+      formId: mutationContextId,
+      resourceKind: "planner.availability",
+      retryLastMutation
+    }),
+    [mutationContextId, retryLastMutation]
+  );
   const isReadOnly = Boolean(readOnly);
   const canManageUnavailability = allowUnavailability ?? true;
   const dialogRef = React.useRef(null);
@@ -692,16 +723,20 @@ function AvailabilityRulesEditor({
     setIsWeeklyAutoSaving(options?.silentSuccess === true);
     try {
       const windows = buildWeeklyPayload(normalizeWeeklyWindows(weeklyWindowsRef.current));
-      await apiCallOrThrow("/api/planner/availability-weekly", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          subjectType: subjectForRules,
-          subjectId: subjectIdForRules,
-          timezone,
-          windows
-        })
-      }, { errorMessage: listLabels.saveWeeklyError });
+      await runMutation({
+        operation: () => apiCallOrThrow("/api/planner/availability-weekly", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            subjectType: subjectForRules,
+            subjectId: subjectIdForRules,
+            timezone,
+            windows
+          })
+        }, { errorMessage: listLabels.saveWeeklyError }),
+        context: mutationContext,
+        mutationPayload: { action: "save-weekly", subjectType: subjectForRules, subjectId: subjectIdForRules }
+      });
       lastSavedWeeklyKeyRef.current = weeklyKey;
       weeklyDirtyRef.current = false;
       if (!options?.silentSuccess) {
@@ -729,7 +764,9 @@ function AvailabilityRulesEditor({
     usingRuleSet,
     weeklyHasErrors,
     weeklyKey,
-    isReadOnly
+    isReadOnly,
+    mutationContext,
+    runMutation
   ]);
   React.useEffect(() => {
     saveWeeklyRef.current = saveWeeklyHours;
@@ -795,7 +832,11 @@ function AvailabilityRulesEditor({
         })));
       }
       if (updates.length) {
-        await Promise.all(updates);
+        await runMutation({
+          operation: () => Promise.all(updates),
+          context: mutationContext,
+          mutationPayload: { action: "update-timezone", timezone: trimmedTimezone }
+        });
         await refreshAvailability();
         await refreshRuleSetRules();
       }
@@ -816,7 +857,9 @@ function AvailabilityRulesEditor({
     effectiveRulesetId,
     subjectId,
     subjectType,
-    isReadOnly
+    isReadOnly,
+    mutationContext,
+    runMutation
   ]);
   React.useEffect(() => {
     if (!timezoneDirty) return;
@@ -853,14 +896,18 @@ function AvailabilityRulesEditor({
         kind: rule.kind ?? "availability",
         note: rule.note ?? null
       }));
-      await Promise.all(creations);
+      await runMutation({
+        operation: () => Promise.all(creations),
+        context: mutationContext,
+        mutationPayload: { action: "customize", count: creations.length }
+      });
       setCustomOverridesEnabled(true);
       await refreshAvailability();
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : listLabels.saveWeeklyError;
       flash(message, "error");
     }
-  }, [effectiveRulesetId, listLabels.saveWeeklyError, refreshAvailability, rulesetRules, subjectId, subjectType, isReadOnly]);
+  }, [effectiveRulesetId, listLabels.saveWeeklyError, refreshAvailability, rulesetRules, subjectId, subjectType, isReadOnly, mutationContext, runMutation]);
   const handleResetToRuleSet = React.useCallback(async () => {
     if (isReadOnly) return;
     if (!effectiveRulesetId) return;
@@ -874,31 +921,39 @@ function AvailabilityRulesEditor({
     try {
       const idsToDelete = selectCustomRuleIdsToDelete("reset", availabilityRules);
       const idsToDeleteSet = new Set(idsToDelete);
-      await Promise.all(
-        availabilityRules.filter((rule) => idsToDeleteSet.has(rule.id)).map((rule) => withOptimisticLockForRule(
-          rule,
-          () => deleteCrud("planner/availability", rule.id, { errorMessage: listLabels.saveWeeklyError })
-        ))
-      );
+      await runMutation({
+        operation: () => Promise.all(
+          availabilityRules.filter((rule) => idsToDeleteSet.has(rule.id)).map((rule) => withOptimisticLockForRule(
+            rule,
+            () => deleteCrud("planner/availability", rule.id, { errorMessage: listLabels.saveWeeklyError })
+          ))
+        ),
+        context: mutationContext,
+        mutationPayload: { action: "reset-to-ruleset", ids: idsToDelete }
+      });
       setCustomOverridesEnabled(false);
       await refreshAvailability();
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : listLabels.saveWeeklyError;
       flash(message, "error");
     }
-  }, [availabilityRules, confirm, effectiveRulesetId, listLabels.ruleSetConfirm, listLabels.saveWeeklyError, refreshAvailability, isReadOnly]);
+  }, [availabilityRules, confirm, effectiveRulesetId, listLabels.ruleSetConfirm, listLabels.saveWeeklyError, refreshAvailability, isReadOnly, mutationContext, runMutation]);
   const handleRuleSetChange = React.useCallback(async (nextId) => {
     if (isReadOnly) return;
     if (!onRulesetChange) return;
     const idsToDelete = selectCustomRuleIdsToDelete("switch", availabilityRules);
     if (idsToDelete.length) {
       const idsToDeleteSet = new Set(idsToDelete);
-      await Promise.all(
-        availabilityRules.filter((rule) => idsToDeleteSet.has(rule.id)).map((rule) => withOptimisticLockForRule(
-          rule,
-          () => deleteCrud("planner/availability", rule.id, { errorMessage: listLabels.saveWeeklyError })
-        ))
-      );
+      await runMutation({
+        operation: () => Promise.all(
+          availabilityRules.filter((rule) => idsToDeleteSet.has(rule.id)).map((rule) => withOptimisticLockForRule(
+            rule,
+            () => deleteCrud("planner/availability", rule.id, { errorMessage: listLabels.saveWeeklyError })
+          ))
+        ),
+        context: mutationContext,
+        mutationPayload: { action: "switch-ruleset", ids: idsToDelete }
+      });
     }
     setSelectedRulesetId(nextId);
     setCustomOverridesEnabled(false);
@@ -915,7 +970,9 @@ function AvailabilityRulesEditor({
     listLabels.saveWeeklyError,
     onRulesetChange,
     refreshAvailability,
-    isReadOnly
+    isReadOnly,
+    mutationContext,
+    runMutation
   ]);
   const handleDeleteRuleSet = React.useCallback(async () => {
     if (isReadOnly || !onRulesetChange || !rulesetId) return;
@@ -929,7 +986,11 @@ function AvailabilityRulesEditor({
         variant: "destructive"
       }),
       deleteRuleSet: async (id) => {
-        await withOptimisticLockForRuleSet(selected, () => deleteCrud("planner/availability-rule-sets", id, { errorMessage: listLabels.ruleSetDeleteError }));
+        await runMutation({
+          operation: () => withOptimisticLockForRuleSet(selected, () => deleteCrud("planner/availability-rule-sets", id, { errorMessage: listLabels.ruleSetDeleteError })),
+          context: mutationContext,
+          mutationPayload: { action: "delete-ruleset", id }
+        });
       },
       clearAssignment: async () => {
         setCustomOverridesEnabled(false);
@@ -955,7 +1016,9 @@ function AvailabilityRulesEditor({
     refreshAvailability,
     refreshRuleSets,
     ruleSets,
-    rulesetId
+    rulesetId,
+    mutationContext,
+    runMutation
   ]);
   const ruleSetFormSchema = React.useMemo(
     () => z.object({
@@ -1134,11 +1197,11 @@ function AvailabilityRulesEditor({
           unavailabilityReasonEntryId: editorUnavailable ? reasonEntryId : null,
           unavailabilityReasonValue: editorUnavailable ? reasonValue : null
         };
-        await apiCallOrThrow("/api/planner/availability-date-specific", {
+        await withOptimisticLockForDateSpecific(editorRules, () => apiCallOrThrow("/api/planner/availability-date-specific", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify(payload)
-        }, { errorMessage: listLabels.saveDateError });
+        }, { errorMessage: listLabels.saveDateError }));
       } else {
         const rulesToDelete = editorRules;
         const uniqueRulesById = new Map(rulesToDelete.map((rule) => [rule.id, rule]));
@@ -1172,6 +1235,7 @@ function AvailabilityRulesEditor({
       await refreshAvailability();
       await refreshRuleSetRules();
     } catch (error2) {
+      if (surfaceRecordConflict(error2, t)) return;
       const message = error2 instanceof Error ? error2.message : listLabels.saveDateError;
       flash(message, "error");
     }
@@ -1197,7 +1261,8 @@ function AvailabilityRulesEditor({
     timezone,
     usingRuleSet,
     canManageUnavailability,
-    isReadOnly
+    isReadOnly,
+    t
   ]);
   const handleSlotClick = React.useCallback((slot) => {
     if (usingRuleSet || isReadOnly) return;
@@ -1453,12 +1518,16 @@ function AvailabilityRulesEditor({
                         variant: "outline",
                         size: "icon",
                         onClick: async () => {
-                          await Promise.all(
-                            rules.map((rule) => withOptimisticLockForRule(
-                              rule,
-                              () => deleteCrud("planner/availability", rule.id)
-                            ))
-                          );
+                          await runMutation({
+                            operation: () => Promise.all(
+                              rules.map((rule) => withOptimisticLockForRule(
+                                rule,
+                                () => deleteCrud("planner/availability", rule.id)
+                              ))
+                            ),
+                            context: mutationContext,
+                            mutationPayload: { action: "delete-date-rules", count: rules.length }
+                          });
                           await refreshAvailability();
                           await refreshRuleSetRules();
                         },