@open-mercato/core 0.6.6-develop.6184.1.b7e55f8d61 → 0.6.6-develop.6201.1.8ceb502c4b

package/src/modules/customers/components/detail/InlineEditors.tsx

@@ -3,15 +3,13 @@
 import * as React from 'react'
 import Link from 'next/link'
 import { AtSign, Briefcase, Loader2, Pencil, X } from 'lucide-react'
-import ReactMarkdown from 'react-markdown'
 import { Button } from '@open-mercato/ui/primitives/button'
-import type { PluggableList } from 'unified'
+import { MarkdownContent } from '@open-mercato/ui/backend/markdown'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { cn } from '@open-mercato/shared/lib/utils'
 import { useQueryClient } from '@tanstack/react-query'
 import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
-import remarkGfm from 'remark-gfm'
 import { useEmailDuplicateCheck } from '../../backend/hooks/useEmailDuplicateCheck'
 import { lookupPhoneDuplicate } from '../../utils/phoneDuplicates'
 import {
@@ -172,8 +170,6 @@ export function InlineTextEditor(props: InlineFieldProps) {
 export const InlineMultilineEditor = UiInlineMultilineEditor
 export const InlineSelectEditor = UiInlineSelectEditor
 
-const MARKDOWN_PREVIEW_PLUGINS: PluggableList = [remarkGfm]
-
 function createSocialRenderDisplay(IconComponent: typeof Briefcase): NonNullable<InlineFieldProps['renderDisplay']> {
   // eslint-disable-next-line react/display-name
   return ({ value, emptyLabel }) => {
@@ -206,11 +202,11 @@ export const renderMultilineMarkdownDisplay: InlineMultilineDisplayRenderer = ({
     return <span className="text-muted-foreground">{emptyLabel}</span>
   }
   return (
-    <div className="text-sm text-foreground [&>*]:mb-2 [&>*:last-child]:mb-0 [&_ul]:ml-4 [&_ul]:list-disc [&_ol]:ml-4 [&_ol]:list-decimal [&_code]:rounded [&_code]:bg-muted [&_code]:px-1 [&_code]:py-0.5 [&_pre]:rounded-md [&_pre]:bg-muted [&_pre]:p-3 [&_pre]:text-xs">
-      <ReactMarkdown remarkPlugins={MARKDOWN_PREVIEW_PLUGINS}>
-        {raw}
-      </ReactMarkdown>
-    </div>
+    <MarkdownContent
+      format="markdown"
+      body={raw}
+      className="text-sm text-foreground [&>*]:mb-2 [&>*:last-child]:mb-0 [&_ul]:ml-4 [&_ul]:list-disc [&_ol]:ml-4 [&_ol]:list-decimal [&_code]:rounded [&_code]:bg-muted [&_code]:px-1 [&_code]:py-0.5 [&_pre]:rounded-md [&_pre]:bg-muted [&_pre]:p-3 [&_pre]:text-xs"
+    />
   )
 }
 

package/src/modules/integrations/backend/integrations/[id]/page.tsx

@@ -47,6 +47,10 @@ import {
   resolveIntegrationDetailWidgetSpotId,
   resolveRequestedIntegrationDetailTab,
 } from '../detail-page-widgets'
+import {
+  refreshIntegrationDetailPanels,
+  refreshIntegrationRunActivityPanels,
+} from '../detail-page-refresh'
 import { isValidCredentialUrl } from '../../../lib/credentials-field-validation'
 
 type CredentialField = IntegrationCredentialField
@@ -531,8 +535,7 @@ export default function IntegrationDetailPage({ params }: IntegrationDetailPageP
     spotId: detailWidgetSpotId,
   })
   const refreshDetail = React.useCallback(async () => {
-    await loadDetail({ showLoading: false })
-    await loadCredentials()
+    await refreshIntegrationDetailPanels({ loadDetail, loadCredentials })
   }, [loadCredentials, loadDetail])
   const refreshLogs = React.useCallback(async () => {
     await loadLogs()
@@ -549,13 +552,14 @@ export default function IntegrationDetailPage({ params }: IntegrationDetailPageP
     }
     if (options?.showLoading) setIsRefreshingRunActivity(true)
     try {
-      const call = await apiCall<DataSyncRunDetail>(
-        `/api/data_sync/runs/${encodeURIComponent(runIdFromUrl)}`,
-        undefined,
-        { fallback: null },
-      )
-      await loadLogs()
-      await loadDetail({ showLoading: false })
+      const [call] = await Promise.all([
+        apiCall<DataSyncRunDetail>(
+          `/api/data_sync/runs/${encodeURIComponent(runIdFromUrl)}`,
+          undefined,
+          { fallback: null },
+        ),
+        refreshIntegrationRunActivityPanels({ loadLogs, loadDetail }),
+      ])
       if (call.ok && call.result) {
         setActiveRunDetail(call.result)
         setActiveRunRefreshedAt(new Date().toISOString())

package/src/modules/integrations/backend/integrations/bundle/[id]/page.tsx

@@ -18,6 +18,7 @@ import {
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
 import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import type { CredentialFieldType, IntegrationCredentialField } from '@open-mercato/shared/modules/integrations/types'
@@ -88,6 +89,14 @@ export default function BundleConfigPage({ params }: BundleConfigPageProps) {
   const [isSavingCreds, setIsSavingCreds] = React.useState(false)
   const [togglingIds, setTogglingIds] = React.useState<Set<string>>(new Set())
 
+  const mutationContextId = React.useMemo(
+    () => `integrations.bundle:${bundleId ?? 'unknown'}`,
+    [bundleId],
+  )
+  const { runMutation, retryLastMutation } = useGuardedMutation<Record<string, unknown>>({
+    contextId: mutationContextId,
+  })
+
   const resolveCurrentBundleId = React.useCallback(() => {
     return bundleId ?? (
       typeof window !== 'undefined'
@@ -147,49 +156,83 @@ export default function BundleConfigPage({ params }: BundleConfigPageProps) {
     const currentBundleId = resolveCurrentBundleId()
     if (!currentBundleId) return
     setIsSavingCreds(true)
-    // TODO(#2373-B): thread updatedAt — integration detail/state response does not expose a record version yet
-    const call = await withScopedApiRequestHeaders(
-      buildOptimisticLockHeader(undefined),
-      () => apiCall(`/api/integrations/${encodeURIComponent(currentBundleId)}/credentials`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ credentials: credValues }),
-      }, { fallback: null }),
-    )
-    if (call.ok) {
-      flash(t('integrations.detail.credentials.saved'), 'success')
-    } else {
+    try {
+      const call = await runMutation({
+        mutationPayload: { bundleId: currentBundleId, credentials: credValues },
+        context: {
+          formId: mutationContextId,
+          operation: 'update',
+          actionId: 'save-credentials',
+          resourceKind: 'integrations.bundle',
+          resourceId: currentBundleId,
+          bundleId: currentBundleId,
+          retryLastMutation,
+        },
+        // TODO(#2373-B): thread updatedAt — integration detail/state response does not expose a record version yet
+        operation: () => withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(undefined),
+          () => apiCall(`/api/integrations/${encodeURIComponent(currentBundleId)}/credentials`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ credentials: credValues }),
+          }, { fallback: null }),
+        ),
+      })
+      if (call.ok) {
+        flash(t('integrations.detail.credentials.saved'), 'success')
+      } else {
+        flash(t('integrations.detail.credentials.saveError'), 'error')
+      }
+    } catch {
       flash(t('integrations.detail.credentials.saveError'), 'error')
+    } finally {
+      setIsSavingCreds(false)
     }
-    setIsSavingCreds(false)
-  }, [resolveCurrentBundleId, credValues, t])
+  }, [resolveCurrentBundleId, runMutation, mutationContextId, retryLastMutation, credValues, t])
 
   const handleToggle = React.useCallback(async (integrationId: string, enabled: boolean) => {
     setTogglingIds((prev) => new Set(prev).add(integrationId))
-    // TODO(#2373-B): thread updatedAt — integration detail/state response does not expose a record version yet
-    const call = await withScopedApiRequestHeaders(
-      buildOptimisticLockHeader(undefined),
-      () => apiCall(`/api/integrations/${encodeURIComponent(integrationId)}/state`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ isEnabled: enabled }),
-      }, { fallback: null }),
-    )
-    if (call.ok) {
-      setDetail((prev) => {
-        if (!prev) return prev
-        return {
-          ...prev,
-          bundleIntegrations: prev.bundleIntegrations.map((item) =>
-            item.id === integrationId ? { ...item, isEnabled: enabled } : item,
-          ),
-        }
+    try {
+      const call = await runMutation({
+        mutationPayload: { integrationId, isEnabled: enabled },
+        context: {
+          formId: mutationContextId,
+          operation: 'update',
+          actionId: 'toggle-state',
+          resourceKind: 'integrations.integration',
+          resourceId: integrationId,
+          integrationId,
+          retryLastMutation,
+        },
+        // TODO(#2373-B): thread updatedAt — integration detail/state response does not expose a record version yet
+        operation: () => withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(undefined),
+          () => apiCall(`/api/integrations/${encodeURIComponent(integrationId)}/state`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ isEnabled: enabled }),
+          }, { fallback: null }),
+        ),
       })
-    } else {
+      if (call.ok) {
+        setDetail((prev) => {
+          if (!prev) return prev
+          return {
+            ...prev,
+            bundleIntegrations: prev.bundleIntegrations.map((item) =>
+              item.id === integrationId ? { ...item, isEnabled: enabled } : item,
+            ),
+          }
+        })
+      } else {
+        flash(t('integrations.detail.stateError'), 'error')
+      }
+    } catch {
       flash(t('integrations.detail.stateError'), 'error')
+    } finally {
+      setTogglingIds((prev) => { const next = new Set(prev); next.delete(integrationId); return next })
     }
-    setTogglingIds((prev) => { const next = new Set(prev); next.delete(integrationId); return next })
-  }, [t])
+  }, [runMutation, mutationContextId, retryLastMutation, t])
 
   const handleBulkToggle = React.useCallback(async (enabled: boolean) => {
     if (!detail) return

package/src/modules/integrations/backend/integrations/detail-page-refresh.ts

@@ -0,0 +1,36 @@
+type ShowLoadingOption = { showLoading?: boolean }
+type IntegrationDetailLoader = (options?: ShowLoadingOption) => Promise<void>
+type IntegrationPanelLoader = () => Promise<void>
+
+/**
+ * Refresh the integration detail and credential panels concurrently.
+ *
+ * Detail and credentials are served by independent endpoints with no data
+ * dependency between them, so the two requests start together instead of
+ * waiting for the detail load to resolve before credentials begins.
+ */
+export async function refreshIntegrationDetailPanels(loaders: {
+  loadDetail: IntegrationDetailLoader
+  loadCredentials: IntegrationPanelLoader
+}): Promise<void> {
+  await Promise.all([
+    loaders.loadDetail({ showLoading: false }),
+    loaders.loadCredentials(),
+  ])
+}
+
+/**
+ * Refresh the run-activity panels (logs and detail) concurrently.
+ *
+ * loadLogs and loadDetail hit independent endpoints and neither consumes the
+ * other's result, so the two reloads start together.
+ */
+export async function refreshIntegrationRunActivityPanels(loaders: {
+  loadLogs: IntegrationPanelLoader
+  loadDetail: IntegrationDetailLoader
+}): Promise<void> {
+  await Promise.all([
+    loaders.loadLogs(),
+    loaders.loadDetail({ showLoading: false }),
+  ])
+}

package/src/modules/integrations/backend/integrations/page.tsx

@@ -9,6 +9,7 @@ import { Input } from '@open-mercato/ui/primitives/input'
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
 import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
 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'
@@ -145,6 +146,9 @@ export default function IntegrationsMarketplacePage() {
   const [togglingIds, setTogglingIds] = React.useState<Set<string>>(new Set())
   const scopeVersion = useOrganizationScopeVersion()
   const t = useT()
+  const { runMutation, retryLastMutation } = useGuardedMutation<Record<string, unknown>>({
+    contextId: 'integrations.marketplace',
+  })
 
   React.useEffect(() => {
     const timer = setTimeout(() => setDebouncedSearch(searchInput.trim()), 300)
@@ -202,30 +206,47 @@ export default function IntegrationsMarketplacePage() {
 
   const handleToggle = React.useCallback(async (integrationId: string, enabled: boolean, updatedAt?: string | null) => {
     setTogglingIds((prev) => new Set(prev).add(integrationId))
-    const call = await withScopedApiRequestHeaders(
-      buildOptimisticLockHeader(updatedAt),
-      () => apiCall(`/api/integrations/${encodeURIComponent(integrationId)}/state`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ isEnabled: enabled }),
-      }, { fallback: null }),
-    )
+    try {
+      const call = await runMutation({
+        mutationPayload: { integrationId, isEnabled: enabled },
+        context: {
+          formId: 'integrations.marketplace',
+          operation: 'update',
+          actionId: 'toggle-state',
+          resourceKind: 'integrations.integration',
+          resourceId: integrationId,
+          integrationId,
+          retryLastMutation,
+        },
+        operation: () => withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(updatedAt),
+          () => apiCall(`/api/integrations/${encodeURIComponent(integrationId)}/state`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ isEnabled: enabled }),
+          }, { fallback: null }),
+        ),
+      })
 
-    if (!call.ok) {
+      if (!call.ok) {
+        flash(t('integrations.detail.stateError'), 'error')
+      } else {
+        setData((prev) => {
+          if (!prev) return prev
+          return {
+            ...prev,
+            items: prev.items.map((item) =>
+              item.id === integrationId ? { ...item, isEnabled: enabled } : item,
+            ),
+          }
+        })
+      }
+    } catch {
       flash(t('integrations.detail.stateError'), 'error')
-    } else {
-      setData((prev) => {
-        if (!prev) return prev
-        return {
-          ...prev,
-          items: prev.items.map((item) =>
-            item.id === integrationId ? { ...item, isEnabled: enabled } : item,
-          ),
-        }
-      })
+    } finally {
+      setTogglingIds((prev) => { const next = new Set(prev); next.delete(integrationId); return next })
     }
-    setTogglingIds((prev) => { const next = new Set(prev); next.delete(integrationId); return next })
-  }, [t])
+  }, [retryLastMutation, runMutation, t])
 
   const grouped = React.useMemo(() => {
     if (!data) return { bundles: [] as Array<BundleItem & { integrations: IntegrationItem[] }>, standalone: [] as IntegrationItem[] }

package/src/modules/notifications/api/[id]/action/route.ts

@@ -1,9 +1,11 @@
 import { executeActionSchema } from '../../../data/validators'
 import { actionResultResponseSchema, errorResponseSchema } from '../../openapi'
 import {
+  NOTIFICATION_RESOURCE_KIND,
   notificationCrudErrorResponse,
   notificationValidationErrorResponse,
   resolveNotificationContext,
+  runGuardedNotificationWrite,
 } from '../../../lib/routeHelpers'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 
@@ -13,7 +15,7 @@ export const metadata = {
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const { service, scope } = await resolveNotificationContext(req)
+  const { service, scope, ctx } = await resolveNotificationContext(req)
 
   const body = await req.json().catch(() => ({}))
   const parsed = executeActionSchema.safeParse(body)
@@ -23,7 +25,20 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const input = parsed.data
 
   try {
-    const { notification, result } = await service.executeAction(id, input, scope)
+    const guarded = await runGuardedNotificationWrite(
+      ctx.container,
+      scope,
+      req,
+      {
+        resourceKind: NOTIFICATION_RESOURCE_KIND,
+        resourceId: id,
+        operation: 'custom',
+        payload: input as Record<string, unknown>,
+      },
+      () => service.executeAction(id, input, scope),
+    )
+    if (!guarded.ok) return guarded.response
+    const { notification, result } = guarded.result
 
     const action = notification.actionData?.actions?.find((a) => a.id === input.actionId)
     const href = action?.href?.replace('{sourceEntityId}', notification.sourceEntityId ?? '')

package/src/modules/notifications/api/[id]/restore/route.ts

@@ -1,6 +1,10 @@
 import { z } from 'zod'
 import { restoreNotificationSchema } from '../../../data/validators'
-import { resolveNotificationContext } from '../../../lib/routeHelpers'
+import {
+  NOTIFICATION_RESOURCE_KIND,
+  resolveNotificationContext,
+  runGuardedNotificationWrite,
+} from '../../../lib/routeHelpers'
 
 export const metadata = {
   PUT: { requireAuth: true },
@@ -8,12 +12,24 @@ export const metadata = {
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const { service, scope } = await resolveNotificationContext(req)
+  const { service, scope, ctx } = await resolveNotificationContext(req)
 
   const body = await req.json().catch(() => ({}))
   const input = restoreNotificationSchema.parse(body)
 
-  await service.restoreDismissed(id, input.status, scope)
+  const guarded = await runGuardedNotificationWrite(
+    ctx.container,
+    scope,
+    req,
+    {
+      resourceKind: NOTIFICATION_RESOURCE_KIND,
+      resourceId: id,
+      operation: 'update',
+      payload: input as Record<string, unknown>,
+    },
+    () => service.restoreDismissed(id, input.status, scope),
+  )
+  if (!guarded.ok) return guarded.response
 
   return Response.json({ ok: true })
 }

package/src/modules/notifications/api/mark-all-read/route.ts

@@ -1,16 +1,30 @@
 import { z } from 'zod'
-import { resolveNotificationContext } from '../../lib/routeHelpers'
+import {
+  NOTIFICATION_RESOURCE_KIND,
+  resolveNotificationContext,
+  runGuardedNotificationWrite,
+} from '../../lib/routeHelpers'
 
 export const metadata = {
   PUT: { requireAuth: true },
 }
 
 export async function PUT(req: Request) {
-  const { service, scope } = await resolveNotificationContext(req)
+  const { service, scope, ctx } = await resolveNotificationContext(req)
 
-  const count = await service.markAllAsRead(scope)
+  const guarded = await runGuardedNotificationWrite(
+    ctx.container,
+    scope,
+    req,
+    {
+      resourceKind: NOTIFICATION_RESOURCE_KIND,
+      operation: 'update',
+    },
+    () => service.markAllAsRead(scope),
+  )
+  if (!guarded.ok) return guarded.response
 
-  return Response.json({ ok: true, count })
+  return Response.json({ ok: true, count: guarded.result })
 }
 
 export const openApi = {

package/src/modules/notifications/api/route.ts

@@ -4,9 +4,11 @@ import { Notification } from '../data/entities'
 import { listNotificationsSchema, createNotificationSchema } from '../data/validators'
 import { toNotificationDto } from '../lib/notificationMapper'
 import {
+  NOTIFICATION_RESOURCE_KIND,
   notificationCrudErrorResponse,
   notificationValidationErrorResponse,
   resolveNotificationContext,
+  runGuardedNotificationWrite,
 } from '../lib/routeHelpers'
 import {
   buildNotificationsCrudOpenApi,
@@ -74,7 +76,7 @@ export async function GET(req: Request) {
 }
 
 export async function POST(req: Request) {
-  const { service, scope } = await resolveNotificationContext(req)
+  const { service, scope, ctx } = await resolveNotificationContext(req)
 
   const body = await req.json().catch(() => ({}))
   const parsed = createNotificationSchema.safeParse(body)
@@ -83,9 +85,20 @@ export async function POST(req: Request) {
   }
 
   try {
-    const notification = await service.create(parsed.data, scope)
+    const guarded = await runGuardedNotificationWrite(
+      ctx.container,
+      scope,
+      req,
+      {
+        resourceKind: NOTIFICATION_RESOURCE_KIND,
+        operation: 'create',
+        payload: parsed.data as Record<string, unknown>,
+      },
+      () => service.create(parsed.data, scope),
+    )
+    if (!guarded.ok) return guarded.response
 
-    return Response.json({ id: notification.id }, { status: 201 })
+    return Response.json({ id: guarded.result.id }, { status: 201 })
   } catch (error) {
     const errorResponse = notificationCrudErrorResponse(error)
     if (errorResponse) return errorResponse

package/src/modules/notifications/api/settings/route.ts

@@ -13,6 +13,10 @@ import {
   resolveNotificationDeliveryConfig,
   saveNotificationDeliveryConfig,
 } from '../../lib/deliveryConfig'
+import {
+  NOTIFICATION_SETTINGS_RESOURCE_KIND,
+  runGuardedNotificationWrite,
+} from '../../lib/routeHelpers'
 
 export const metadata = {
   GET: { requireAuth: true, requireFeatures: ['notifications.manage'] },
@@ -67,11 +71,28 @@ export async function POST(req: Request) {
 
   const container = await createRequestContainer()
   try {
-    await saveNotificationDeliveryConfig(container, parsed.data)
-    const settings = await resolveNotificationDeliveryConfig(container, {
-      defaultValue: DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
-    })
-    return NextResponse.json({ ok: true, settings })
+    const guarded = await runGuardedNotificationWrite(
+      container,
+      {
+        tenantId: auth.tenantId ?? '',
+        organizationId: auth.orgId ?? null,
+        userId: auth.sub ?? null,
+      },
+      req,
+      {
+        resourceKind: NOTIFICATION_SETTINGS_RESOURCE_KIND,
+        operation: 'update',
+        payload: parsed.data as Record<string, unknown>,
+      },
+      async () => {
+        await saveNotificationDeliveryConfig(container, parsed.data)
+        return resolveNotificationDeliveryConfig(container, {
+          defaultValue: DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
+        })
+      },
+    )
+    if (!guarded.ok) return guarded.response
+    return NextResponse.json({ ok: true, settings: guarded.result })
   } catch (error) {
     return NextResponse.json(
       { error: error instanceof Error ? error.message : t('api.errors.internal', 'Internal error') },