@open-mercato/search 0.4.6-develop-6953d75a91 → 0.4.6-develop-5cacfcc21a

package/src/modules/search/frontend/components/sections/VectorSearchSection.tsx

@@ -4,6 +4,7 @@ import * as React from 'react'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useAppEvent } from '@open-mercato/ui/backend/injection/useAppEvent'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { Label } from '@open-mercato/ui/primitives/label'
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
@@ -234,13 +235,17 @@ export function VectorSearchSection({
     fetchActivityLogs()
   }, [fetchActivityLogs])
 
-  // Poll for activity when reindexing
-  React.useEffect(() => {
-    if (vectorReindexLock || vectorReindexing) {
-      const interval = setInterval(fetchActivityLogs, 5000)
-      return () => clearInterval(interval)
-    }
-  }, [vectorReindexLock, vectorReindexing, fetchActivityLogs])
+  useAppEvent('progress.job.updated', () => {
+    void fetchActivityLogs()
+  }, [fetchActivityLogs])
+
+  useAppEvent('progress.job.completed', () => {
+    void fetchActivityLogs()
+  }, [fetchActivityLogs])
+
+  useAppEvent('om:bridge:reconnected', () => {
+    void fetchActivityLogs()
+  }, [fetchActivityLogs])
 
   // Update auto-indexing
   const updateAutoIndexing = React.useCallback(async (nextValue: boolean) => {

package/src/modules/search/lib/reindex-progress.ts

@@ -0,0 +1,202 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { ProgressJob } from '@open-mercato/core/modules/progress/data/entities'
+import type { ProgressService } from '@open-mercato/core/modules/progress/lib/progressService'
+
+export type ReindexProgressType = 'fulltext' | 'vector'
+
+const REINDEX_JOB_CONFIG: Record<ReindexProgressType, { jobType: string; name: string }> = {
+  fulltext: {
+    jobType: 'search.reindex.fulltext',
+    name: 'Search fulltext reindex',
+  },
+  vector: {
+    jobType: 'search.reindex.vector',
+    name: 'Search vector reindex',
+  },
+}
+
+function buildScopeFilter(
+  type: ReindexProgressType,
+  tenantId: string,
+  organizationId?: string | null,
+) {
+  const config = REINDEX_JOB_CONFIG[type]
+  return {
+    jobType: config.jobType,
+    tenantId,
+    organizationId: organizationId ?? null,
+  }
+}
+
+async function findActiveJob(
+  em: EntityManager,
+  type: ReindexProgressType,
+  tenantId: string,
+  organizationId?: string | null,
+): Promise<ProgressJob | null> {
+  return em.findOne(
+    ProgressJob,
+    {
+      ...buildScopeFilter(type, tenantId, organizationId),
+      status: { $in: ['pending', 'running'] },
+    },
+    {
+      orderBy: { createdAt: 'DESC' },
+    },
+  )
+}
+
+export async function ensureReindexProgressJob(params: {
+  em: EntityManager
+  progressService: ProgressService
+  type: ReindexProgressType
+  tenantId: string
+  organizationId?: string | null
+  userId?: string | null
+  totalCount?: number | null
+  description?: string | null
+}): Promise<string | null> {
+  const current = await findActiveJob(params.em, params.type, params.tenantId, params.organizationId)
+  if (current) {
+    if (typeof params.totalCount === 'number') {
+      await params.progressService.updateProgress(
+        current.id,
+        { totalCount: params.totalCount },
+        {
+          tenantId: params.tenantId,
+          organizationId: params.organizationId ?? null,
+          userId: params.userId ?? null,
+        },
+      )
+    }
+    return current.id
+  }
+
+  const config = REINDEX_JOB_CONFIG[params.type]
+  const created = await params.progressService.createJob(
+    {
+      jobType: config.jobType,
+      name: config.name,
+      description: params.description ?? undefined,
+      totalCount: params.totalCount ?? undefined,
+      cancellable: true,
+      meta: {
+        source: 'search',
+        type: params.type,
+      },
+    },
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId ?? null,
+      userId: params.userId ?? null,
+    },
+  )
+  await params.progressService.startJob(created.id, {
+    tenantId: params.tenantId,
+    organizationId: params.organizationId ?? null,
+    userId: params.userId ?? null,
+  })
+  return created.id
+}
+
+export async function incrementReindexProgress(params: {
+  em: EntityManager
+  progressService: ProgressService
+  type: ReindexProgressType
+  tenantId: string
+  organizationId?: string | null
+  delta: number
+}): Promise<boolean> {
+  if (!Number.isFinite(params.delta) || params.delta <= 0) return false
+  const current = await findActiveJob(params.em, params.type, params.tenantId, params.organizationId)
+  if (!current) return false
+  const updated = await params.progressService.incrementProgress(
+    current.id,
+    params.delta,
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId ?? null,
+      userId: null,
+    },
+  )
+  if (updated.totalCount && updated.processedCount >= updated.totalCount) {
+    await params.progressService.completeJob(
+      updated.id,
+      {
+        resultSummary: {
+          processedCount: updated.processedCount,
+          totalCount: updated.totalCount,
+        },
+      },
+      {
+        tenantId: params.tenantId,
+        organizationId: params.organizationId ?? null,
+        userId: null,
+      },
+    )
+    return true
+  }
+  return false
+}
+
+export async function completeReindexProgress(params: {
+  em: EntityManager
+  progressService: ProgressService
+  type: ReindexProgressType
+  tenantId: string
+  organizationId?: string | null
+  resultSummary?: Record<string, unknown>
+}): Promise<void> {
+  const current = await findActiveJob(params.em, params.type, params.tenantId, params.organizationId)
+  if (!current) return
+  await params.progressService.completeJob(
+    current.id,
+    { resultSummary: params.resultSummary ?? {} },
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId ?? null,
+      userId: null,
+    },
+  )
+}
+
+export async function failReindexProgress(params: {
+  em: EntityManager
+  progressService: ProgressService
+  type: ReindexProgressType
+  tenantId: string
+  organizationId?: string | null
+  errorMessage: string
+}): Promise<void> {
+  const current = await findActiveJob(params.em, params.type, params.tenantId, params.organizationId)
+  if (!current) return
+  await params.progressService.failJob(
+    current.id,
+    { errorMessage: params.errorMessage },
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId ?? null,
+      userId: null,
+    },
+  )
+}
+
+export async function cancelReindexProgress(params: {
+  em: EntityManager
+  progressService: ProgressService
+  type: ReindexProgressType
+  tenantId: string
+  organizationId?: string | null
+  userId?: string | null
+}): Promise<void> {
+  const current = await findActiveJob(params.em, params.type, params.tenantId, params.organizationId)
+  if (!current) return
+  await params.progressService.cancelJob(
+    current.id,
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId ?? null,
+      userId: params.userId ?? null,
+    },
+  )
+}

package/src/modules/search/workers/fulltext-index.worker.ts

@@ -7,8 +7,10 @@ import type { Knex } from 'knex'
 import type { EntityId } from '@open-mercato/shared/modules/entities'
 import { recordIndexerLog } from '@open-mercato/shared/lib/indexers/status-log'
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
+import type { ProgressService } from '@open-mercato/core/modules/progress/lib/progressService'
 import { searchDebug, searchDebugWarn, searchError } from '../../../lib/debug'
-import { updateReindexProgress } from '../lib/reindex-lock'
+import { clearReindexLock, updateReindexProgress } from '../lib/reindex-lock'
+import { incrementReindexProgress } from '../lib/reindex-progress'
 
 // Worker metadata for auto-discovery
 const DEFAULT_CONCURRENCY = 2
@@ -93,6 +95,13 @@ export async function handleFulltextIndexJob(
   }
 
   try {
+    let progressService: ProgressService | null = null
+    try {
+      progressService = ctx.resolve<ProgressService>('progressService')
+    } catch {
+      progressService = null
+    }
+
     // ========== SINGLE INDEX: Use searchIndexer.indexRecordById() for fresh data ==========
     if (jobType === 'index') {
       const { entityType, recordId, organizationId } = job.payload as {
@@ -184,9 +193,22 @@ export async function handleFulltextIndexJob(
       }
 
       // Update heartbeat to signal worker is still processing
-      if (knex && successCount > 0) {
+      if (knex && records.length > 0) {
         await updateReindexProgress(knex, tenantId, 'fulltext', successCount, organizationId ?? null)
       }
+      if (progressService && em && records.length > 0) {
+        const completed = await incrementReindexProgress({
+          em,
+          progressService,
+          type: 'fulltext',
+          tenantId,
+          organizationId: organizationId ?? null,
+          delta: successCount,
+        })
+        if (completed && knex) {
+          await clearReindexLock(knex, tenantId, 'fulltext', organizationId ?? null)
+        }
+      }
 
       searchDebug('fulltext-index.worker', 'Batch indexed to fulltext', {
         jobId: jobCtx.jobId,

package/src/modules/search/workers/vector-index.worker.ts

@@ -4,13 +4,15 @@ import type { SearchIndexer } from '../../../indexer/search-indexer'
 import type { EmbeddingService } from '../../../vector'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import type { Knex } from 'knex'
+import type { ProgressService } from '@open-mercato/core/modules/progress/lib/progressService'
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
 import { applyCoverageAdjustments, createCoverageAdjustments } from '@open-mercato/core/modules/query_index/lib/coverage'
 import { logVectorOperation } from '../../../vector/lib/vector-logs'
 import { resolveAutoIndexingEnabled } from '../lib/auto-indexing'
 import { resolveEmbeddingConfig } from '../lib/embedding-config'
 import { searchDebugWarn } from '../../../lib/debug'
-import { updateReindexProgress } from '../lib/reindex-lock'
+import { clearReindexLock, updateReindexProgress } from '../lib/reindex-lock'
+import { incrementReindexProgress } from '../lib/reindex-progress'
 
 // Worker metadata for auto-discovery
 const DEFAULT_CONCURRENCY = 2
@@ -61,11 +63,20 @@ export async function handleVectorIndexJob(
 
     // Get knex for heartbeat updates
     let knex: Knex | null = null
+    let em: EntityManager | null = null
     try {
-      const em = ctx.resolve('em') as EntityManager
+      em = ctx.resolve('em') as EntityManager
       knex = (em.getConnection() as unknown as { getKnex: () => Knex }).getKnex()
     } catch {
       knex = null
+      em = null
+    }
+
+    let progressService: ProgressService | null = null
+    try {
+      progressService = ctx.resolve<ProgressService>('progressService')
+    } catch {
+      progressService = null
     }
 
     // Load saved embedding config to use the correct provider/model
@@ -106,9 +117,22 @@ export async function handleVectorIndexJob(
     }
 
     // Update heartbeat to signal worker is still processing
-    if (knex && successCount > 0) {
+    if (knex && records.length > 0) {
       await updateReindexProgress(knex, tenantId, 'vector', successCount, organizationId ?? null)
     }
+    if (progressService && em && records.length > 0) {
+      const completed = await incrementReindexProgress({
+        em,
+        progressService,
+        type: 'vector',
+        tenantId,
+        organizationId: organizationId ?? null,
+        delta: successCount,
+      })
+      if (completed && knex) {
+        await clearReindexLock(knex, tenantId, 'vector', organizationId ?? null)
+      }
+    }
 
     searchDebugWarn('vector-index.worker', 'Batch-index job completed', {
       jobId: jobCtx.jobId,