@open-mercato/search 0.4.2-canary-c02407ff85

package/src/modules/search/api/settings/fulltext/route.ts

@@ -0,0 +1,82 @@
+import { NextResponse } from 'next/server'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['search.view'] },
+}
+
+type EnvVarStatus = {
+  set: boolean
+  hint: string
+}
+
+type OptionalEnvVarStatus = {
+  set: boolean
+  value?: string | boolean
+  default?: string | boolean
+  hint: string
+}
+
+type FulltextConfigResponse = {
+  driver: 'meilisearch' | null
+  configured: boolean
+  envVars: {
+    MEILISEARCH_HOST: EnvVarStatus
+    MEILISEARCH_API_KEY: EnvVarStatus
+  }
+  optionalEnvVars: {
+    MEILISEARCH_INDEX_PREFIX: OptionalEnvVarStatus
+    SEARCH_EXCLUDE_ENCRYPTED_FIELDS: OptionalEnvVarStatus
+  }
+}
+
+const unauthorized = async () => {
+  const { t } = await resolveTranslations()
+  return NextResponse.json({ error: t('api.errors.unauthorized', 'Unauthorized') }, { status: 401 })
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  const hostSet = Boolean(process.env.MEILISEARCH_HOST?.trim())
+  const apiKeySet = Boolean(process.env.MEILISEARCH_API_KEY?.trim())
+  const configured = hostSet && apiKeySet
+
+  const indexPrefix = process.env.MEILISEARCH_INDEX_PREFIX?.trim()
+  const excludeEncrypted = ['1', 'true', 'yes', 'on'].includes(
+    (process.env.SEARCH_EXCLUDE_ENCRYPTED_FIELDS ?? '').toLowerCase()
+  )
+
+  const response: FulltextConfigResponse = {
+    driver: configured ? 'meilisearch' : null,
+    configured,
+    envVars: {
+      MEILISEARCH_HOST: {
+        set: hostSet,
+        hint: 'The URL of your Meilisearch server (e.g., http://localhost:7700)',
+      },
+      MEILISEARCH_API_KEY: {
+        set: apiKeySet,
+        hint: 'API key for authentication with Meilisearch',
+      },
+    },
+    optionalEnvVars: {
+      MEILISEARCH_INDEX_PREFIX: {
+        set: Boolean(indexPrefix),
+        value: indexPrefix,
+        default: 'om',
+        hint: 'Prefix for index names to namespace indexes per tenant',
+      },
+      SEARCH_EXCLUDE_ENCRYPTED_FIELDS: {
+        set: Boolean(process.env.SEARCH_EXCLUDE_ENCRYPTED_FIELDS),
+        value: excludeEncrypted,
+        default: false,
+        hint: 'Exclude encrypted fields from full-text indexing for security',
+      },
+    },
+  }
+
+  return NextResponse.json(response)
+}

package/src/modules/search/api/settings/global-search/route.ts

@@ -0,0 +1,91 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import {
+  resolveGlobalSearchStrategies,
+  saveGlobalSearchStrategies,
+  DEFAULT_GLOBAL_SEARCH_STRATEGIES,
+} from '../../../lib/global-search-config'
+import type { SearchStrategyId } from '@open-mercato/shared/modules/search'
+
+const updateSchema = z.object({
+  enabledStrategies: z.array(z.enum(['fulltext', 'vector', 'tokens'])).min(1),
+})
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['search.view'] },
+  POST: { requireAuth: true, requireFeatures: ['search.manage'] },
+}
+
+type SettingsResponse = {
+  enabledStrategies: SearchStrategyId[]
+}
+
+const toJson = (payload: SettingsResponse, init?: ResponseInit) => NextResponse.json(payload, init)
+
+const unauthorized = async () => {
+  const { t } = await resolveTranslations()
+  return NextResponse.json({ error: t('api.errors.unauthorized', 'Unauthorized') }, { status: 401 })
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  const container = await createRequestContainer()
+  try {
+    const enabledStrategies = await resolveGlobalSearchStrategies(container, {
+      defaultValue: DEFAULT_GLOBAL_SEARCH_STRATEGIES,
+    })
+
+    return toJson({ enabledStrategies })
+  } finally {
+    const disposable = container as unknown as { dispose?: () => Promise<void> }
+    if (typeof disposable.dispose === 'function') {
+      await disposable.dispose()
+    }
+  }
+}
+
+export async function POST(req: Request) {
+  const { t } = await resolveTranslations()
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  let body: unknown
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json(
+      { error: t('api.errors.invalidPayload', 'Invalid request body') },
+      { status: 400 }
+    )
+  }
+
+  const parsed = updateSchema.safeParse(body)
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: t('search.api.errors.invalidStrategies', 'Invalid strategies configuration') },
+      { status: 400 }
+    )
+  }
+
+  const container = await createRequestContainer()
+  try {
+    await saveGlobalSearchStrategies(container, parsed.data.enabledStrategies)
+
+    return NextResponse.json({ ok: true, enabledStrategies: parsed.data.enabledStrategies })
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : t('api.errors.internal', 'Internal error') },
+      { status: 500 }
+    )
+  } finally {
+    const disposable = container as unknown as { dispose?: () => Promise<void> }
+    if (typeof disposable.dispose === 'function') {
+      await disposable.dispose()
+    }
+  }
+}

package/src/modules/search/api/settings/route.ts

@@ -0,0 +1,187 @@
+import { NextResponse } from 'next/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { SearchService } from '@open-mercato/search'
+import type { FullTextSearchStrategy } from '@open-mercato/search/strategies'
+import type { Knex } from 'knex'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { getReindexLockStatus } from '../../lib/reindex-lock'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['search.view'] },
+}
+
+type StrategyStatus = {
+  id: string
+  name: string
+  priority: number
+  available: boolean
+}
+
+type FulltextStats = {
+  numberOfDocuments: number
+  isIndexing: boolean
+  fieldDistribution: Record<string, number>
+}
+
+type ReindexLock = {
+  type: 'fulltext' | 'vector'
+  action: string
+  startedAt: string
+  elapsedMinutes: number
+  processedCount?: number | null
+  totalCount?: number | null
+}
+
+type SearchSettings = {
+  strategies: StrategyStatus[]
+  fulltextConfigured: boolean
+  fulltextStats: FulltextStats | null
+  vectorConfigured: boolean
+  tokensEnabled: boolean
+  defaultStrategies: string[]
+  /** @deprecated Use fulltextReindexLock or vectorReindexLock instead */
+  reindexLock: ReindexLock | null
+  fulltextReindexLock: ReindexLock | null
+  vectorReindexLock: ReindexLock | null
+}
+
+type SettingsResponse = {
+  settings: SearchSettings
+}
+
+const toJson = (payload: SettingsResponse, init?: ResponseInit) => NextResponse.json(payload, init)
+
+const unauthorized = async () => {
+  const { t } = await resolveTranslations()
+  return NextResponse.json({ error: t('api.errors.unauthorized', 'Unauthorized') }, { status: 401 })
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  const container = await createRequestContainer()
+  try {
+    const strategies: StrategyStatus[] = []
+    let defaultStrategies: string[] = []
+    let fulltextStats: FulltextStats | null = null
+
+    try {
+      const searchService = container.resolve('searchService') as SearchService | undefined
+      const searchStrategies = container.resolve('searchStrategies') as unknown[] | undefined
+
+      if (searchStrategies) {
+        for (const strategy of searchStrategies) {
+          const s = strategy as { id?: string; name?: string; priority?: number; isAvailable?: () => Promise<boolean> }
+          const available = await s.isAvailable?.() ?? true
+          strategies.push({
+            id: s.id ?? 'unknown',
+            name: s.name ?? s.id ?? 'unknown',
+            priority: s.priority ?? 0,
+            available,
+          })
+        }
+
+        // Get fulltext stats if available and tenant is set
+        if (auth.tenantId) {
+          const fulltextStrategy = searchStrategies.find(
+            (s: unknown) => (s as { id?: string })?.id === 'fulltext'
+          ) as FullTextSearchStrategy | undefined
+
+          if (fulltextStrategy) {
+            try {
+              const stats = await fulltextStrategy.getIndexStats(auth.tenantId)
+              if (stats) {
+                fulltextStats = stats
+              }
+            } catch {
+              // Stats not available
+            }
+          }
+        }
+      }
+
+      if (searchService) {
+        defaultStrategies = searchService.getDefaultStrategies?.() ?? []
+      }
+    } catch {
+      // Search service may not be available
+    }
+
+    const fulltextConfigured = Boolean(
+      process.env.MEILISEARCH_HOST && process.env.MEILISEARCH_HOST.trim().length > 0
+    )
+
+    const vectorConfigured = Boolean(
+      process.env.OPENAI_API_KEY ||
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY ||
+      process.env.MISTRAL_API_KEY ||
+      process.env.COHERE_API_KEY ||
+      process.env.AWS_ACCESS_KEY_ID ||
+      process.env.OLLAMA_BASE_URL
+    )
+
+    const tokensEnabled = process.env.OM_SEARCH_ENABLED !== 'false'
+
+    // Check for active reindex locks with heartbeat-based stale detection
+    let fulltextReindexLock: ReindexLock | null = null
+    let vectorReindexLock: ReindexLock | null = null
+
+    if (auth.tenantId) {
+      const em = container.resolve('em') as EntityManager
+      const knex = (em.getConnection() as unknown as { getKnex: () => Knex }).getKnex()
+
+      // Check fulltext lock (auto-cleans stale locks based on heartbeat)
+      const fulltextLockStatus = await getReindexLockStatus(knex, auth.tenantId, { type: 'fulltext' })
+      if (fulltextLockStatus) {
+        const startedAt = new Date(fulltextLockStatus.startedAt)
+        fulltextReindexLock = {
+          type: 'fulltext',
+          action: fulltextLockStatus.action,
+          startedAt: fulltextLockStatus.startedAt,
+          elapsedMinutes: Math.round((Date.now() - startedAt.getTime()) / 60000),
+          processedCount: fulltextLockStatus.processedCount,
+          totalCount: fulltextLockStatus.totalCount,
+        }
+      }
+
+      // Check vector lock (auto-cleans stale locks based on heartbeat)
+      const vectorLockStatus = await getReindexLockStatus(knex, auth.tenantId, { type: 'vector' })
+      if (vectorLockStatus) {
+        const startedAt = new Date(vectorLockStatus.startedAt)
+        vectorReindexLock = {
+          type: 'vector',
+          action: vectorLockStatus.action,
+          startedAt: vectorLockStatus.startedAt,
+          elapsedMinutes: Math.round((Date.now() - startedAt.getTime()) / 60000),
+          processedCount: vectorLockStatus.processedCount,
+          totalCount: vectorLockStatus.totalCount,
+        }
+      }
+    }
+
+    // Keep deprecated reindexLock for backwards compatibility (prefer fulltext if both are active)
+    const reindexLock = fulltextReindexLock ?? vectorReindexLock
+
+    return toJson({
+      settings: {
+        strategies,
+        fulltextConfigured,
+        fulltextStats,
+        vectorConfigured,
+        tokensEnabled,
+        defaultStrategies,
+        reindexLock,
+        fulltextReindexLock,
+        vectorReindexLock,
+      },
+    })
+  } finally {
+    const disposable = container as unknown as { dispose?: () => Promise<void> }
+    if (typeof disposable.dispose === 'function') {
+      await disposable.dispose()
+    }
+  }
+}

package/src/modules/search/api/settings/vector-store/route.ts

@@ -0,0 +1,105 @@
+import { NextResponse } from 'next/server'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { VectorDriverId } from '@open-mercato/shared/modules/vector'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['search.view'] },
+}
+
+type DriverStatus = {
+  id: VectorDriverId
+  name: string
+  configured: boolean
+  implemented: boolean
+  envVars: {
+    name: string
+    set: boolean
+    hint: string
+  }[]
+}
+
+type VectorStoreConfigResponse = {
+  currentDriver: VectorDriverId
+  configured: boolean
+  drivers: DriverStatus[]
+}
+
+const unauthorized = async () => {
+  const { t } = await resolveTranslations()
+  return NextResponse.json({ error: t('api.errors.unauthorized', 'Unauthorized') }, { status: 401 })
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  // Check pgvector - uses existing DATABASE_URL
+  const databaseUrlSet = Boolean(process.env.DATABASE_URL?.trim())
+
+  // Check qdrant - would need QDRANT_URL
+  const qdrantUrlSet = Boolean(process.env.QDRANT_URL?.trim())
+  const qdrantApiKeySet = Boolean(process.env.QDRANT_API_KEY?.trim())
+
+  // Check chromadb - would need CHROMA_URL
+  const chromaUrlSet = Boolean(process.env.CHROMA_URL?.trim())
+
+  const drivers: DriverStatus[] = [
+    {
+      id: 'pgvector',
+      name: 'PostgreSQL (pgvector)',
+      configured: databaseUrlSet,
+      implemented: true,
+      envVars: [
+        {
+          name: 'DATABASE_URL',
+          set: databaseUrlSet,
+          hint: 'PostgreSQL connection string with pgvector extension',
+        },
+      ],
+    },
+    {
+      id: 'qdrant',
+      name: 'Qdrant',
+      configured: qdrantUrlSet,
+      implemented: false,
+      envVars: [
+        {
+          name: 'QDRANT_URL',
+          set: qdrantUrlSet,
+          hint: 'URL of your Qdrant server (e.g., http://localhost:6333)',
+        },
+        {
+          name: 'QDRANT_API_KEY',
+          set: qdrantApiKeySet,
+          hint: 'API key for Qdrant authentication (optional for local)',
+        },
+      ],
+    },
+    {
+      id: 'chromadb',
+      name: 'ChromaDB',
+      configured: chromaUrlSet,
+      implemented: false,
+      envVars: [
+        {
+          name: 'CHROMA_URL',
+          set: chromaUrlSet,
+          hint: 'URL of your ChromaDB server (e.g., http://localhost:8000)',
+        },
+      ],
+    },
+  ]
+
+  // Currently only pgvector is supported
+  const currentDriver: VectorDriverId = 'pgvector'
+  const configured = databaseUrlSet
+
+  const response: VectorStoreConfigResponse = {
+    currentDriver,
+    configured,
+    drivers,
+  }
+
+  return NextResponse.json(response)
+}

package/src/modules/search/backend/config/search/page.meta.ts

@@ -0,0 +1,22 @@
+import React from 'react'
+
+const searchIcon = React.createElement(
+  'svg',
+  { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' },
+  React.createElement('circle', { cx: 11, cy: 11, r: 8 }),
+  React.createElement('path', { d: 'm21 21-4.3-4.3' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['search.view'],
+  pageTitle: 'Search Settings',
+  pageTitleKey: 'search.config.nav.hybridSearch',
+  pageGroup: 'Configuration',
+  pageGroupKey: 'backend.nav.configuration',
+  pageOrder: 425,
+  icon: searchIcon,
+  breadcrumb: [
+    { label: 'Search Settings', labelKey: 'search.config.nav.hybridSearch' },
+  ],
+} as const

package/src/modules/search/backend/config/search/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { SearchSettingsPageClient } from '../../../frontend/components/SearchSettingsPageClient'
+
+export default async function SearchSettingsPage() {
+  return (
+    <Page>
+      <PageBody>
+        <SearchSettingsPageClient />
+      </PageBody>
+    </Page>
+  )
+}