@open-mercato/search 0.4.2-canary-c02407ff85

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

@@ -0,0 +1,201 @@
+import type { Knex } from 'knex'
+import {
+  prepareJob,
+  updateJobProgress,
+  finalizeJob,
+  type JobScope,
+} from '@open-mercato/core/modules/query_index/lib/jobs'
+
+export const REINDEX_LOCK_KEY = 'reindex_lock'
+
+export type ReindexLockType = 'fulltext' | 'vector'
+
+// Entity type mapping for search reindex jobs
+const LOCK_ENTITY_TYPES: Record<ReindexLockType, string> = {
+  fulltext: 'search:reindex:fulltext',
+  vector: 'search:reindex:vector',
+}
+
+// Heartbeat staleness threshold (30 seconds)
+const HEARTBEAT_STALE_MS = 30 * 1000
+
+export type ReindexLockStatus = {
+  type: ReindexLockType
+  action: string
+  startedAt: string
+  tenantId: string
+  organizationId?: string | null
+  processedCount?: number | null
+  totalCount?: number | null
+}
+
+function buildScope(
+  type: ReindexLockType,
+  tenantId: string,
+  organizationId?: string | null,
+): JobScope {
+  return {
+    entityType: LOCK_ENTITY_TYPES[type],
+    tenantId,
+    organizationId: organizationId ?? null,
+    partitionIndex: null,
+    partitionCount: null,
+  }
+}
+
+/**
+ * Check if a reindex operation is currently in progress for a specific type.
+ * Returns the lock status if active, null if no lock or lock is stale.
+ *
+ * Automatically cleans up stale locks (heartbeat older than 60 seconds).
+ */
+export async function getReindexLockStatus(
+  knex: Knex,
+  tenantId: string,
+  options?: { type?: ReindexLockType },
+): Promise<ReindexLockStatus | null> {
+  const typesToCheck: ReindexLockType[] = options?.type
+    ? [options.type]
+    : ['fulltext', 'vector']
+
+  for (const lockType of typesToCheck) {
+    const entityType = LOCK_ENTITY_TYPES[lockType]
+
+    try {
+      const job = await knex('entity_index_jobs')
+        .where('entity_type', entityType)
+        .whereRaw('tenant_id is not distinct from ?', [tenantId])
+        .whereNull('finished_at')
+        .first()
+
+      if (!job) continue
+
+      // Check heartbeat staleness
+      const heartbeatAt = job.heartbeat_at
+        ? new Date(job.heartbeat_at).getTime()
+        : 0
+      const elapsed = Date.now() - heartbeatAt
+
+      if (elapsed > HEARTBEAT_STALE_MS) {
+        // Auto-cleanup stale lock
+        await knex('entity_index_jobs')
+          .where('id', job.id)
+          .update({ finished_at: knex.fn.now() })
+        continue
+      }
+
+      // started_at comes as string from knex, convert if needed
+      const startedAtStr = job.started_at
+        ? (typeof job.started_at === 'string' ? job.started_at : new Date(job.started_at).toISOString())
+        : new Date().toISOString()
+
+      const result = {
+        type: lockType,
+        action: job.status || 'reindexing',
+        startedAt: startedAtStr,
+        tenantId,
+        organizationId: job.organization_id,
+        processedCount: job.processed_count,
+        totalCount: job.total_count,
+      }
+      return result
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+/**
+ * Acquire a reindex lock for a specific type. Returns whether lock was acquired.
+ * Fulltext and vector locks are independent - they don't block each other.
+ */
+export async function acquireReindexLock(
+  knex: Knex,
+  options: {
+    type: ReindexLockType
+    action: string
+    tenantId: string
+    organizationId?: string | null
+    totalCount?: number | null
+  },
+): Promise<{ acquired: boolean; jobId?: string }> {
+  // Check existing active lock
+  const existing = await getReindexLockStatus(knex, options.tenantId, {
+    type: options.type,
+  })
+  if (existing) {
+    return { acquired: false }
+  }
+
+  try {
+    const scope = buildScope(
+      options.type,
+      options.tenantId,
+      options.organizationId,
+    )
+    const jobId = await prepareJob(knex, scope, 'reindexing', {
+      totalCount: options.totalCount,
+    })
+
+    return { acquired: true, jobId: jobId ?? undefined }
+  } catch {
+    return { acquired: false }
+  }
+}
+
+/**
+ * Release the reindex lock for a specific type.
+ */
+export async function clearReindexLock(
+  knex: Knex,
+  tenantId: string,
+  type: ReindexLockType,
+  organizationId?: string | null,
+): Promise<void> {
+  try {
+    const scope = buildScope(type, tenantId, organizationId)
+    await finalizeJob(knex, scope)
+  } catch {
+    // Ignore errors when clearing lock
+  }
+}
+
+/**
+ * Update the reindex progress and refresh the heartbeat.
+ * Call this periodically during batch processing to prevent stale lock detection.
+ *
+ * If no active lock exists (e.g., it expired after queue restart), this will
+ * recreate the lock so the reindex button stays disabled while processing.
+ */
+export async function updateReindexProgress(
+  knex: Knex,
+  tenantId: string,
+  type: ReindexLockType,
+  processedDelta: number,
+  organizationId?: string | null,
+): Promise<void> {
+  try {
+    const scope = buildScope(type, tenantId, organizationId)
+    const entityType = LOCK_ENTITY_TYPES[type]
+
+    // Try to update existing active job first
+    const updated = await knex('entity_index_jobs')
+      .where('entity_type', entityType)
+      .whereRaw('tenant_id is not distinct from ?', [tenantId])
+      .whereRaw('organization_id is not distinct from ?', [organizationId ?? null])
+      .whereNull('finished_at')
+      .update({
+        processed_count: knex.raw('coalesce(processed_count, 0) + ?', [Math.max(0, processedDelta)]),
+        heartbeat_at: knex.fn.now(),
+      })
+
+    // If no active lock exists, recreate it
+    if (updated === 0) {
+      await prepareJob(knex, scope, 'reindexing')
+    }
+  } catch {
+    // Ignore errors when updating progress
+  }
+}

package/src/modules/search/subscribers/fulltext_upsert.ts

@@ -0,0 +1,83 @@
+import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
+import type { Queue } from '@open-mercato/queue'
+import type { FulltextIndexJobPayload } from '../../../queue/fulltext-indexing'
+import { resolveAutoIndexingEnabled } from '../lib/auto-indexing'
+import { searchDebugWarn, searchError } from '../../../lib/debug'
+
+export const metadata = { event: 'search.index_record', persistent: false }
+
+type Payload = {
+  entityId?: string
+  recordId?: string
+  organizationId?: string | null
+  tenantId?: string | null
+}
+
+type HandlerContext = { resolve: <T = unknown>(name: string) => T }
+
+export default async function handle(payload: Payload, ctx: HandlerContext) {
+  const entityType = String(payload?.entityId ?? '')
+  const recordId = String(payload?.recordId ?? '')
+
+  if (!entityType || !recordId) {
+    return
+  }
+
+  let organizationId = payload?.organizationId ?? null
+  let tenantId = payload?.tenantId ?? null
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let em: any | null = null
+  try {
+    em = ctx.resolve('em')
+  } catch {
+    em = null
+  }
+
+  // Resolve missing scope from DB if needed (same pattern as vector_upsert.ts)
+  if ((organizationId == null || tenantId == null) && em) {
+    try {
+      const knex = em.getConnection().getKnex()
+      const table = resolveEntityTableName(em, entityType)
+      const row = await knex(table).select(['organization_id', 'tenant_id']).where({ id: recordId }).first()
+      if (organizationId == null) organizationId = row?.organization_id ?? organizationId
+      if (tenantId == null) tenantId = row?.tenant_id ?? tenantId
+    } catch {
+      // Ignore lookup errors
+    }
+  }
+
+  if (!tenantId) {
+    return
+  }
+
+  const autoIndexingEnabled = await resolveAutoIndexingEnabled(ctx, { defaultValue: true })
+  if (!autoIndexingEnabled) {
+    return
+  }
+
+  let queue: Queue<FulltextIndexJobPayload>
+  try {
+    queue = ctx.resolve<Queue<FulltextIndexJobPayload>>('fulltextIndexQueue')
+  } catch {
+    searchDebugWarn('search.fulltext', 'fulltextIndexQueue not available, skipping fulltext indexing')
+    return
+  }
+
+  try {
+    await queue.enqueue({
+      jobType: 'index',
+      entityType,
+      recordId,
+      tenantId: String(tenantId),
+      organizationId: organizationId ? String(organizationId) : null,
+    })
+  } catch (error) {
+    searchError('search.fulltext', 'Failed to enqueue fulltext index job', {
+      entityType,
+      recordId,
+      error: error instanceof Error ? error.message : error,
+    })
+    throw error
+  }
+}

package/src/modules/search/subscribers/vector_delete.ts

@@ -0,0 +1,75 @@
+import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
+import type { Queue } from '@open-mercato/queue'
+import type { VectorIndexJobPayload } from '../../../queue/vector-indexing'
+import { resolveAutoIndexingEnabled } from '../lib/auto-indexing'
+import { searchDebugWarn, searchError } from '../../../lib/debug'
+
+export const metadata = { event: 'query_index.delete_one', persistent: false }
+
+type Payload = {
+  entityType?: string
+  recordId?: string
+  organizationId?: string | null
+  tenantId?: string | null
+}
+
+type HandlerContext = { resolve: <T = unknown>(name: string) => T }
+
+export default async function handle(payload: Payload, ctx: HandlerContext) {
+  const entityType = String(payload?.entityType ?? '')
+  const recordId = String(payload?.recordId ?? '')
+  if (!entityType || !recordId) return
+
+  let organizationId = payload?.organizationId ?? null
+  let tenantId = payload?.tenantId ?? null
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let em: any | null = null
+  try {
+    em = ctx.resolve('em')
+  } catch {
+    em = null
+  }
+
+  if ((organizationId == null || tenantId == null) && em) {
+    try {
+      const knex = em.getConnection().getKnex()
+      const table = resolveEntityTableName(em, entityType)
+      const row = await knex(table).select(['organization_id', 'tenant_id']).where({ id: recordId }).first()
+      if (organizationId == null) organizationId = row?.organization_id ?? organizationId
+      if (tenantId == null) tenantId = row?.tenant_id ?? tenantId
+    } catch {
+      // Ignore lookup errors
+    }
+  }
+
+  if (!tenantId) return
+
+  const autoIndexingEnabled = await resolveAutoIndexingEnabled(ctx, { defaultValue: true })
+  if (!autoIndexingEnabled) return
+
+  let queue: Queue<VectorIndexJobPayload>
+  try {
+    queue = ctx.resolve<Queue<VectorIndexJobPayload>>('vectorIndexQueue')
+  } catch {
+    searchDebugWarn('search.vector', 'vectorIndexQueue not available, skipping vector delete')
+    return
+  }
+
+  try {
+    await queue.enqueue({
+      jobType: 'delete',
+      entityType,
+      recordId,
+      tenantId: String(tenantId),
+      organizationId: organizationId ? String(organizationId) : null,
+    })
+  } catch (error) {
+    searchError('search.vector', 'Failed to enqueue vector delete job', {
+      entityType,
+      recordId,
+      error: error instanceof Error ? error.message : error,
+    })
+    throw error // Propagate to caller so failure is visible
+  }
+}

package/src/modules/search/subscribers/vector_purge.ts

@@ -0,0 +1,161 @@
+import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
+import { recordIndexerLog } from '@open-mercato/shared/lib/indexers/status-log'
+import type { SearchIndexer } from '../../../indexer/search-indexer'
+import type { EmbeddingService } from '../../../vector'
+import { writeCoverageCounts } from '@open-mercato/core/modules/query_index/lib/coverage'
+import { resolveEmbeddingConfig } from '../lib/embedding-config'
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import { searchDebugWarn } from '../../../lib/debug'
+
+export const metadata = { event: 'query_index.vectorize_purge', persistent: false }
+
+type Payload = {
+  entityType?: string
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type HandlerContext = { resolve: <T = any>(name: string) => T }
+
+export default async function handle(payload: Payload, ctx: HandlerContext) {
+  const entityType = String(payload?.entityType ?? '')
+  if (!entityType) return
+  const tenantIdRaw = payload?.tenantId
+  if (tenantIdRaw == null || tenantIdRaw === '') {
+    searchDebugWarn('search.vector', 'Skipping vector purge for reindex without tenant scope', { entityType })
+    return
+  }
+  const tenantId = String(tenantIdRaw)
+  const organizationId = payload?.organizationId == null ? null : String(payload.organizationId)
+
+  let searchIndexer: SearchIndexer
+  try {
+    searchIndexer = ctx.resolve<SearchIndexer>('searchIndexer')
+  } catch {
+    return
+  }
+
+  // Load saved embedding config for consistency (dimension info may be needed for table recreation)
+  try {
+    const embeddingConfig = await resolveEmbeddingConfig(ctx, { defaultValue: null })
+    if (embeddingConfig) {
+      const embeddingService = ctx.resolve<EmbeddingService>('vectorEmbeddingService')
+      embeddingService.updateConfig(embeddingConfig)
+    }
+  } catch {
+    // Purge operations don't require embedding, ignore config errors
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let em: any = null
+  try {
+    em = ctx.resolve('em')
+  } catch {
+    em = null
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let eventBus: { emitEvent(event: string, payload: any, options?: any): Promise<void> } | null = null
+  try {
+    eventBus = ctx.resolve('eventBus')
+  } catch {
+    eventBus = null
+  }
+  const scopes = new Set<string>()
+  const registerScope = (org: string | null) => {
+    const key = org ?? '__null__'
+    if (!scopes.has(key)) scopes.add(key)
+  }
+  registerScope(null)
+  if (organizationId != null) registerScope(organizationId)
+
+  try {
+    await searchIndexer.purgeEntity({
+      entityId: entityType as EntityId,
+      tenantId,
+    })
+    if (em) {
+      try {
+        for (const scope of scopes) {
+          const orgValue = scope === '__null__' ? null : scope
+          await writeCoverageCounts(
+            em,
+            {
+              entityType,
+              tenantId,
+              organizationId: orgValue,
+              withDeleted: false,
+            },
+            { vectorCount: 0 },
+          )
+        }
+      } catch (coverageError) {
+        searchDebugWarn('search.vector', 'Failed to reset vector coverage after purge', {
+          error: coverageError instanceof Error ? coverageError.message : coverageError,
+        })
+      }
+    }
+    if (eventBus) {
+      await Promise.all(
+        Array.from(scopes).map((scope) => {
+          const orgValue = scope === '__null__' ? null : scope
+          return eventBus!
+            .emitEvent(
+              'query_index.coverage.refresh',
+              {
+                entityType,
+                tenantId,
+                organizationId: orgValue,
+                delayMs: 0,
+              },
+            )
+            .catch(() => undefined)
+        }),
+      )
+    }
+    await recordIndexerLog(
+      { em: em ?? undefined },
+      {
+        source: 'vector',
+        handler: 'event:query_index.vectorize_purge',
+        message: `Vector purge completed for ${entityType}`,
+        entityType,
+        tenantId,
+        organizationId,
+        details: payload,
+      },
+    ).catch(() => undefined)
+  } catch (error) {
+    searchDebugWarn('search.vector', 'Failed to purge vector index scope', {
+      entityType,
+      tenantId,
+      organizationId,
+      error: error instanceof Error ? error.message : error,
+    })
+    await recordIndexerLog(
+      { em: em ?? undefined },
+      {
+        source: 'vector',
+        handler: 'event:query_index.vectorize_purge',
+        level: 'warn',
+        message: `Vector purge failed for ${entityType}`,
+        entityType,
+        tenantId,
+        organizationId,
+        details: { error: error instanceof Error ? error.message : String(error), payload },
+      },
+    ).catch(() => undefined)
+    await recordIndexerError(
+      { em: em ?? undefined },
+      {
+        source: 'vector',
+        handler: 'event:query_index.vectorize_purge',
+        error,
+        entityType,
+        tenantId,
+        organizationId,
+        payload,
+      },
+    )
+  }
+}

package/src/modules/search/subscribers/vector_upsert.ts

@@ -0,0 +1,75 @@
+import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
+import type { Queue } from '@open-mercato/queue'
+import type { VectorIndexJobPayload } from '../../../queue/vector-indexing'
+import { resolveAutoIndexingEnabled } from '../lib/auto-indexing'
+import { searchDebugWarn, searchError } from '../../../lib/debug'
+
+export const metadata = { event: 'query_index.vectorize_one', persistent: false }
+
+type Payload = {
+  entityType?: string
+  recordId?: string
+  organizationId?: string | null
+  tenantId?: string | null
+}
+
+type HandlerContext = { resolve: <T = unknown>(name: string) => T }
+
+export default async function handle(payload: Payload, ctx: HandlerContext) {
+  const entityType = String(payload?.entityType ?? '')
+  const recordId = String(payload?.recordId ?? '')
+  if (!entityType || !recordId) return
+
+  let organizationId = payload?.organizationId ?? null
+  let tenantId = payload?.tenantId ?? null
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let em: any | null = null
+  try {
+    em = ctx.resolve('em')
+  } catch {
+    em = null
+  }
+
+  if ((organizationId == null || tenantId == null) && em) {
+    try {
+      const knex = em.getConnection().getKnex()
+      const table = resolveEntityTableName(em, entityType)
+      const row = await knex(table).select(['organization_id', 'tenant_id']).where({ id: recordId }).first()
+      if (organizationId == null) organizationId = row?.organization_id ?? organizationId
+      if (tenantId == null) tenantId = row?.tenant_id ?? tenantId
+    } catch {
+      // Ignore lookup errors
+    }
+  }
+
+  if (!tenantId) return
+
+  const autoIndexingEnabled = await resolveAutoIndexingEnabled(ctx, { defaultValue: true })
+  if (!autoIndexingEnabled) return
+
+  let queue: Queue<VectorIndexJobPayload>
+  try {
+    queue = ctx.resolve<Queue<VectorIndexJobPayload>>('vectorIndexQueue')
+  } catch {
+    searchDebugWarn('search.vector', 'vectorIndexQueue not available, skipping vector indexing')
+    return
+  }
+
+  try {
+    await queue.enqueue({
+      jobType: 'index',
+      entityType,
+      recordId,
+      tenantId: String(tenantId),
+      organizationId: organizationId ? String(organizationId) : null,
+    })
+  } catch (error) {
+    searchError('search.vector', 'Failed to enqueue vector index job', {
+      entityType,
+      recordId,
+      error: error instanceof Error ? error.message : error,
+    })
+    throw error // Propagate to caller so failure is visible
+  }
+}