@open-mercato/core 0.6.7-develop.6842.1.8cd8a8883c → 0.6.7-develop.6851.1.c1680b00d8

package/src/modules/entities/backend/entities/user/[entityId]/records/page.tsx

@@ -4,7 +4,7 @@ import { resolveExtensionPointPattern } from '@open-mercato/shared/modules/widge
 import { extensionPoints } from '@open-mercato/core/modules/entities/extension-points'
 import { useSearchParams } from 'next/navigation'
 import type { ColumnDef, SortingState } from '@tanstack/react-table'
-import { filterCustomFieldDefs, useCustomFieldDefs } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import { filterCustomFieldDefs, useCustomFieldDefs, type CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { DataTable, type DataTableExportFormat } from '@open-mercato/ui/backend/DataTable'
 import type { PreparedExport } from '@open-mercato/shared/lib/crud/exporters'
@@ -23,6 +23,11 @@ import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuarde
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { ErrorMessage, LoadingMessage } from '@open-mercato/ui/backend/detail'
 import { useRecordsEntityGuard } from '@open-mercato/core/modules/entities/components/useRecordsEntityGuard'
+import {
+  RelationCell,
+  RelationDisplaysProvider,
+  useRecordListRelationDisplays,
+} from '@open-mercato/core/modules/entities/components/RecordListRelationCell'
 
 type RecordsResponse = {
   items: any[]
@@ -98,6 +103,13 @@ function RecordsPageInner({ params }: { params: { entityId?: string } }) {
     enabled: Boolean(entityId),
     keyExtras: [scopeVersion],
   })
+  const relationDefinitions = React.useMemo(
+    () => filterCustomFieldDefs(cfDefs, 'list').filter(
+      (definition): definition is CustomFieldDefDto => definition.kind === 'relation',
+    ),
+    [cfDefs],
+  )
+  const relationDisplaysByField = useRecordListRelationDisplays(relationDefinitions, rawData)
 
   // Fields searched server-side: every visible column plus the base `id`.
   const searchableFields = React.useMemo(() => {
@@ -182,7 +194,10 @@ function RecordsPageInner({ params }: { params: { entityId?: string } }) {
       meta: { priority: idx < 4 ? 1 : idx < 6 ? 2 : idx < 8 ? 3 : idx < maxVisible ? 4 : 5 },
       cell: ({ getValue }: { getValue: () => unknown }) => {
         const v = getValue() as any
-        return <span className="truncate max-w-[24ch] inline-block align-top" title={normalizeCell(v)}>{normalizeCell(v)}</span>
+        if (d.kind === 'relation') {
+          return <RelationCell fieldKey={d.key} value={v} fallbackText={normalizeCell(v)} />
+        }
+        return <span className="inline-block max-w-60 truncate align-top" title={normalizeCell(v)}>{normalizeCell(v)}</span>
       },
     }))
     // Ensure hidden 'id' column exists for sorting/state
@@ -378,81 +393,83 @@ export RECORD_ID="<record uuid>"`}</code></pre>
             </div>
           </div>
         </ContextHelp>
-        <DataTable
-          stickyActionsColumn
-          title={`Records: ${entityId}`}
-          entityId={entityId}
-          actions={actions}
-          columns={columns}
-          data={data}
-          perspective={{
-            tableId: resolveExtensionPointPattern(extensionPoints.hosts.userRecordsTable.pattern, { entityId }),
-          }}
-          exporter={exportConfig}
-          filters={baseFilters}
-          filterValues={filterValues}
-          rowActions={(row) => (
-            <RowActions
-              items={[
-                { id: 'edit', label: 'Edit', href: `/backend/entities/user/${encodeURIComponent(entityId)}/records/${encodeURIComponent(String((row as any).id))}` },
-                { id: 'delete', label: 'Delete', destructive: true, onSelect: async () => {
-                  const recordId = String((row as any).id)
-                  try {
-                    const confirmed = await confirm({
-                      title: 'Delete this record?',
-                      variant: 'destructive',
-                    })
-                    if (!confirmed) return
-                    await runDeleteMutation({
-                      operation: async () => {
-                        const deleteCall = await withScopedApiRequestHeaders(
-                          buildOptimisticLockHeader((row as any).updatedAt),
-                          () => apiCall(
-                            `/api/entities/records?entityId=${encodeURIComponent(entityId)}&recordId=${encodeURIComponent(recordId)}`,
-                            { method: 'DELETE' },
-                          ),
-                        )
-                        if (!deleteCall.ok) {
-                          await raiseCrudError(deleteCall.response, 'Failed to delete record')
-                        }
-                      },
-                      context: {
-                        formId: deleteMutationContextId,
-                        resourceKind: 'entities.record',
-                        resourceId: recordId,
-                        retryLastMutation: retryDeleteMutation,
-                      },
-                    })
-                    const j = await readApiResultOrThrow<RecordsResponse>(
-                      `/api/entities/records?entityId=${encodeURIComponent(entityId)}&page=${page}&pageSize=${pageSize}`,
-                      undefined,
-                      {
-                        errorMessage: 'Failed to reload records',
-                        fallback: { items: [], total: 0, page, pageSize, totalPages: 1 },
-                      },
-                    )
-                    setRawData(j.items || [])
-                    setTotal(j.total || 0)
-                    setTotalPages(j.totalPages || 1)
-                    flash('Record has been removed', 'success')
-                  } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Failed to delete record'
-                    flash(message, 'error')
-                  }
-                } },
-              ]}
-            />
-          )}
-          sortable
-          sorting={sorting}
-          onSortingChange={setSorting}
-          searchValue={search}
-          onSearchChange={(v) => { setSearch(v); setPage(1) }}
-          onFiltersApply={(vals) => { setFilterValues(vals); setPage(1) }}
-          onFiltersClear={() => { setFilterValues({}); setPage(1) }}
-          pagination={{ page, pageSize, total, totalPages, onPageChange: setPage }}
-          isLoading={loading}
-        />
+        <RelationDisplaysProvider displaysByField={relationDisplaysByField}>
+          <DataTable
+            stickyActionsColumn
+            title={`Records: ${entityId}`}
+            entityId={entityId}
+            actions={actions}
+            columns={columns}
+            data={data}
+            perspective={{
+              tableId: resolveExtensionPointPattern(extensionPoints.hosts.userRecordsTable.pattern, { entityId }),
+            }}
+            exporter={exportConfig}
+            filters={baseFilters}
+            filterValues={filterValues}
+            rowActions={(row) => (
+              <RowActions
+                items={[
+                  { id: 'edit', label: 'Edit', href: `/backend/entities/user/${encodeURIComponent(entityId)}/records/${encodeURIComponent(String((row as any).id))}` },
+                  { id: 'delete', label: 'Delete', destructive: true, onSelect: async () => {
+                    const recordId = String((row as any).id)
+                    try {
+                      const confirmed = await confirm({
+                        title: 'Delete this record?',
+                        variant: 'destructive',
+                      })
+                      if (!confirmed) return
+                      await runDeleteMutation({
+                        operation: async () => {
+                          const deleteCall = await withScopedApiRequestHeaders(
+                            buildOptimisticLockHeader((row as any).updatedAt),
+                            () => apiCall(
+                              `/api/entities/records?entityId=${encodeURIComponent(entityId)}&recordId=${encodeURIComponent(recordId)}`,
+                              { method: 'DELETE' },
+                            ),
+                          )
+                          if (!deleteCall.ok) {
+                            await raiseCrudError(deleteCall.response, 'Failed to delete record')
+                          }
+                        },
+                        context: {
+                          formId: deleteMutationContextId,
+                          resourceKind: 'entities.record',
+                          resourceId: recordId,
+                          retryLastMutation: retryDeleteMutation,
+                        },
+                      })
+                      const j = await readApiResultOrThrow<RecordsResponse>(
+                        `/api/entities/records?entityId=${encodeURIComponent(entityId)}&page=${page}&pageSize=${pageSize}`,
+                        undefined,
+                        {
+                          errorMessage: 'Failed to reload records',
+                          fallback: { items: [], total: 0, page, pageSize, totalPages: 1 },
+                        },
+                      )
+                      setRawData(j.items || [])
+                      setTotal(j.total || 0)
+                      setTotalPages(j.totalPages || 1)
+                      flash('Record has been removed', 'success')
+                    } catch (error) {
+                      const message = error instanceof Error ? error.message : 'Failed to delete record'
+                      flash(message, 'error')
+                    }
+                  } },
+                ]}
+              />
+            )}
+            sortable
+            sorting={sorting}
+            onSortingChange={setSorting}
+            searchValue={search}
+            onSearchChange={(v) => { setSearch(v); setPage(1) }}
+            onFiltersApply={(vals) => { setFilterValues(vals); setPage(1) }}
+            onFiltersClear={() => { setFilterValues({}); setPage(1) }}
+            pagination={{ page, pageSize, total, totalPages, onPageChange: setPage }}
+            isLoading={loading}
+          />
+        </RelationDisplaysProvider>
       </PageBody>
       {ConfirmDialogElement}
     </Page>

package/src/modules/entities/components/RecordListRelationCell.tsx

@@ -0,0 +1,90 @@
+"use client"
+import * as React from 'react'
+import Link from 'next/link'
+import type { CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import {
+  getRecordListRelationDisplays,
+  resolveRecordListRelationDisplays,
+  type RelationDisplaysByField,
+} from './recordListRelationDisplays'
+
+const RelationDisplaysContext = React.createContext<RelationDisplaysByField>({})
+
+export function RelationDisplaysProvider({
+  displaysByField,
+  children,
+}: {
+  displaysByField: RelationDisplaysByField
+  children: React.ReactNode
+}) {
+  return (
+    <RelationDisplaysContext.Provider value={displaysByField}>
+      {children}
+    </RelationDisplaysContext.Provider>
+  )
+}
+
+export function useRecordListRelationDisplays(
+  definitions: CustomFieldDefDto[],
+  records: Array<Record<string, unknown>>,
+): RelationDisplaysByField {
+  const [displaysByField, setDisplaysByField] = React.useState<RelationDisplaysByField>({})
+
+  React.useEffect(() => {
+    const abortController = new AbortController()
+    setDisplaysByField((current) => (Object.keys(current).length ? {} : current))
+    if (!definitions.length || !records.length) {
+      return () => abortController.abort()
+    }
+
+    void resolveRecordListRelationDisplays(definitions, records, abortController.signal)
+      .then((resolvedDisplays) => {
+        if (!abortController.signal.aborted) setDisplaysByField(resolvedDisplays)
+      })
+      .catch(() => {
+        if (!abortController.signal.aborted) setDisplaysByField({})
+      })
+
+    return () => abortController.abort()
+  }, [definitions, records])
+
+  return displaysByField
+}
+
+export function RelationCell({
+  fieldKey,
+  value,
+  fallbackText,
+}: {
+  fieldKey: string
+  value: unknown
+  fallbackText: string
+}) {
+  const displaysByField = React.useContext(RelationDisplaysContext)
+  const resolvedDisplays = getRecordListRelationDisplays(value, displaysByField[fieldKey])
+  const rawValue = resolvedDisplays.map((display) => display.id).join(', ') || fallbackText
+
+  if (!resolvedDisplays.length) {
+    return <span className="inline-block max-w-60 truncate align-top" title={rawValue}>{rawValue}</span>
+  }
+
+  return (
+    <span className="inline-block max-w-60 truncate align-top" title={rawValue}>
+      {resolvedDisplays.map((display, index) => (
+        <React.Fragment key={`${display.id}-${index}`}>
+          {index > 0 ? ', ' : null}
+          {display.href ? (
+            <Link
+              href={display.href}
+              className="font-medium text-primary underline-offset-2 hover:underline focus-visible:underline"
+              onClick={(event) => event.stopPropagation()}
+              onKeyDown={(event) => event.stopPropagation()}
+            >
+              {display.label}
+            </Link>
+          ) : display.label}
+        </React.Fragment>
+      ))}
+    </span>
+  )
+}

package/src/modules/entities/components/recordListRelationDisplays.ts

@@ -0,0 +1,109 @@
+import type { CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import {
+  buildRelationHref,
+  collectRelationValueIds,
+  fetchRelationRecordDisplays,
+  parseRelationOptionsMetadata,
+  type RelationOptionsMetadata,
+  type ResolvedValueDisplay,
+} from '@open-mercato/ui/backend/utils/customFieldRelationDisplay'
+
+export type RelationDisplaysByField = Record<string, Record<string, ResolvedValueDisplay>>
+
+type RelationLookup = {
+  optionsUrl: string
+  relation: RelationOptionsMetadata
+  recordIds: Set<string>
+  recordIdsByField: Map<string, Set<string>>
+}
+
+export function resolveRelationOptionsUrl(definition: CustomFieldDefDto): string | null {
+  if (definition.kind !== 'relation') return null
+
+  const configuredUrl = definition.optionsUrl?.trim()
+  if (configuredUrl && parseRelationOptionsMetadata(configuredUrl)) return configuredUrl
+
+  const relatedEntityId = definition.relatedEntityId?.trim()
+  if (!relatedEntityId) return null
+  return `/api/entities/relations/options?entityId=${encodeURIComponent(relatedEntityId)}`
+}
+
+function collectRelationLookups(
+  definitions: CustomFieldDefDto[],
+  records: Array<Record<string, unknown>>,
+): RelationLookup[] {
+  const lookups = new Map<string, RelationLookup>()
+
+  definitions.forEach((definition) => {
+    const optionsUrl = resolveRelationOptionsUrl(definition)
+    if (!optionsUrl) return
+    const relation = parseRelationOptionsMetadata(optionsUrl)
+    if (!relation) return
+
+    const recordIds = new Set(
+      records.flatMap((record) => collectRelationValueIds(record[definition.key])),
+    )
+    if (!recordIds.size) return
+
+    const lookupKey = JSON.stringify([relation.entityId, optionsUrl])
+    const lookup = lookups.get(lookupKey) ?? {
+      optionsUrl,
+      relation,
+      recordIds: new Set<string>(),
+      recordIdsByField: new Map<string, Set<string>>(),
+    }
+    recordIds.forEach((recordId) => lookup.recordIds.add(recordId))
+    lookup.recordIdsByField.set(definition.key, recordIds)
+    lookups.set(lookupKey, lookup)
+  })
+
+  return Array.from(lookups.values())
+}
+
+export async function resolveRecordListRelationDisplays(
+  definitions: CustomFieldDefDto[],
+  records: Array<Record<string, unknown>>,
+  signal?: AbortSignal,
+): Promise<RelationDisplaysByField> {
+  const displaysByField: RelationDisplaysByField = {}
+  const lookups = collectRelationLookups(definitions, records)
+
+  await Promise.all(lookups.map(async (lookup) => {
+    let fetchedDisplays: Record<string, ResolvedValueDisplay> = {}
+    try {
+      fetchedDisplays = await fetchRelationRecordDisplays(
+        lookup.optionsUrl,
+        lookup.relation,
+        Array.from(lookup.recordIds),
+        signal,
+      )
+    } catch {
+      fetchedDisplays = {}
+    }
+
+    if (signal?.aborted) return
+    lookup.recordIdsByField.forEach((recordIds, fieldKey) => {
+      const fieldDisplays: Record<string, ResolvedValueDisplay> = {}
+      recordIds.forEach((recordId) => {
+        fieldDisplays[recordId] = fetchedDisplays[recordId] ?? {
+          label: recordId,
+          href: buildRelationHref(lookup.relation.entityId, recordId),
+        }
+      })
+      displaysByField[fieldKey] = fieldDisplays
+    })
+  }))
+
+  return displaysByField
+}
+
+export function getRecordListRelationDisplays(
+  value: unknown,
+  displays: Record<string, ResolvedValueDisplay> | undefined,
+): Array<{ id: string; label: string; href?: string }> {
+  return collectRelationValueIds(value).map((recordId) => ({
+    id: recordId,
+    label: displays?.[recordId]?.label ?? recordId,
+    href: displays?.[recordId]?.href,
+  }))
+}

package/src/modules/inbox_ops/api/proposals/[id]/actions/[actionId]/route.ts

@@ -1,6 +1,8 @@
 import { NextResponse } from 'next/server'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 import { runWithCacheTenant } from '@open-mercato/cache'
+import { enforceCommandOptimisticLockWithGuards } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import {
   runCrudMutationGuardAfterSuccess,
   validateCrudMutationGuard,
@@ -40,6 +42,20 @@ export async function PATCH(req: Request) {
       return NextResponse.json({ error: 'Action already processed' }, { status: 409 })
     }
 
+    // Optimistic lock: refuse a stale overwrite when two tabs edit the same action
+    // payload. Strictly additive — a no-op without the expected-version header.
+    try {
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: 'inbox_ops.action',
+        resourceId: action.id,
+        current: action.updatedAt ?? null,
+        request: req,
+      })
+    } catch (err) {
+      if (isCrudHttpError(err)) return NextResponse.json(err.body, { status: err.status })
+      throw err
+    }
+
     const mergedPayload = { ...action.payload as Record<string, unknown>, ...parsed.data.payload }
     const payloadValidation = validateActionPayloadForType(action.actionType, mergedPayload)
     if (!payloadValidation.success) {
@@ -108,7 +124,7 @@ export const openApi: OpenApiRouteDoc = {
       responses: [
         { status: 200, description: 'Action updated' },
         { status: 404, description: 'Action not found' },
-        { status: 409, description: 'Action already processed' },
+        { status: 409, description: 'Action already processed or stale (optimistic-lock conflict)' },
       ],
     },
   },

package/src/modules/inbox_ops/components/proposals/EditActionDialog.tsx

@@ -9,8 +9,8 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@open-mercato/ui/primitives/select'
-import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
-import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { apiCallOrThrow, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
+import { buildOptimisticLockHeader, extractOptimisticLockConflict } 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'
@@ -461,25 +461,30 @@ export function EditActionDialog({
     }
 
     setIsSaving(true)
-    const result = await runMutation({
-      // TODO(#2373-D): thread updatedAt — ActionDetail type lives outside this file's edit scope
-      operation: () => withScopedApiRequestHeaders(
-        buildOptimisticLockHeader(undefined),
-        () => apiCall<{ ok: boolean; error?: string }>(
-          `/api/inbox_ops/proposals/${action.proposalId}/actions/${action.id}`,
-          { method: 'PATCH', body: JSON.stringify({ payload: finalPayload }) },
+    try {
+      await runMutation({
+        operation: () => withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(action.updatedAt),
+          () => apiCallOrThrow<{ ok: boolean; error?: string }>(
+            `/api/inbox_ops/proposals/${action.proposalId}/actions/${action.id}`,
+            { method: 'PATCH', body: JSON.stringify({ payload: finalPayload }) },
+          ),
         ),
-      ),
-      context: {},
-    })
-    if (result?.ok && result.result?.ok) {
+        context: {},
+      })
       flash(t('inbox_ops.edit_dialog.saved', 'Action updated successfully'), 'success')
       onSaved()
       onClose()
-    } else {
-      flash(result?.result?.error || t('inbox_ops.flash.save_failed', 'Failed to save'), 'error')
+    } catch (error) {
+      if (extractOptimisticLockConflict(error)) {
+        onClose()
+        return
+      }
+      const message = error instanceof Error ? error.message.trim() : ''
+      flash(message || t('inbox_ops.flash.save_failed', 'Failed to save'), 'error')
+    } finally {
+      setIsSaving(false)
     }
-    setIsSaving(false)
   }, [action, payload, jsonMode, jsonText, t, onSaved, onClose, runMutation])
 
   React.useEffect(() => {

package/src/modules/inbox_ops/components/proposals/types.ts

@@ -27,6 +27,7 @@ export type ActionDetail = {
   createdEntityType?: string
   executionError?: string
   executedAt?: string
+  updatedAt?: string
 }
 
 export type DiscrepancyDetail = {

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

@@ -85,6 +85,21 @@ export async function POST(req: Request) {
       },
     },
   ).catch(() => undefined)
+  // Queued once here rather than from a partition: the purge deletes every vector for the
+  // scope, so emitting it from inside the fan-out would race the per-record vectorize jobs
+  // its siblings are already queueing and drop vectors this run had just rebuilt.
+  if (force && partitions.length > 1) {
+    try {
+      await bus.emitEvent(
+        'query_index.vectorize_purge',
+        { entityType, tenantId: auth.tenantId ?? null, organizationId: auth.orgId ?? null },
+        { persistent: true, deliverInline: false },
+      )
+    } catch {
+      // Best effort: a failed purge leaves stale vectors, which the orphan sweep still prunes.
+    }
+  }
+
   try {
     await Promise.all(
       partitions.map((part) => {