@open-mercato/search 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

package/src/__tests__/pgvector-extension-availability.test.ts

@@ -0,0 +1,158 @@
+import { createPgVectorDriver, type PgPool } from '../vector/drivers/pgvector'
+import { VectorSearchStrategy } from '../strategies/vector.strategy'
+import { SearchService } from '../service'
+import type { IndexableRecord } from '../types'
+
+type QueryCall = { text: string; params?: unknown[] }
+
+function pgError(code: string, message: string): Error & { code: string } {
+  return Object.assign(new Error(message), { code })
+}
+
+function createPool(options: {
+  extensionInstalled?: boolean
+  extensionInstallable?: boolean
+  calls: QueryCall[]
+}): PgPool {
+  const { calls } = options
+  const run = async (text: string, params?: unknown[]) => {
+    calls.push({ text, params })
+    if (/pg_available_extensions/.test(text)) {
+      return {
+        rows: [{
+          installed: options.extensionInstalled ?? false,
+          installable: options.extensionInstallable ?? false,
+        }],
+      }
+    }
+    if (/CREATE EXTENSION IF NOT EXISTS vector/.test(text)) {
+      if (options.extensionInstalled || options.extensionInstallable) return { rows: [] }
+      throw pgError('58P01', 'extension "vector" is not available')
+    }
+    return { rows: [] }
+  }
+  return {
+    connect: async () => ({ query: run as PgPool['query'], release: () => {} }),
+    query: run as PgPool['query'],
+    end: async () => {},
+  }
+}
+
+describe('pgvector extension availability', () => {
+  it('reports the driver unhealthy when the extension cannot be installed', async () => {
+    const calls: QueryCall[] = []
+    const driver = createPgVectorDriver({ pool: createPool({ calls }) })
+
+    expect(await driver.isHealthy!()).toBe(false)
+    const status = await driver.getStatus!()
+    expect(status.available).toBe(false)
+    // Curated, not the raw Postgres message: the settings API surfaces this to the browser.
+    expect(status.reason).toBe('extension "vector" is not available on this PostgreSQL server')
+  })
+
+  it('probes the catalog once instead of running DDL for every record', async () => {
+    const calls: QueryCall[] = []
+    const driver = createPgVectorDriver({ pool: createPool({ calls }) })
+
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      expect(await driver.isHealthy!()).toBe(false)
+    }
+
+    const probes = calls.filter((call) => /pg_available_extensions/.test(call.text))
+    expect(probes).toHaveLength(1)
+    expect(calls.some((call) => /CREATE TABLE/.test(call.text))).toBe(false)
+  })
+
+  it('short-circuits ensureReady once the extension is known to be missing', async () => {
+    const calls: QueryCall[] = []
+    const driver = createPgVectorDriver({ pool: createPool({ calls }) })
+
+    await expect(driver.ensureReady()).rejects.toThrow(/vector/)
+    const afterFirst = calls.length
+    await expect(driver.ensureReady()).rejects.toThrow(/vector/)
+
+    expect(calls.length).toBe(afterFirst)
+  })
+
+  it('stays healthy when the extension is installable', async () => {
+    const calls: QueryCall[] = []
+    const driver = createPgVectorDriver({ pool: createPool({ calls, extensionInstallable: true }) })
+
+    expect(await driver.isHealthy!()).toBe(true)
+    await expect(driver.ensureReady()).resolves.toBeUndefined()
+  })
+
+  it('keeps the existing superuser-less degradation path', async () => {
+    const calls: QueryCall[] = []
+    const pool = createPool({ calls, extensionInstalled: true })
+    const originalQuery = pool.query
+    pool.query = (async (text: string, params?: unknown[]) => {
+      if (/CREATE EXTENSION IF NOT EXISTS vector/.test(text)) {
+        calls.push({ text, params })
+        throw pgError('42501', 'permission denied to create extension "vector"')
+      }
+      return originalQuery(text, params)
+    }) as PgPool['query']
+    pool.connect = async () => ({ query: pool.query as never, release: () => {} })
+
+    const driver = createPgVectorDriver({ pool })
+    await expect(driver.ensureReady()).resolves.toBeUndefined()
+    expect(await driver.isHealthy!()).toBe(true)
+  })
+})
+
+describe('vector strategy availability', () => {
+  const embeddingService = { available: true, createEmbedding: jest.fn() }
+
+  function createDriver(overrides: Partial<Record<string, unknown>> = {}) {
+    return {
+      id: 'pgvector' as const,
+      ensureReady: jest.fn().mockResolvedValue(undefined),
+      upsert: jest.fn().mockResolvedValue(undefined),
+      delete: jest.fn().mockResolvedValue(undefined),
+      query: jest.fn().mockResolvedValue([]),
+      getChecksum: jest.fn().mockResolvedValue(null),
+      ...overrides,
+    }
+  }
+
+  it('is unavailable when the store reports itself unhealthy', async () => {
+    const driver = createDriver({ isHealthy: jest.fn().mockResolvedValue(false) })
+    const strategy = new VectorSearchStrategy(embeddingService, driver)
+
+    expect(await strategy.isAvailable()).toBe(false)
+  })
+
+  it('stays available for drivers that expose no probe', async () => {
+    const strategy = new VectorSearchStrategy(embeddingService, createDriver())
+
+    expect(await strategy.isAvailable()).toBe(true)
+  })
+
+  it('never touches the store on delete when it is unhealthy', async () => {
+    const driver = createDriver({ isHealthy: jest.fn().mockResolvedValue(false) })
+    const strategy = new VectorSearchStrategy(embeddingService, driver)
+    const service = new SearchService({ strategies: [strategy] })
+
+    await expect(service.delete('customers:customer_deal', 'rec-1', 'tenant-1')).resolves.toBeUndefined()
+    expect(driver.ensureReady).not.toHaveBeenCalled()
+    expect(driver.delete).not.toHaveBeenCalled()
+  })
+
+  it('never touches the store on index when it is unhealthy', async () => {
+    const driver = createDriver({ isHealthy: jest.fn().mockResolvedValue(false) })
+    const strategy = new VectorSearchStrategy(embeddingService, driver)
+    const service = new SearchService({ strategies: [strategy] })
+    const record: IndexableRecord = {
+      entityId: 'customers:customer_deal',
+      recordId: 'rec-1',
+      tenantId: 'tenant-1',
+      fields: { name: 'Deal' },
+      text: 'Deal',
+    }
+
+    await expect(service.index(record)).resolves.toBeUndefined()
+    expect(driver.ensureReady).not.toHaveBeenCalled()
+    expect(driver.upsert).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/presenter-enricher.test.ts

@@ -3,6 +3,7 @@ import type { Kysely } from 'kysely'
 import type { SearchEntityConfig } from '../types'
 import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
 import type { SearchResult } from '@open-mercato/shared/modules/search'
+import type { EntityId } from '@open-mercato/shared/modules/entities'
 import { decryptIndexDocForSearch } from '@open-mercato/shared/lib/encryption/indexDoc'
 import { createPresenterEnricher } from '../lib/presenter-enricher'
 
@@ -142,4 +143,51 @@ describe('createPresenterEnricher', () => {
     expect(resolveLinks).toHaveBeenCalled()
     expect(enriched.links).toEqual([{ href: '/backend/customers/person-1', label: 'View', kind: 'primary' }])
   })
+
+  it('re-renders a result that already has a stored presenter when the entity has a config', async () => {
+    const doc = { id: 'rec-1', display_name: 'Ada' }
+    mockedDecryptIndexDocForSearch.mockResolvedValue(doc)
+
+    const formatResult = jest.fn(async () => ({ title: 'Fresh Title', badge: 'Fresh' }))
+    const config = createConfig({
+      entityId: 'customers:customer_person_profile' as EntityId,
+      enabled: true,
+      formatResult,
+    })
+    const entityConfigMap = new Map<EntityId, SearchEntityConfig>([[config.entityId, config]])
+    const db = createKyselyMock([
+      { entity_type: 'customers:customer_person_profile', entity_id: 'rec-1', doc },
+    ])
+
+    const enrich = createPresenterEnricher(db, entityConfigMap)
+    const results: SearchResult[] = [{
+      entityId: 'customers:customer_person_profile' as EntityId,
+      recordId: 'rec-1',
+      score: 1,
+      source: 'fulltext',
+      presenter: { title: 'Stale English Title' },
+      url: '/x',
+    }]
+
+    const [enriched] = await enrich(results, 'tenant-1', null)
+
+    expect(formatResult).toHaveBeenCalledTimes(1)
+    expect(enriched.presenter?.title).toBe('Fresh Title')
+  })
+
+  it('keeps the stored presenter when the entity has no config', async () => {
+    const db = createKyselyMock([])
+    const enrich = createPresenterEnricher(db, new Map(), undefined)
+    const results: SearchResult[] = [{
+      entityId: 'unknown:thing' as EntityId,
+      recordId: 'rec-9',
+      score: 1,
+      source: 'fulltext',
+      presenter: { title: 'Stored' },
+      url: '/y',
+    }]
+
+    const [enriched] = await enrich(results, 'tenant-1', null)
+    expect(enriched.presenter?.title).toBe('Stored')
+  })
 })

package/src/__tests__/presenter-locale.test.ts

@@ -0,0 +1,76 @@
+jest.mock('next/headers', () => ({
+  cookies: async () => ({ get: (name: string) => (name === 'locale' ? { value: 'pl' } : undefined) }),
+  headers: async () => ({ get: () => '' }),
+}))
+
+import type { Kysely } from 'kysely'
+import { createPresenterEnricher } from '../lib/presenter-enricher'
+import { registerModules, resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import type { Module } from '@open-mercato/shared/modules/registry'
+import type { SearchEntityConfig, SearchResult } from '../types'
+
+const DEMO_ENTITY_ID = 'demo:thing' as EntityId
+
+function makeDbReturning(rows: Array<{ entity_type: string; entity_id: string; doc: Record<string, unknown> }>) {
+  const chain = {
+    selectFrom: () => chain,
+    select: () => chain,
+    where: () => chain,
+    execute: async () => rows,
+  }
+  return chain as unknown as Kysely<Record<string, never>>
+}
+
+describe('request-time presenter localization', () => {
+  beforeAll(() => {
+    registerModules([
+      {
+        id: 'demo',
+        translations: {
+          en: { 'demo.search.badge': 'Person', 'demo.search.link.open': 'Open person' },
+          pl: { 'demo.search.badge': 'Osoba', 'demo.search.link.open': 'Otwórz osobę' },
+        },
+      },
+    ] satisfies Module[])
+  })
+
+  it('renders the presenter badge and link label in the request locale (pl)', async () => {
+    const { locale, t } = await resolveTranslations()
+    expect(locale).toBe('pl')
+    expect(t('demo.search.badge', 'Person')).toBe('Osoba')
+
+    const config: SearchEntityConfig = {
+      entityId: DEMO_ENTITY_ID,
+      enabled: true,
+      formatResult: async () => {
+        const { t: translate } = await resolveTranslations()
+        return { title: 'Ada', badge: translate('demo.search.badge', 'Person') }
+      },
+      resolveLinks: async () => {
+        const { t: translate } = await resolveTranslations()
+        return [{ href: '/x', label: translate('demo.search.link.open', 'Open person') }]
+      },
+    }
+
+    const entityConfigMap = new Map<EntityId, SearchEntityConfig>([[DEMO_ENTITY_ID, config]])
+    const db = makeDbReturning([
+      { entity_type: 'demo:thing', entity_id: 'rec-1', doc: { id: 'rec-1', display_name: 'Ada' } },
+    ])
+
+    const enrich = createPresenterEnricher(db, entityConfigMap)
+    const results: SearchResult[] = [{
+      entityId: DEMO_ENTITY_ID,
+      recordId: 'rec-1',
+      score: 1,
+      source: 'fulltext',
+      presenter: { title: 'Ada', badge: 'Person' },
+      links: [{ href: '/x', label: 'Open person', kind: 'primary' }],
+    }]
+
+    const [enriched] = await enrich(results, 'tenant-1', null)
+
+    expect(enriched.presenter?.badge).toBe('Osoba')
+    expect(enriched.links?.[0]?.label).toBe('Otwórz osobę')
+  })
+})

package/src/lib/presenter-enricher.ts

@@ -137,23 +137,22 @@ async function computePresenterAndLinks(
     queryEngine,
   }
 
-  // If search.ts config exists, use formatResult/buildSource for presenter
   if (config?.formatResult || config?.buildSource) {
-    if (config.buildSource) {
+    if (config.formatResult) {
       try {
-        const source = await config.buildSource(buildContext)
-        if (source?.presenter) presenter = source.presenter
-        if (source?.links) links = source.links
+        presenter = (await config.formatResult(buildContext)) ?? null
       } catch (err) {
-        logWarning('buildSource failed', { entityId, recordId, err })
+        logWarning('formatResult failed', { entityId, recordId, err })
       }
     }
 
-    if (!presenter && config.formatResult) {
+    if (!presenter && config.buildSource) {
       try {
-        presenter = (await config.formatResult(buildContext)) ?? null
+        const source = await config.buildSource(buildContext)
+        if (source?.presenter) presenter = source.presenter
+        if (source?.links) links = source.links
       } catch (err) {
-        logWarning('formatResult failed', { entityId, recordId, err })
+        logWarning('buildSource failed', { entityId, recordId, err })
       }
     }
   }
@@ -203,8 +202,10 @@ export function createPresenterEnricher(
   encryptionService?: TenantDataEncryptionService | null,
 ): PresenterEnricherFn {
   return async (results, tenantId, organizationId) => {
-    // Find results missing presenter OR with encrypted presenter
-    const missingResults = results.filter(needsSearchResultEnrichment)
+    const shouldEnrich = (result: SearchResult): boolean =>
+      needsSearchResultEnrichment(result) || entityConfigMap.has(result.entityId as EntityId)
+
+    const missingResults = results.filter(shouldEnrich)
     if (missingResults.length === 0) return results
 
     // Group by entity type for config lookup
@@ -285,16 +286,15 @@ export function createPresenterEnricher(
 
     // Enrich results with computed presenter, URL, and links
     return results.map((result) => {
-      if (!needsSearchResultEnrichment(result)) return result
+      if (!shouldEnrich(result)) return result
       const key = `${result.entityId}:${result.recordId}`
       const enriched = enrichmentMap.get(key)
       if (!enriched) return result
-      const hasExistingLinks = Array.isArray(result.links) && result.links.length > 0
       return {
         ...result,
         presenter: enriched.presenter ?? result.presenter,
         url: result.url ?? enriched.url,
-        links: hasExistingLinks ? result.links : (enriched.links ?? result.links),
+        links: enriched.links ?? result.links,
       }
     })
   }

package/src/modules/search/README.md

@@ -460,7 +460,10 @@ yarn mercato search worker fulltext-indexing --concurrency=5
 | `OM_SEARCH_ENABLE_PARTIAL` | Prefix/partial expansion for `search_tokens` (indexing "john" stores hashes for `joh`,`john`). Token/Postgres only — Meilisearch unaffected. Increases `search_tokens` size ~5–6× | `true` |
 | `OM_SEARCH_HASH_ALGO` | Hash algorithm for `search_tokens` tokens (`sha256`/`sha1`/`md5`); token strategy only | `sha256` |
 | `OM_SEARCH_STORE_RAW_TOKENS` | Store plaintext token alongside the hash in `search_tokens` — **security-sensitive** (retains plaintext of otherwise-hashed values); token strategy only | `false` |
-| `OM_SEARCH_FIELD_BLOCKLIST` | Comma-separated extra field names excluded from tokenization (merged with built-in `password,token,secret,hash`); token strategy only | - |
+| `OM_SEARCH_FIELD_BLOCKLIST` | Comma-separated field-name substrings excluded from per-field tokens and aggregate `search_text` (merged with built-in `password,token,secret,hash`); prefix an entry with `entityType@` to scope it to one entity and reindex affected entities after changes; token strategy only | - |
+| `OM_SEARCH_MAX_FIELD_CHARS` | Maximum input characters considered per field value before splitting or prefix expansion; `0` disables the limit; token strategy only | `20000` |
+| `OM_SEARCH_MAX_TOKENS_PER_FIELD` | Maximum distinct token rows across all values of one field; `0` disables the limit; token strategy only | `5000` |
+| `OM_SEARCH_MAX_TOKENS_PER_RECORD` | Maximum token rows across all fields in one indexed record; `0` disables the limit; token strategy only | `20000` |
 | `SEARCH_EXCLUDE_ENCRYPTED_FIELDS` | Exclude encrypted fields from Meilisearch indexing | `false` |
 | `QUEUE_STRATEGY` | Queue strategy (`local` or `async`) | `local` |
 | `REDIS_URL` | Redis connection URL for async queues | - |

package/src/modules/search/ai-tools.ts

@@ -4,7 +4,7 @@ import type {
   SearchResult,
   SearchStrategyId,
 } from '@open-mercato/shared/modules/search'
-import { hasAllFeatures } from '@open-mercato/shared/security/features'
+import { authorizeFeatures } from '@open-mercato/shared/security/featurePolicy'
 
 /**
  * AI Tools definitions for the Search module.
@@ -96,7 +96,10 @@ function authorizeEntityAccess(entityType: string, ctx: ToolContext): SearchEnti
     )
   }
 
-  if (!hasAllFeatures(ctx.userFeatures, required)) {
+  if (!authorizeFeatures(required, {
+    grantedFeatures: ctx.userFeatures,
+    unrestricted: ctx.isSuperAdmin,
+  })) {
     throw new SearchToolAuthorizationError(
       `[internal] Insufficient permissions for entity "${entityType}". Required: ${required.join(', ')}`
     )

package/src/modules/search/api/__tests__/global-search.routes.test.ts

@@ -0,0 +1,167 @@
+const mockGetAuthFromRequest = jest.fn()
+jest.mock('@open-mercato/shared/lib/auth/server', () => ({
+  getAuthFromRequest: (...args: unknown[]) => mockGetAuthFromRequest(...args),
+}))
+
+const mockCreateRequestContainer = jest.fn()
+jest.mock('@open-mercato/shared/lib/di/container', () => ({
+  createRequestContainer: (...args: unknown[]) => mockCreateRequestContainer(...args),
+}))
+
+const mockResolveOrganizationScopeForRequest = jest.fn()
+jest.mock('@open-mercato/core/modules/directory/utils/organizationScope', () => ({
+  resolveOrganizationScopeForRequest: (...args: unknown[]) => mockResolveOrganizationScopeForRequest(...args),
+}))
+
+jest.mock('../../lib/embedding-config', () => ({
+  resolveEmbeddingConfig: jest.fn().mockResolvedValue(null),
+}))
+
+jest.mock('../../lib/global-search-config', () => ({
+  resolveGlobalSearchStrategies: jest.fn().mockResolvedValue(['fulltext', 'vector', 'tokens']),
+}))
+
+jest.mock('next/headers', () => ({
+  cookies: async () => ({ get: () => undefined }),
+  headers: async () => ({ get: (name: string) => (name === 'accept-language' ? 'pl-PL' : null) }),
+}))
+
+import type { Kysely } from 'kysely'
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import type { Module } from '@open-mercato/shared/modules/registry'
+import type { SearchEntityConfig, SearchResult, SearchStrategy, SearchStrategyId } from '../../../../types'
+import { registerModules, resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { SearchService } from '../../../../service'
+import { createPresenterEnricher } from '../../../../lib/presenter-enricher'
+import { GET } from '../search/global/route'
+
+const DEMO_ENTITY_ID = 'demo:thing' as EntityId
+
+function createDatabase(rows: Array<{ entity_type: string; entity_id: string; doc: Record<string, unknown> }>) {
+  const chain = {
+    selectFrom: () => chain,
+    select: () => chain,
+    where: () => chain,
+    execute: async () => rows,
+  }
+  return chain as unknown as Kysely<Record<string, never>>
+}
+
+function createStrategy(source: SearchStrategyId, recordId: string): SearchStrategy {
+  const result: SearchResult = {
+    entityId: DEMO_ENTITY_ID,
+    recordId,
+    organizationId: 'org-1',
+    score: 1,
+    source,
+    presenter: { title: recordId, badge: 'Person' },
+    links: [{ href: `/backend/demo/${recordId}`, label: 'Open person', kind: 'primary' }],
+  }
+
+  return {
+    id: source,
+    name: source,
+    priority: 10,
+    isAvailable: async () => true,
+    ensureReady: async () => undefined,
+    search: async () => [result],
+    index: async () => undefined,
+    delete: async () => undefined,
+  }
+}
+
+describe('GET /api/search/search/global presenter localization', () => {
+  beforeAll(() => {
+    registerModules([
+      {
+        id: 'demo',
+        translations: {
+          en: {
+            'demo.search.badge': 'Person',
+            'demo.search.link.open': 'Open person',
+          },
+          pl: {
+            'demo.search.badge': 'Osoba',
+            'demo.search.link.open': 'Otwórz osobę',
+          },
+        },
+      },
+    ] satisfies Module[])
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockGetAuthFromRequest.mockResolvedValue({
+      tenantId: 'tenant-1',
+      orgId: 'org-1',
+      sub: 'user-1',
+      isSuperAdmin: false,
+    })
+    mockResolveOrganizationScopeForRequest.mockResolvedValue({
+      selectedId: 'org-1',
+      filterIds: ['org-1'],
+      allowedIds: ['org-1'],
+      tenantId: 'tenant-1',
+    })
+  })
+
+  it('replaces frozen presenters and links for fulltext, vector, and tokens using Accept-Language', async () => {
+    const rows = ['fulltext-record', 'vector-record', 'tokens-record'].map((recordId) => ({
+      entity_type: DEMO_ENTITY_ID,
+      entity_id: recordId,
+      doc: { id: recordId, title: recordId },
+    }))
+    const config: SearchEntityConfig = {
+      entityId: DEMO_ENTITY_ID,
+      enabled: true,
+      formatResult: async (context) => {
+        const { t } = await resolveTranslations()
+        return {
+          title: String(context.record.title),
+          badge: t('demo.search.badge', 'Person'),
+        }
+      },
+      resolveLinks: async (context) => {
+        const { t } = await resolveTranslations()
+        return [{
+          href: `/backend/demo/${String(context.record.id)}`,
+          label: t('demo.search.link.open', 'Open person'),
+          kind: 'primary',
+        }]
+      },
+    }
+    const configMap = new Map<EntityId, SearchEntityConfig>([[DEMO_ENTITY_ID, config]])
+    const presenterEnricher = createPresenterEnricher(createDatabase(rows), configMap)
+    const searchService = new SearchService({
+      strategies: [
+        createStrategy('fulltext', 'fulltext-record'),
+        createStrategy('vector', 'vector-record'),
+        createStrategy('tokens', 'tokens-record'),
+      ],
+      defaultStrategies: ['fulltext', 'vector', 'tokens'],
+      presenterEnricher,
+    })
+    const container = {
+      resolve: jest.fn((name: string) => (name === 'searchService' ? searchService : undefined)),
+      dispose: jest.fn().mockResolvedValue(undefined),
+    }
+    mockCreateRequestContainer.mockResolvedValue(container)
+
+    const request = new Request('http://localhost/api/search/search/global?q=person', {
+      headers: { 'accept-language': 'pl-PL' },
+    })
+    const response = await GET(request)
+    const body = await response.json() as {
+      results: SearchResult[]
+      strategiesUsed: SearchStrategyId[]
+    }
+
+    expect(response.status).toBe(200)
+    expect(body.results).toHaveLength(3)
+    expect(body.strategiesUsed).toEqual(expect.arrayContaining(['fulltext', 'vector', 'tokens']))
+    for (const result of body.results) {
+      expect(result.presenter?.badge).toBe('Osoba')
+      expect(result.links?.[0]?.label).toBe('Otwórz osobę')
+    }
+  })
+})

package/src/modules/search/api/openapi.ts

@@ -246,6 +246,8 @@ export const vectorDriverStatusSchema = z.object({
   name: z.string(),
   configured: z.boolean(),
   implemented: z.boolean(),
+  available: z.boolean().nullable(),
+  unavailableReason: z.string().nullable(),
   envVars: z.array(vectorDriverEnvVarSchema),
 })
 

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

@@ -1,7 +1,9 @@
 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 { VectorDriverId } from '@open-mercato/shared/modules/vector'
+import type { VectorDriver } from '../../../../../vector'
 import { vectorStoreSettingsOpenApi } from '../../openapi'
 
 export const metadata = {
@@ -13,6 +15,9 @@ type DriverStatus = {
   name: string
   configured: boolean
   implemented: boolean
+  /** Runtime reachability of the store itself; `null` when the driver exposes no probe. */
+  available: boolean | null
+  unavailableReason: string | null
   envVars: {
     name: string
     set: boolean
@@ -26,6 +31,24 @@ type VectorStoreConfigResponse = {
   drivers: DriverStatus[]
 }
 
+async function probeDriverStatus(
+  container: { resolve: <T = unknown>(name: string) => T },
+  driverId: VectorDriverId,
+): Promise<{ available: boolean | null; unavailableReason: string | null }> {
+  try {
+    const drivers = container.resolve<VectorDriver[]>('vectorDrivers')
+    const driver = drivers.find((entry) => entry.id === driverId)
+    if (!driver?.getStatus) return { available: null, unavailableReason: null }
+    const status = await driver.getStatus()
+    return {
+      available: status.available,
+      unavailableReason: status.available ? null : status.reason ?? null,
+    }
+  } catch {
+    return { available: null, unavailableReason: null }
+  }
+}
+
 const unauthorized = async () => {
   const { t } = await resolveTranslations()
   return NextResponse.json({ error: t('api.errors.unauthorized', 'Unauthorized') }, { status: 401 })
@@ -45,12 +68,28 @@ export async function GET(req: Request) {
   // Check chromadb - would need CHROMA_URL
   const chromaUrlSet = Boolean(process.env.CHROMA_URL?.trim())
 
+  let pgvectorStatus: { available: boolean | null; unavailableReason: string | null } = {
+    available: null,
+    unavailableReason: null,
+  }
+  if (databaseUrlSet) {
+    const container = await createRequestContainer()
+    try {
+      pgvectorStatus = await probeDriverStatus(container, 'pgvector')
+    } finally {
+      const disposable = container as { dispose?: () => Promise<unknown> }
+      if (typeof disposable.dispose === 'function') await disposable.dispose()
+    }
+  }
+
   const drivers: DriverStatus[] = [
     {
       id: 'pgvector',
       name: 'PostgreSQL (pgvector)',
       configured: databaseUrlSet,
       implemented: true,
+      available: pgvectorStatus.available,
+      unavailableReason: pgvectorStatus.unavailableReason,
       envVars: [
         {
           name: 'DATABASE_URL',
@@ -64,6 +103,8 @@ export async function GET(req: Request) {
       name: 'Qdrant',
       configured: qdrantUrlSet,
       implemented: false,
+      available: null,
+      unavailableReason: null,
       envVars: [
         {
           name: 'QDRANT_URL',
@@ -82,6 +123,8 @@ export async function GET(req: Request) {
       name: 'ChromaDB',
       configured: chromaUrlSet,
       implemented: false,
+      available: null,
+      unavailableReason: null,
       envVars: [
         {
           name: 'CHROMA_URL',

package/src/modules/search/events.ts

@@ -0,0 +1,10 @@
+import { createModuleEvents } from '@open-mercato/shared/modules/events'
+
+const events = [
+  { id: 'search.index_record', label: 'Index Record', category: 'lifecycle' },
+] as const
+
+export const eventsConfig = createModuleEvents({ moduleId: 'search', events })
+export const emitSearchEvent = eventsConfig.emit
+export type SearchEventId = typeof events[number]['id']
+export default eventsConfig