@open-mercato/core 0.10.1-develop.7883.1.44ac2125f5 → 0.10.1-develop.7894.1.2c464c73e3

package/src/modules/audit_logs/services/actionLogService.ts

@@ -1,6 +1,7 @@
 import { raw, type FilterQuery } from '@mikro-orm/core'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { sql } from 'kysely'
+import { z } from 'zod'
 import { ActionLog } from '@open-mercato/core/modules/audit_logs/data/entities'
 import {
   actionLogCreateSchema,
@@ -30,6 +31,15 @@ import {
 
 const logger = createLogger('audit_logs').child({ component: 'action-log-service' })
 
+const DEFAULT_LIST_PAGE_SIZE = 50
+
+const actionLogListQuerySchema = actionLogListSchema.extend({
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().max(200).optional(),
+})
+
+type ParsedActionLogListQuery = z.infer<typeof actionLogListQuerySchema>
+
 let validationWarningLogged = false
 let runtimeValidationAvailable: boolean | null = null
 let decryptionWarningLogged = false
@@ -409,26 +419,26 @@ export class ActionLogService {
   }
 
   private parseListQuery(query: Partial<ActionLogListQuery>) {
-    return actionLogListSchema.parse({
+    return actionLogListQuerySchema.parse({
       ...query,
     })
   }
 
-  private resolveActorUserIds(parsed: ActionLogListQuery): string[] {
+  private resolveActorUserIds(parsed: ParsedActionLogListQuery): string[] {
     const values = [...(parsed.actorUserIds ?? [])]
     if (parsed.actorUserId) values.push(parsed.actorUserId)
 
     return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)))
   }
 
-  private resolveFieldNames(parsed: ActionLogListQuery): string[] {
+  private resolveFieldNames(parsed: ParsedActionLogListQuery): string[] {
     const values = [...(parsed.fieldNames ?? [])]
     if (parsed.fieldName) values.push(parsed.fieldName)
 
     return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)))
   }
 
-  private resolveActionTypes(parsed: ActionLogListQuery): ActionLogFilterType[] {
+  private resolveActionTypes(parsed: ParsedActionLogListQuery): ActionLogFilterType[] {
     const values = [...(parsed.actionTypes ?? [])]
     if (parsed.actionType) values.push(parsed.actionType)
 
@@ -436,22 +446,14 @@ export class ActionLogService {
       .filter((value): value is ActionLogFilterType => ACTION_LOG_FILTER_TYPES.includes(value as ActionLogFilterType))
   }
 
-  private resolvePagination(parsed: ActionLogListQuery): { page: number; pageSize: number; offset: number; limit: number } {
-    const pageSize =
-      typeof parsed.pageSize === 'number' && parsed.pageSize > 0
-        ? parsed.pageSize
-        : typeof parsed.limit === 'number' && parsed.limit > 0
-          ? parsed.limit
-          : 50
-    const page = typeof parsed.page === 'number' && parsed.page > 0 ? parsed.page : 1
-    const offset =
-      typeof parsed.offset === 'number' && parsed.offset >= 0
-        ? parsed.offset
-        : (page - 1) * pageSize
+  private resolvePagination(parsed: ParsedActionLogListQuery): { page: number; pageSize: number; offset: number; limit: number } {
+    const pageSize = parsed.pageSize ?? parsed.limit ?? DEFAULT_LIST_PAGE_SIZE
+    const page = parsed.page ?? 1
+    const offset = parsed.offset ?? (page - 1) * pageSize
     return { page, pageSize, offset, limit: pageSize }
   }
 
-  private async loadEntries(parsed: ActionLogListQuery, options?: { paginate?: boolean }) {
+  private async loadEntries(parsed: ParsedActionLogListQuery, options?: { paginate?: boolean }) {
     let query = (this.buildListQuery(parsed) as any).select('action_logs.id as id')
 
     if (options?.paginate !== false) {
@@ -480,7 +482,7 @@ export class ActionLogService {
     ))
   }
 
-  private buildListQuery(parsed: ActionLogListQuery): any {
+  private buildListQuery(parsed: ParsedActionLogListQuery): any {
     let query = (this.em.getKysely<any>() as any)
       .selectFrom('action_logs')
       .selectAll()

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

@@ -167,13 +167,14 @@ export function CompanyKpiBar({ data }: CompanyKpiBarProps) {
     <div className="space-y-2">
       <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 xl:grid-cols-4">
         {visibleTiles.map((tile) => (
-          <div key={tile.id} className="group relative">
+          <div key={tile.id} data-testid="company-kpi-tile" className="group relative flex">
             <KpiCard
               title={tile.title}
               value={tile.value}
               trend={tile.trend}
               formatValue={tile.formatValue}
               comparisonLabel={tile.comparisonLabel}
+              className="w-full"
             />
             <IconButton
               type="button"

package/src/modules/query_index/lib/coverage.ts

@@ -191,7 +191,8 @@ async function updateCoverageRows(
 // overlapping adjustments compose, and drops the `SELECT` (and the window between it and the
 // write) that made the coverage row a contention point in the first place.
 //
-// In steady state that is one statement. The extra statements are recovery paths that do not
+// For non-null tenants, steady state is one statement. NULL-tenant writers first take
+// the scope advisory lock because the unique constraint cannot coordinate their rows. The extra statements are recovery paths that do not
 // fire once a scope has settled: the legacy NULL-organization fold below runs only for
 // global-organization scopes, the insert only until the scope's row exists, and the duplicate
 // prune only when the scope somehow holds more than one row.
@@ -209,6 +210,7 @@ async function incrementCoverageRow(
   scope: CoverageScope,
   deltas: { deltaBase: number; deltaIndex: number; deltaVector: number }
 ): Promise<void> {
+  if (scope.tenantId == null) await lockCoverageInitialization(db, scope)
   const storedOrgId = normalizeOrganizationForStore(scope.organizationId ?? null)
   let deltaBase = deltas.deltaBase
   let deltaIndex = deltas.deltaIndex
@@ -237,15 +239,7 @@ async function incrementCoverageRow(
     }
   }
 
-  let updated = await updateCoverageRows(db, scope, { deltaBase, deltaIndex, deltaVector })
-
-  if (updated.length === 0 && scope.tenantId == null) {
-    // The unique constraint cannot serialize a first insert whose tenant is NULL. Take a
-    // transaction-scoped lock only on this rowless branch, then repeat the UPDATE: a creator
-    // that won while we waited has committed its row, so this adjustment composes into it.
-    await lockCoverageInitialization(db, scope)
-    updated = await updateCoverageRows(db, scope, { deltaBase, deltaIndex, deltaVector })
-  }
+  const updated = await updateCoverageRows(db, scope, { deltaBase, deltaIndex, deltaVector })
 
   if (updated.length > 0) {
     // In steady state the scope holds exactly the row just incremented, so the adjustment is
@@ -257,7 +251,7 @@ async function incrementCoverageRow(
   }
 
   // No row for this scope yet. `ON CONFLICT` closes the insert race for scopes the unique
-  // constraint can see. NULL-tenant initialization reaches here only while holding the scoped
+  // constraint can see. NULL-tenant writes reach here only while holding the scoped
   // transaction advisory lock above, so it has the same single-creator guarantee.
   const rows = await db
     .insertInto('entity_index_coverage' as any)
@@ -304,6 +298,27 @@ async function upsertCoverageRow(
     await purge.execute()
   }
 
+  if (scope.tenantId == null) {
+    const updated = await db
+      .updateTable('entity_index_coverage')
+      .set({
+        base_count: counts.baseCount,
+        indexed_count: counts.indexedCount,
+        vector_indexed_count: counts.vectorIndexedCount,
+        refreshed_at: sql`now()`,
+      })
+      .where('entity_type', '=', scope.entityType)
+      .where('tenant_id', 'is', null)
+      .where('organization_id', '=', storedOrgId)
+      .where('with_deleted', '=', scope.withDeleted === true)
+      .returning('id')
+      .execute() as Array<{ id: string }>
+    if (updated.length > 0) {
+      if (updated.length > 1) await pruneDuplicateCoverageRows(db, scope, updated[0]!.id)
+      return
+    }
+  }
+
   const rows = await db
     .insertInto('entity_index_coverage' as any)
     .values({
@@ -674,26 +689,34 @@ export async function writeCoverageCounts(
   const tenantId = scope.tenantId ?? null
   const organizationId = scope.organizationId ?? null
   const withDeleted = scope.withDeleted === true
-  const existing = await fetchCoverageRow(db, {
-    entityType,
-    tenantId,
-    organizationId,
-    withDeleted,
-  })
-  const baseCount = counts.baseCount !== undefined
-    ? Math.max(0, Math.trunc(toCount(counts.baseCount)))
-    : Math.max(0, Math.trunc(toCount(existing?.base_count)))
-  const indexCount = counts.indexedCount !== undefined
-    ? Math.max(0, Math.trunc(toCount(counts.indexedCount)))
-    : Math.max(0, Math.trunc(toCount(existing?.indexed_count)))
-  const vectorCount = counts.vectorCount !== undefined
-    ? Math.max(0, Math.trunc(toCount(counts.vectorCount)))
-    : Math.max(0, Math.trunc(toCount(existing?.vector_indexed_count)))
-  await upsertCoverageRow(db, { entityType, tenantId, organizationId, withDeleted }, {
-    baseCount,
-    indexedCount: indexCount,
-    vectorIndexedCount: vectorCount,
-  })
+  const write = async (executor: CoverageExecutor): Promise<void> => {
+    if (tenantId == null) await lockCoverageInitialization(executor, scope)
+    const existing = await fetchCoverageRow(executor, {
+      entityType,
+      tenantId,
+      organizationId,
+      withDeleted,
+    })
+    const baseCount = counts.baseCount !== undefined
+      ? Math.max(0, Math.trunc(toCount(counts.baseCount)))
+      : Math.max(0, Math.trunc(toCount(existing?.base_count)))
+    const indexCount = counts.indexedCount !== undefined
+      ? Math.max(0, Math.trunc(toCount(counts.indexedCount)))
+      : Math.max(0, Math.trunc(toCount(existing?.indexed_count)))
+    const vectorCount = counts.vectorCount !== undefined
+      ? Math.max(0, Math.trunc(toCount(counts.vectorCount)))
+      : Math.max(0, Math.trunc(toCount(existing?.vector_indexed_count)))
+    await upsertCoverageRow(executor, { entityType, tenantId, organizationId, withDeleted }, {
+      baseCount,
+      indexedCount: indexCount,
+      vectorIndexedCount: vectorCount,
+    })
+  }
+  if (tenantId == null && !db.isTransaction) {
+    await db.transaction().execute(write)
+  } else {
+    await write(db)
+  }
 }
 
 type AggregatedAdjustment = {

package/src/modules/warranty_claims/backend/components/ReceivingPanel.tsx

@@ -56,9 +56,9 @@ function readErrorKey(value: unknown): string | null {
   return typeof value.error === 'string' && value.error.trim().length ? value.error.trim() : null
 }
 
-function toApiError(status: number, result: unknown, fallbackKey: string, t: TranslateFn): Error & { status?: number } {
+function toApiError(status: number, result: unknown, fallbackKey: string, t: TranslateFn): Error & { status: number; body: unknown } {
   const key = readErrorKey(result) ?? fallbackKey
-  return Object.assign(new Error(t(key, key)), { status })
+  return Object.assign(new Error(t(key, key)), { status, body: result })
 }
 
 function formatLineTitle(line: ReceivingLine, t: TranslateFn): string {
@@ -142,7 +142,10 @@ export function ReceivingPanel({
       setDialogLine(null)
       await onRefresh()
     } catch (err) {
-      if (surfaceRecordConflict(err, t, { onRefresh })) return
+      if (surfaceRecordConflict(err, t, { onRefresh })) {
+        setDialogLine(null)
+        return
+      }
       const message = err instanceof Error && err.message
         ? err.message
         : t('warranty_claims.receiving.error.save', 'Failed to save receiving details.')

package/src/modules/warranty_claims/backend/components/ReturnLabelPanel.tsx

@@ -55,9 +55,9 @@ function readErrorKey(value: unknown): string | null {
   return typeof value.error === 'string' && value.error.trim().length ? value.error.trim() : null
 }
 
-function toApiError(status: number, result: unknown, fallbackKey: string, t: TranslateFn): Error & { status?: number } {
+function toApiError(status: number, result: unknown, fallbackKey: string, t: TranslateFn): Error & { status: number; body: unknown } {
   const key = readErrorKey(result) ?? fallbackKey
-  return Object.assign(new Error(t(key, key)), { status })
+  return Object.assign(new Error(t(key, key)), { status, body: result })
 }
 
 function isReturnLabelStatus(value: unknown): value is ReturnLabelResponse {

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

@@ -9,6 +9,7 @@ import { hasFeature } from '@open-mercato/shared/security/features'
 import { parseBooleanFromUnknown } from '@open-mercato/shared/lib/boolean'
 import type { TranslateFn, TranslateParams } from '@open-mercato/shared/lib/i18n/context'
 import { useLocale, useT } from '@open-mercato/shared/lib/i18n/context'
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
 import { formatDateTime, formatRelativeTime } from '@open-mercato/shared/lib/time'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { DataTable } from '@open-mercato/ui/backend/DataTable'
@@ -67,6 +68,7 @@ import {
 import { AiAssessButtons } from '../../components/AiAssessButtons'
 import { useUserDisplayNames } from '../../components/useUserDisplayNames'
 import { ReceivingPanel } from '../../components/ReceivingPanel'
+import { loadClaimLines } from '../../../lib/claimLines'
 import { ReturnLabelPanel } from '../../components/ReturnLabelPanel'
 import { VendorRecoverySuggestionsPanel } from '../../components/VendorRecoverySuggestionsPanel'
 import { ClaimStageProgress } from '../../components/ClaimStageProgress'
@@ -929,11 +931,7 @@ export default function WarrantyClaimDetailPage({ params }: { params?: { id?: st
           undefined,
           { fallback: { items: [] }, errorMessage: t('warranty_claims.detail.error.load') },
         ),
-        readApiResultOrThrow<{ items?: unknown[] }>(
-          `/api/warranty_claims/lines?claimId=${encodeURIComponent(id)}&page=1&pageSize=100`,
-          undefined,
-          { fallback: { items: [] }, errorMessage: t('warranty_claims.detail.error.loadLines') },
-        ),
+        loadClaimLines(id, t('warranty_claims.detail.error.loadLines')),
         readApiResultOrThrow<{ items?: unknown[] }>(
           `/api/warranty_claims/events?claimId=${encodeURIComponent(id)}`,
           undefined,
@@ -1427,6 +1425,39 @@ export default function WarrantyClaimDetailPage({ params }: { params?: { id?: st
     }
   }, [claim, confirm, currentStatus, featureAccess.claimDelete, loadData, mutationContext, router, runMutation, t])
 
+  const deleteLine = React.useCallback(async (line: ClaimLine) => {
+    if (!claim || !linesInlineEditable) return
+    const confirmed = await confirm({
+      title: t('warranty_claims.form.lines.remove'),
+      variant: 'destructive',
+    })
+    if (!confirmed) return
+    const payload = { id: line.id, claimId: claim.id }
+    try {
+      await runMutation({
+        operation: () => withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(line.updatedAt),
+          () => deleteCrud('warranty_claims/lines', {
+            body: payload,
+            errorMessage: t('warranty_claims.detail.lines.error.delete'),
+          }),
+        ),
+        context: { ...mutationContext, resourceKind: 'warranty_claims.claim_line', resourceId: line.id },
+        mutationPayload: payload,
+      })
+      flash(t('warranty_claims.detail.lines.flash.deleted'), 'success')
+      await loadData()
+    } catch (err) {
+      if (surfaceRecordConflict(err, t, { onRefresh: loadData })) return
+      getTelemetryRuntime()?.reportError(err, {
+        module: 'warranty_claims',
+        code: 'warranty_claims.line_delete_failed',
+        attributes: { claimId: claim.id, lineId: line.id },
+      })
+      flash(translateErrorMessage(err, t, 'warranty_claims.detail.lines.error.delete'), 'error')
+    }
+  }, [claim, confirm, linesInlineEditable, loadData, mutationContext, runMutation, t])
+
   const headerMoreActions = React.useMemo(() => {
     if (!claim) return []
     const items = [
@@ -2090,6 +2121,12 @@ export default function WarrantyClaimDetailPage({ params }: { params?: { id?: st
                             label: t('warranty_claims.detail.lines.edit'),
                             onSelect: () => setLineDialog({ mode: 'edit', line }),
                           },
+                          {
+                            id: 'delete',
+                            label: t('warranty_claims.form.lines.remove'),
+                            destructive: true,
+                            onSelect: () => { void deleteLine(line) },
+                          },
                         ]}
                       />
                     ) : undefined}
@@ -2533,17 +2570,6 @@ export default function WarrantyClaimDetailPage({ params }: { params?: { id?: st
               setLineDialog(null)
               await loadData()
             }}
-            onDelete={lineDialog?.mode === 'edit'
-              ? async () => {
-                await deleteCrud('warranty_claims/lines', {
-                  body: { id: lineDialog.line.id, claimId: claim.id },
-                  errorMessage: t('warranty_claims.detail.lines.error.delete'),
-                })
-                flash(t('warranty_claims.detail.lines.flash.deleted'), 'success')
-                setLineDialog(null)
-                await loadData()
-              }
-              : undefined}
           />
         </DialogContent>
       </Dialog>

package/src/modules/warranty_claims/frontend/[orgSlug]/portal/claims/[id]/page.tsx

@@ -5,6 +5,7 @@ import Link from 'next/link'
 import { ArrowLeft, Check, CircleAlert, Info, Paperclip, RefreshCw, ShieldCheck, Trash2, TriangleAlert } from 'lucide-react'
 import { replaceWithPageReload } from '@open-mercato/core/modules/portal/lib/navigation'
 import { useLocale, useT, type TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
 import { localizeDictionaryLabel } from '@open-mercato/core/modules/warranty_claims/lib/dictionaryLabels'
 import { formatQuantity } from '@open-mercato/core/modules/warranty_claims/lib/quantity'
 import {
@@ -30,6 +31,7 @@ import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/u
 import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
 import { usePortalContext } from '@open-mercato/ui/portal/PortalContext'
 import { PortalEmptyState } from '@open-mercato/ui/portal/components/PortalEmptyState'
+import { usePortalAppEvent } from '@open-mercato/ui/portal/hooks/usePortalAppEvent'
 
 type Props = { params: { orgSlug: string; id: string } }
 
@@ -357,6 +359,8 @@ export default function WarrantyClaimPortalDetailPage({ params }: Props) {
   const [actionSubmitting, setActionSubmitting] = React.useState(false)
   const replacementInputRef = React.useRef<HTMLInputElement | null>(null)
   const replacementTargetRef = React.useRef<PortalAttachment | null>(null)
+  const claimRequestSequenceRef = React.useRef(0)
+  const eventsRequestSequenceRef = React.useRef(0)
 
   // Leaving an authenticated page for the login page crosses the public/authenticated
   // boundary, so it must be a full page load — see `replaceWithPageReload`.
@@ -367,8 +371,11 @@ export default function WarrantyClaimPortalDetailPage({ params }: Props) {
   }, [loading, user, params.orgSlug])
 
   const refreshEvents = React.useCallback(async (claimId: string) => {
+    const requestSequence = ++eventsRequestSequenceRef.current
     const result = await apiCall<EventResponse>(`/api/warranty_claims/portal/events?claimId=${encodeURIComponent(claimId)}`)
-    if (result.ok && result.result) setEvents(result.result.items)
+    if (requestSequence === eventsRequestSequenceRef.current && result.ok && result.result) {
+      setEvents(result.result.items)
+    }
   }, [])
 
   const refreshAttachments = React.useCallback(async (claimId: string) => {
@@ -376,12 +383,14 @@ export default function WarrantyClaimPortalDetailPage({ params }: Props) {
     if (result.ok && result.result) setAttachments(result.result.items)
   }, [])
 
-  const loadClaim = React.useCallback(async () => {
-    setIsLoading(true)
+  const loadClaim = React.useCallback(async (showLoading = true) => {
+    const requestSequence = ++claimRequestSequenceRef.current
+    if (showLoading) setIsLoading(true)
     setError(null)
     setNotFound(false)
     try {
       const detail = await apiCall<ClaimResponse>(`/api/warranty_claims/portal/claims/${encodeURIComponent(params.id)}`)
+      if (requestSequence !== claimRequestSequenceRef.current) return
       if (detail.status === 404) {
         setClaim(null)
         setNotFound(true)
@@ -397,9 +406,11 @@ export default function WarrantyClaimPortalDetailPage({ params }: Props) {
         refreshAttachments(detail.result.item.id),
       ])
     } catch {
-      setError(t('warranty_claims.portal.detail.loadError'))
+      if (requestSequence === claimRequestSequenceRef.current) {
+        setError(t('warranty_claims.portal.detail.loadError'))
+      }
     } finally {
-      setIsLoading(false)
+      if (requestSequence === claimRequestSequenceRef.current) setIsLoading(false)
     }
   }, [params.id, refreshAttachments, refreshEvents, t])
 
@@ -407,6 +418,23 @@ export default function WarrantyClaimPortalDetailPage({ params }: Props) {
     if (user) void loadClaim()
   }, [loadClaim, user])
 
+  usePortalAppEvent('warranty_claims.claim.portal_status_changed', (event) => {
+    if (!user || event.payload.claimId !== params.id) return
+    void loadClaim(false)
+  })
+
+  usePortalAppEvent('warranty_claims.claim.comment_added', (event) => {
+    if (!user || event.payload.claimId !== params.id) return
+    void refreshEvents(params.id).catch((error) => {
+      getTelemetryRuntime()?.reportError(error, {
+        module: 'warranty_claims',
+        code: 'warranty_claims.portal_timeline_refresh_failed',
+        attributes: { claimId: params.id },
+      })
+      setError(t('warranty_claims.portal.detail.loadError'))
+    })
+  })
+
   React.useEffect(() => {
     if (!user) return
     let cancelled = false

package/src/modules/warranty_claims/lib/claimLines.ts

@@ -0,0 +1,22 @@
+import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+
+type ClaimLinesPage = {
+  items?: unknown[]
+  totalPages?: number
+}
+
+export async function loadClaimLines(claimId: string, errorMessage: string): Promise<{ items: unknown[] }> {
+  const readPage = (page: number) => readApiResultOrThrow<ClaimLinesPage>(
+    `/api/warranty_claims/lines?claimId=${encodeURIComponent(claimId)}&page=${page}&pageSize=100&sortField=lineNo&sortDir=asc`,
+    undefined,
+    { fallback: { items: [] }, errorMessage },
+  )
+  const firstPage = await readPage(1)
+  const items = [...(firstPage.items ?? [])]
+  const totalPages = firstPage.totalPages ?? 1
+  for (let page = 2; page <= totalPages; page += 1) {
+    const payload = await readPage(page)
+    items.push(...(payload.items ?? []))
+  }
+  return { items }
+}