@open-mercato/core 0.6.5-develop.4670.1.afe50dfd5c → 0.6.5-develop.4691.1.bb409545b3

package/src/modules/query_index/subscribers/delete_one.ts

@@ -8,7 +8,11 @@ import { loadQueryIndexRowScope, resolveQueryIndexRecordScope } from '../lib/sub
 export const metadata = { event: 'query_index.delete_one', persistent: false }
 
 export default async function handle(payload: any, ctx: { resolve: <T=any>(name: string) => T }) {
-  const em = ctx.resolve<any>('em')
+  // Forked EntityManager — this awaited subscriber runs synchronously on the request
+  // `em`; isolating it prevents our queries/writes from resetting the originating CRUD
+  // write's UnitOfWork and dropping its pending changes. See upsert_one.ts for detail.
+  const baseEm = ctx.resolve<any>('em')
+  const em = typeof baseEm?.fork === 'function' ? baseEm.fork() : baseEm
   const entityType = String(payload?.entityType || '')
   const recordId = String(payload?.recordId || '')
   if (!entityType || !recordId) return
@@ -73,24 +77,40 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
       }
     }
 
+    // The projection row + token removal above are synchronous (the data engine
+    // awaits this subscriber) so list reads are consistent immediately. The coverage
+    // recompute (a COUNT, run inline when delayMs is 0) and the fulltext delete are
+    // secondary, so defer them fire-and-forget to keep write/bulk-delete latency bounded.
     const shouldRefreshCoverage = coverageDelayMs === undefined || coverageDelayMs >= 0
-    if (shouldRefreshCoverage) {
-      const delay = coverageDelayMs ?? 0
+    const coverageRefreshDelay = coverageDelayMs ?? 0
+    void (async () => {
       try {
         const bus = ctx.resolve<any>('eventBus')
-        await bus.emitEvent('query_index.coverage.refresh', {
-          entityType,
-          tenantId: tenantId ?? null,
-          organizationId: organizationId ?? null,
-          delayMs: delay,
-        })
-      } catch {}
-    }
-    // Emit search delete event
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('search.delete_record', { entityId: entityType, recordId, organizationId, tenantId })
-    } catch {}
+        if (shouldRefreshCoverage) {
+          await bus.emitEvent('query_index.coverage.refresh', {
+            entityType,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            delayMs: coverageRefreshDelay,
+          })
+        }
+        await bus.emitEvent('search.delete_record', { entityId: entityType, recordId, organizationId, tenantId })
+      } catch (error) {
+        await recordIndexerError(
+          { em },
+          {
+            source: 'query_index',
+            handler: 'event:query_index.delete_one:coverage_search',
+            error,
+            entityType,
+            recordId,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            payload,
+          },
+        ).catch(() => {})
+      }
+    })()
   } catch (error) {
     await recordIndexerError(
       { em },

package/src/modules/query_index/subscribers/upsert_one.ts

@@ -1,12 +1,20 @@
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
-import { upsertIndexRow } from '../lib/indexer'
+import { upsertIndexRow, reindexSearchTokensForRecord } from '../lib/indexer'
 import { applyCoverageAdjustments, createCoverageAdjustments } from '../lib/coverage'
 import { loadQueryIndexRowScope, resolveQueryIndexRecordScope } from '../lib/subscriber-scope'
 
 export const metadata = { event: 'query_index.upsert_one', persistent: false }
 
 export default async function handle(payload: any, ctx: { resolve: <T=any>(name: string) => T }) {
-  const em = ctx.resolve<any>('em')
+  // Run index maintenance on a FORKED EntityManager (fresh identity map + UnitOfWork)
+  // so it can never disturb the originating CRUD write's `em`. The data engine awaits
+  // this emit for read-your-writes consistency, which means the subscriber runs
+  // synchronously on the request `em`; sharing it would let our `em.find` / raw
+  // `getKysely()` queries reset the caller's UoW change-tracking and silently drop the
+  // caller's pending write (e.g. the deal's `setCustomFields` insert). The fork reads
+  // the same committed DB rows via the shared connection but keeps its own UoW.
+  const baseEm = ctx.resolve<any>('em')
+  const em = typeof baseEm?.fork === 'function' ? baseEm.fork() : baseEm
   const entityType = String(payload?.entityType || '')
   const recordId = String(payload?.recordId || '')
   if (!entityType || !recordId) return
@@ -28,14 +36,18 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
     organizationId = resolvedScope.organizationId
     tenantId = resolvedScope.tenantId
 
+    const searchTokenDoc = typeof payload?.searchTokenDoc === 'object' && payload.searchTokenDoc && !Array.isArray(payload.searchTokenDoc)
+      ? (payload.searchTokenDoc as Record<string, unknown>)
+      : null
+    // Update the projection row synchronously so list reads (`customValues`) are
+    // consistent the moment the write returns; defer the heavy search-token rebuild.
     const result = await upsertIndexRow(em, {
       entityType,
       recordId,
       organizationId,
       tenantId,
-      searchTokenDoc: typeof payload?.searchTokenDoc === 'object' && payload.searchTokenDoc && !Array.isArray(payload.searchTokenDoc)
-        ? payload.searchTokenDoc
-        : null,
+      searchTokenDoc,
+      deferSearchTokens: true,
     })
     if (!suppressCoverage) {
       const doc = result.doc
@@ -84,16 +96,33 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
         } catch {}
       }
     }
-    // Kick off secondary pass (vectorize) asynchronously
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('query_index.vectorize_one', { entityType, recordId, organizationId, tenantId })
-    } catch {}
-    // Emit search indexing event
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('search.index_record', { entityId: entityType, recordId, organizationId, tenantId })
-    } catch {}
+    // Defer the heavy, eventually-consistent tail: search-token rebuild + vectorize +
+    // fulltext indexing. The data engine awaits this subscriber for projection
+    // consistency, so this work runs fire-and-forget to keep write latency bounded.
+    const deferredScope = { entityType, recordId, organizationId, tenantId }
+    const resolvedDoc = result.doc
+    void (async () => {
+      try {
+        await reindexSearchTokensForRecord(em, { ...deferredScope, doc: resolvedDoc, searchTokenDoc })
+        const bus = ctx.resolve<any>('eventBus')
+        await bus.emitEvent('query_index.vectorize_one', deferredScope)
+        await bus.emitEvent('search.index_record', { entityId: entityType, recordId, organizationId, tenantId })
+      } catch (error) {
+        await recordIndexerError(
+          { em },
+          {
+            source: 'query_index',
+            handler: 'event:query_index.upsert_one:search_tokens',
+            error,
+            entityType,
+            recordId,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            payload,
+          },
+        ).catch(() => {})
+      }
+    })()
   } catch (error) {
     await recordIndexerError(
       { em },

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

@@ -85,6 +85,13 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
   const searchParams = useSearchParams()
   const [initialValues, setInitialValues] = React.useState<Record<string, unknown> | null>(null)
   const [isNotFound, setIsNotFound] = React.useState(false)
+  // Capture the record (incl. its optimistic-lock `updatedAt`) exactly ONCE per
+  // resource. The load effect's deps include identity-unstable values (`t`,
+  // `resolveFieldsetCode`), so without this guard a re-render would re-fetch and
+  // overwrite `initialValues.updatedAt` with a newer server value mid-edit —
+  // silently defeating optimistic locking (a concurrent change would no longer be
+  // detected) and making the conflict flaky.
+  const loadedResourceIdRef = React.useRef<string | null>(null)
   const [tags, setTags] = React.useState<TagOption[]>([])
   const [activeTab, setActiveTab] = React.useState<'details' | 'availability'>('details')
   const [activeDetailTab, setActiveDetailTab] = React.useState<'notes' | 'activities'>('notes')
@@ -413,6 +420,9 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
 
   React.useEffect(() => {
     if (!resourceId || !resourceTypesLoaded) return
+    // Load once per resource — never re-fetch (and thereby refresh the captured
+    // optimistic-lock token) on subsequent re-renders. See loadedResourceIdRef.
+    if (loadedResourceIdRef.current === resourceId) return
     setIsNotFound(false)
     let cancelled = false
     async function loadResource() {
@@ -429,6 +439,7 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
           return
         }
         if (!cancelled) {
+          loadedResourceIdRef.current = resourceId ?? null
           const customValues = extractCustomFieldEntries(resource)
           setTags(Array.isArray(resource.tags) ? resource.tags : [])
           setAvailabilityRuleSetId(

package/src/modules/workflows/lib/workflow-executor.ts

@@ -433,6 +433,14 @@ export async function executeWorkflow(
             console.error(`[WORKFLOW] Transition rejected (instance: ${currentInstance.id}, workflow: ${currentInstance.workflowId}, step: ${currentInstance.currentStepId} → ${selectedTransition.toStepId}): ${rejectionMessage}`)
             errors.push(rejectionMessage)
 
+            await completeWorkflow(trx, container, instanceId, 'FAILED', {
+              error: rejectionMessage,
+            })
+            events.push({
+              eventType: 'WORKFLOW_FAILED',
+              occurredAt: new Date(),
+            })
+
             return {
               status: 'FAILED',
               currentStep: currentInstance.currentStepId,
@@ -501,6 +509,15 @@ export async function executeWorkflow(
             },
           })
 
+          await completeWorkflow(trx, container, instanceId, 'FAILED', {
+            error: errorMessage,
+            details: error instanceof WorkflowExecutionError ? error.details : undefined,
+          })
+          events.push({
+            eventType: 'WORKFLOW_FAILED',
+            occurredAt: new Date(),
+          })
+
           return {
             status: 'FAILED',
             currentStep: currentInstance.currentStepId,