@open-mercato/core 0.6.6-develop.6205.1.109e4b6a84 → 0.6.6-develop.6228.1.cf483c68b5

package/src/modules/planner/components/AvailabilityRulesEditor.tsx

@@ -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'
@@ -29,6 +30,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, type CrudField } from '@open-mercato/ui/backend/CrudForm'
@@ -108,6 +110,30 @@ function withOptimisticLockForRuleSet<T>(ruleSet: AvailabilityRuleSet | null | u
   return withScopedApiRequestHeaders(buildOptimisticLockHeader(ruleSet?.updatedAt ?? ruleSet?.updated_at ?? null), mutation)
 }
 
+/**
+ * The date-specific replace endpoint mutates a subject/date aggregate that has
+ * no single parent row, so its lock version is the latest `updated_at` of the
+ * one-off rules being replaced (mirrors the command-side derivation). Returns
+ * null when no existing rules back the date so the header is omitted (additive).
+ */
+function resolveDateSpecificLockToken(rules: AvailabilityRule[]): string | null {
+  let latestMs = Number.NEGATIVE_INFINITY
+  let latestIso: string | null = 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<T>(rules: AvailabilityRule[], mutation: () => Promise<T>): Promise<T> {
+  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' },
@@ -381,6 +407,23 @@ export function AvailabilityRulesEditor({
 }: AvailabilityRulesEditorProps) {
   const t = useT()
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
+  const mutationContextId = 'planner-availability-rules-editor'
+  const { runMutation, retryLastMutation } = useGuardedMutation<{
+    formId: string
+    resourceKind: string
+    retryLastMutation: () => Promise<boolean>
+  }>({
+    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<HTMLDivElement | null>(null)
@@ -818,16 +861,20 @@ export 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) {
@@ -856,6 +903,8 @@ export function AvailabilityRulesEditor({
     weeklyHasErrors,
     weeklyKey,
     isReadOnly,
+    mutationContext,
+    runMutation,
   ])
 
   React.useEffect(() => {
@@ -929,7 +978,11 @@ export 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()
       }
@@ -951,6 +1004,8 @@ export function AvailabilityRulesEditor({
     subjectId,
     subjectType,
     isReadOnly,
+    mutationContext,
+    runMutation,
   ])
 
   React.useEffect(() => {
@@ -990,14 +1045,18 @@ export 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 (error) {
       const message = error instanceof Error ? error.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
@@ -1012,21 +1071,25 @@ export 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 (error) {
       const message = error instanceof Error ? error.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: string | null) => {
     if (isReadOnly) return
@@ -1035,14 +1098,18 @@ export function AvailabilityRulesEditor({
     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)
@@ -1060,6 +1127,8 @@ export function AvailabilityRulesEditor({
     onRulesetChange,
     refreshAvailability,
     isReadOnly,
+    mutationContext,
+    runMutation,
   ])
 
   const handleDeleteRuleSet = React.useCallback(async () => {
@@ -1076,9 +1145,13 @@ export function AvailabilityRulesEditor({
       deleteRuleSet: async (id) => {
         // Version-check the schedule delete (the list page already does; the editor
         // previously sent no header → last-write-wins on delete). #2055 round-5.
-        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)
@@ -1105,6 +1178,8 @@ export function AvailabilityRulesEditor({
     refreshRuleSets,
     ruleSets,
     rulesetId,
+    mutationContext,
+    runMutation,
   ])
 
   const ruleSetFormSchema = React.useMemo(
@@ -1299,11 +1374,11 @@ export 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]))
@@ -1338,6 +1413,7 @@ export function AvailabilityRulesEditor({
       await refreshAvailability()
       await refreshRuleSetRules()
     } catch (error) {
+      if (surfaceRecordConflict(error, t)) return
       const message = error instanceof Error ? error.message : listLabels.saveDateError
       flash(message, 'error')
     }
@@ -1364,6 +1440,7 @@ export function AvailabilityRulesEditor({
     usingRuleSet,
     canManageUnavailability,
     isReadOnly,
+    t,
   ])
 
   const handleSlotClick = React.useCallback((slot: ScheduleSlot) => {
@@ -1658,12 +1735,16 @@ export 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()
                                 }}

package/src/modules/query_index/api/purge.ts

@@ -4,6 +4,10 @@ import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { queryIndexTag, queryIndexErrorSchema, queryIndexOkSchema, queryIndexPurgeRequestSchema } from './openapi'
 import { recordIndexerLog } from '@open-mercato/shared/lib/indexers/status-log'
+import {
+  runCrudMutationGuardAfterSuccess,
+  validateCrudMutationGuard,
+} from '@open-mercato/shared/lib/crud/mutation-guard'
 
 export const metadata = {
   POST: { requireAuth: true, requireFeatures: ['query_index.purge'] },
@@ -16,12 +20,29 @@ export async function POST(req: Request) {
   const entityType = String(body?.entityType || '')
   if (!entityType) return NextResponse.json({ error: 'Missing entityType' }, { status: 400 })
 
-  const { resolve } = await createRequestContainer()
+  const container = await createRequestContainer()
   let em: any | null = null
   try {
-    em = resolve('em')
+    em = container.resolve('em')
   } catch {}
-  const bus = resolve('eventBus') as any
+  const bus = container.resolve('eventBus') as any
+
+  const guardUserId = typeof auth.sub === 'string' ? auth.sub : ''
+  const guardResult = await validateCrudMutationGuard(container, {
+    tenantId: auth.tenantId,
+    organizationId: auth.orgId,
+    userId: guardUserId,
+    resourceKind: 'query_index',
+    resourceId: entityType,
+    operation: 'custom',
+    requestMethod: req.method,
+    requestHeaders: req.headers,
+    mutationPayload: { entityType },
+  })
+  if (guardResult && !guardResult.ok) {
+    return NextResponse.json(guardResult.body, { status: guardResult.status })
+  }
+
   await recordIndexerLog(
     { em: em ?? undefined },
     {
@@ -50,6 +71,19 @@ export async function POST(req: Request) {
         organizationId: auth.orgId ?? null,
       },
     ).catch(() => undefined)
+    if (guardResult?.ok && guardResult.shouldRunAfterSuccess) {
+      await runCrudMutationGuardAfterSuccess(container, {
+        tenantId: auth.tenantId,
+        organizationId: auth.orgId,
+        userId: guardUserId,
+        resourceKind: 'query_index',
+        resourceId: entityType,
+        operation: 'custom',
+        requestMethod: req.method,
+        requestHeaders: req.headers,
+        metadata: guardResult.metadata ?? null,
+      })
+    }
   } catch (error) {
     await recordIndexerLog(
       { em: em ?? undefined },

package/src/modules/query_index/api/reindex.ts

@@ -5,6 +5,10 @@ import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib
 import { queryIndexTag, queryIndexErrorSchema, queryIndexOkSchema, queryIndexReindexRequestSchema } from './openapi'
 import { recordIndexerLog } from '@open-mercato/shared/lib/indexers/status-log'
 import { isValidEntityIdShape } from '@open-mercato/shared/lib/query/engine'
+import {
+  runCrudMutationGuardAfterSuccess,
+  validateCrudMutationGuard,
+} from '@open-mercato/shared/lib/crud/mutation-guard'
 
 export const metadata = {
   POST: { requireAuth: true, requireFeatures: ['query_index.reindex'] },
@@ -31,16 +35,39 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'partitionIndex must be < partitionCount' }, { status: 400 })
   }
 
-  const { resolve } = await createRequestContainer()
+  const container = await createRequestContainer()
   let em: any | null = null
   try {
-    em = resolve('em')
+    em = container.resolve('em')
   } catch {}
-  const bus = resolve('eventBus') as any
+  const bus = container.resolve('eventBus') as any
   const partitions = partitionIndex !== undefined
     ? [partitionIndex]
     : Array.from({ length: partitionCount }, (_, idx) => idx)
   const firstPartition = partitions[0] ?? 0
+
+  const guardUserId = typeof auth.sub === 'string' ? auth.sub : ''
+  const guardResult = await validateCrudMutationGuard(container, {
+    tenantId: auth.tenantId,
+    organizationId: auth.orgId,
+    userId: guardUserId,
+    resourceKind: 'query_index',
+    resourceId: entityType,
+    operation: 'custom',
+    requestMethod: req.method,
+    requestHeaders: req.headers,
+    mutationPayload: {
+      entityType,
+      force,
+      batchSize: batchSize ?? null,
+      partitionCount,
+      partitionIndex: partitionIndex ?? null,
+    },
+  })
+  if (guardResult && !guardResult.ok) {
+    return NextResponse.json(guardResult.body, { status: guardResult.status })
+  }
+
   await recordIndexerLog(
     { em: em ?? undefined },
     {
@@ -102,6 +129,19 @@ export async function POST(req: Request) {
         },
       },
     ).catch(() => undefined)
+    if (guardResult?.ok && guardResult.shouldRunAfterSuccess) {
+      await runCrudMutationGuardAfterSuccess(container, {
+        tenantId: auth.tenantId,
+        organizationId: auth.orgId,
+        userId: guardUserId,
+        resourceKind: 'query_index',
+        resourceId: entityType,
+        operation: 'custom',
+        requestMethod: req.method,
+        requestHeaders: req.headers,
+        metadata: guardResult.metadata ?? null,
+      })
+    }
   } catch (error) {
     await recordIndexerLog(
       { em: em ?? undefined },

package/src/modules/query_index/components/QueryIndexesTable.tsx

@@ -10,6 +10,9 @@ import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+
+const MUTATION_CONTEXT_ID = 'query_index.status.list:actions'
 
 type Translator = (key: string, params?: Record<string, string | number>) => string
 
@@ -227,6 +230,15 @@ export default function QueryIndexesTable() {
   const t = useT()
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
   const columns = React.useMemo(() => createColumns(t), [t])
+  const { runMutation, retryLastMutation } = useGuardedMutation<{
+    formId: string
+    resourceKind: string
+    resourceId: string
+    retryLastMutation: () => Promise<boolean>
+  }>({
+    contextId: MUTATION_CONTEXT_ID,
+    blockedMessage: t('ui.forms.flash.saveBlocked', 'Save blocked by validation'),
+  })
 
   const { data, isLoading } = useQuery<Resp>({
     queryKey: ['query-index-status', scopeVersion, refreshSeq],
@@ -257,11 +269,21 @@ export default function QueryIndexesTable() {
         action === 'purge' ? t('query_index.table.actions.purge') : t('query_index.table.actions.reindex')
       const errorMessage = t('query_index.table.errors.actionFailed', { action: actionLabel })
       try {
-        await apiCallOrThrow(`/api/query_index/${action}`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify(body),
-        }, { errorMessage })
+        await runMutation({
+          operation: () =>
+            apiCallOrThrow(`/api/query_index/${action}`, {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify(body),
+            }, { errorMessage }),
+          context: {
+            formId: MUTATION_CONTEXT_ID,
+            resourceKind: 'query_index',
+            resourceId: entityId,
+            retryLastMutation,
+          },
+          mutationPayload: { action, entityType: entityId, force: Boolean(opts?.force) },
+        })
       } catch (err) {
         // Expected operational failures (e.g. a 503 when a search backend is not
         // configured) — surface a flash toast, not an alert or an error-level
@@ -272,7 +294,7 @@ export default function QueryIndexesTable() {
       }
       qc.invalidateQueries({ queryKey: ['query-index-status'] })
     },
-    [qc, t],
+    [qc, t, runMutation, retryLastMutation],
   )
 
   const triggerVector = React.useCallback(
@@ -290,14 +312,24 @@ export default function QueryIndexesTable() {
         : t('query_index.table.actions.vectorReindex')
       const errorMessage = t('query_index.table.errors.actionFailed', { action: actionLabel })
       try {
-        await apiCallOrThrow('/api/search/embeddings/reindex', {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({
-            entityId,
-            purgeFirst: action === 'purge',
-          }),
-        }, { errorMessage })
+        await runMutation({
+          operation: () =>
+            apiCallOrThrow('/api/search/embeddings/reindex', {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({
+                entityId,
+                purgeFirst: action === 'purge',
+              }),
+            }, { errorMessage }),
+          context: {
+            formId: MUTATION_CONTEXT_ID,
+            resourceKind: 'query_index.vector',
+            resourceId: entityId,
+            retryLastMutation,
+          },
+          mutationPayload: { action, entityId, purgeFirst: action === 'purge' },
+        })
       } catch (err) {
         const message = err instanceof Error && err.message ? err.message : errorMessage
         console.warn('[query_index] vector action failed', message)
@@ -305,7 +337,7 @@ export default function QueryIndexesTable() {
       }
       qc.invalidateQueries({ queryKey: ['query-index-status'] })
     },
-    [confirm, qc, t],
+    [confirm, qc, t, runMutation, retryLastMutation],
   )
 
   const triggerFulltext = React.useCallback(
@@ -323,14 +355,24 @@ export default function QueryIndexesTable() {
         : t('query_index.table.actions.fulltextReindex')
       const errorMessage = t('query_index.table.errors.actionFailed', { action: actionLabel })
       try {
-        await apiCallOrThrow('/api/search/reindex', {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({
-            action: action === 'purge' ? 'clear' : 'reindex',
-            entityId,
-          }),
-        }, { errorMessage })
+        await runMutation({
+          operation: () =>
+            apiCallOrThrow('/api/search/reindex', {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({
+                action: action === 'purge' ? 'clear' : 'reindex',
+                entityId,
+              }),
+            }, { errorMessage }),
+          context: {
+            formId: MUTATION_CONTEXT_ID,
+            resourceKind: 'query_index.fulltext',
+            resourceId: entityId,
+            retryLastMutation,
+          },
+          mutationPayload: { action, entityId },
+        })
       } catch (err) {
         const message = err instanceof Error && err.message ? err.message : errorMessage
         console.warn('[query_index] fulltext action failed', message)
@@ -338,7 +380,7 @@ export default function QueryIndexesTable() {
       }
       qc.invalidateQueries({ queryKey: ['query-index-status'] })
     },
-    [confirm, qc, t],
+    [confirm, qc, t, runMutation, retryLastMutation],
   )
 
   return (

package/src/modules/shipping_carriers/api/shipments/route.ts

@@ -2,6 +2,10 @@ import { NextResponse } from 'next/server'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import {
+  runCrudMutationGuardAfterSuccess,
+  validateCrudMutationGuard,
+} from '@open-mercato/shared/lib/crud/mutation-guard'
 import type { ShippingCarrierService } from '../../lib/shipping-service'
 import { createShipmentSchema } from '../../data/validators'
 import { shippingCarriersTag } from '../openapi'
@@ -23,12 +27,39 @@ export async function POST(req: Request) {
   }
   const container = await createRequestContainer()
   const service = container.resolve('shippingCarrierService') as ShippingCarrierService
+  const guardResult = await validateCrudMutationGuard(container, {
+    tenantId: auth.tenantId,
+    organizationId: auth.orgId,
+    userId: auth.sub ?? '',
+    resourceKind: 'shipping_carriers.shipment',
+    resourceId: parsed.data.orderId,
+    operation: 'create',
+    requestMethod: req.method,
+    requestHeaders: req.headers,
+    mutationPayload: parsed.data as unknown as Record<string, unknown>,
+  })
+  if (guardResult && !guardResult.ok) {
+    return NextResponse.json(guardResult.body, { status: guardResult.status })
+  }
   try {
     const shipment = await service.createShipment({
       ...parsed.data,
       organizationId: auth.orgId as string,
       tenantId: auth.tenantId,
     })
+    if (guardResult?.shouldRunAfterSuccess) {
+      await runCrudMutationGuardAfterSuccess(container, {
+        tenantId: auth.tenantId,
+        organizationId: auth.orgId,
+        userId: auth.sub ?? '',
+        resourceKind: 'shipping_carriers.shipment',
+        resourceId: shipment.id,
+        operation: 'create',
+        requestMethod: req.method,
+        requestHeaders: req.headers,
+        metadata: guardResult.metadata ?? null,
+      })
+    }
     return NextResponse.json({
       shipmentId: shipment.id,
       carrierShipmentId: shipment.carrierShipmentId,