@open-mercato/shared 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

package/src/lib/query/ciphertext-search-warning.ts

@@ -1,95 +0,0 @@
-import { createLogger } from '../logger'
-import type { EntityId } from '../../modules/entities'
-
-const logger = createLogger('shared').child({ component: 'query' })
-
-/**
- * Minimal slice of `TenantDataEncryptionService` needed to decide whether a
- * text filter targets an encrypted column.
- */
-export type CiphertextWarningEncryptionService = {
-  getEncryptedFieldNames?: (
-    entityId: EntityId,
-    tenantId?: string | null,
-    organizationId?: string | null,
-  ) => Promise<readonly string[]>
-  isEnabled?: () => boolean
-} | null | undefined
-
-export type CiphertextLikeFallbackReason = 'no-indexable-tokens' | 'no-search-tokens' | 'search-disabled'
-
-// One warning per entity/tenant/field per process — the fallback repeats on
-// every request, and an operator only needs to learn about it once.
-const WARN_CACHE_CAP = 5000
-const warned = new Set<string>()
-
-const warnKey = (entity: string, tenantId: string | null, field: string): string =>
-  `${entity}|${tenantId ?? 'null'}|${field}`
-
-export const normalizeColumnName = (value: string): string =>
-  value.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase()
-
-/** Test seam: the warn-once cache is process-global by design. */
-export function resetCiphertextLikeWarnCache(): void {
-  warned.clear()
-}
-
-/**
- * Warn when a `like`/`ilike` filter is about to run against a column that an
- * encryption map covers while the token index is unavailable.
- *
- * Without this the query degrades silently: the predicate compares a plaintext
- * pattern against ciphertext, matches nothing, and the endpoint returns an
- * empty page that is indistinguishable from a genuine no-result. Issue #2990.
- *
- * Never throws and never blocks the query — a failure here is logged at debug
- * level and the caller proceeds unchanged.
- */
-export async function warnOnCiphertextLikeFallback(params: {
-  entity: string
-  fields: readonly string[]
-  tenantId: string | null
-  reason: CiphertextLikeFallbackReason
-  service: CiphertextWarningEncryptionService
-}): Promise<void> {
-  const { entity, tenantId, reason, service } = params
-  if (!service || service.isEnabled?.() === false) return
-  if (typeof service.getEncryptedFieldNames !== 'function') return
-
-  const candidates = params.fields
-    .filter((field) => typeof field === 'string' && !field.startsWith('cf:'))
-    .map((field) => normalizeColumnName(field))
-    .filter((field, index, all) => field.length > 0 && all.indexOf(field) === index)
-    .filter((field) => !warned.has(warnKey(entity, tenantId, field)))
-  if (!candidates.length) return
-
-  try {
-    // `organizationId: null` resolves the global map plus every per-organization
-    // override, so a field encrypted for any organization is reported.
-    const encrypted = new Set(
-      (await service.getEncryptedFieldNames(entity, tenantId, null)).map((field) =>
-        normalizeColumnName(String(field)),
-      ),
-    )
-    for (const field of candidates) {
-      if (!encrypted.has(field)) continue
-      if (warned.size >= WARN_CACHE_CAP) warned.clear()
-      warned.add(warnKey(entity, tenantId, field))
-      logger.warn('Text search filter cannot match an encrypted column', {
-        entity,
-        field,
-        reason,
-        hint: reason === 'search-disabled'
-          ? 'OM_SEARCH_ENABLED is off, so the filter runs as ILIKE against ciphertext and matches nothing.'
-          : reason === 'no-indexable-tokens'
-            ? 'The filter value produced no search tokens, so it runs as ILIKE against ciphertext and matches nothing. Use at least OM_SEARCH_MIN_LEN indexable characters, or filter on the deterministic hash column.'
-            : 'No search_tokens exist for this entity and scope, so the filter runs as ILIKE against ciphertext and matches nothing. Index the entity through query_index and reindex, or filter on the deterministic hash column.',
-      })
-    }
-  } catch (err) {
-    logger.debug('Ciphertext search warning check failed', {
-      entity,
-      err: err instanceof Error ? err.message : String(err),
-    })
-  }
-}

package/src/lib/search/__tests__/availability.test.ts

@@ -1,211 +0,0 @@
-import {
-  clearSearchTokenPresenceCache,
-  createSearchTokenAvailability,
-  hasSearchFilter,
-  isSearchFilterOp,
-  type OrganizationScope,
-  type SearchTokenProbeQueryBuilder,
-} from '../availability'
-
-beforeEach(() => {
-  clearSearchTokenPresenceCache()
-  delete process.env.OM_SEARCH_TOKEN_PRESENCE_CACHE_MS
-})
-
-afterAll(() => {
-  delete process.env.OM_SEARCH_TOKEN_PRESENCE_CACHE_MS
-})
-
-type ProbeLog = { table: string; wheres: unknown[][] }
-
-function createFakeDb(options?: { rowsByTable?: Record<string, object | undefined>; failTables?: string[] }) {
-  const probes: ProbeLog[] = []
-  const db = {
-    selectFrom(table: string) {
-      const log: ProbeLog = { table, wheres: [] }
-      probes.push(log)
-      const chain = {
-        select: () => chain,
-        where: (...args: unknown[]) => {
-          log.wheres.push(args)
-          return chain
-        },
-        limit: () => chain,
-        executeTakeFirst: async () => {
-          if (options?.failTables?.includes(table)) throw new Error(`probe failed for ${table}`)
-          return options?.rowsByTable?.[table]
-        },
-      }
-      return chain
-    },
-  }
-  return { db, probes }
-}
-
-function buildAvailability(options?: Parameters<typeof createFakeDb>[0] & { enabled?: boolean }) {
-  const { db, probes } = createFakeDb(options)
-  const logDebug = jest.fn()
-  const applyOrganizationScope = jest.fn((query: SearchTokenProbeQueryBuilder) => query)
-  const availability = createSearchTokenAvailability({
-    getDb: () => db,
-    getConfig: () => ({ enabled: options?.enabled ?? true }),
-    applyOrganizationScope,
-    logDebug,
-  })
-  return { availability, probes, logDebug, applyOrganizationScope }
-}
-
-const countProbes = (probes: ProbeLog[], table: string) => probes.filter((probe) => probe.table === table).length
-
-describe('hasSearchFilter / isSearchFilterOp', () => {
-  test('recognizes like and ilike only', () => {
-    expect(isSearchFilterOp('like')).toBe(true)
-    expect(isSearchFilterOp('ilike')).toBe(true)
-    expect(isSearchFilterOp('eq')).toBe(false)
-    expect(hasSearchFilter([{ op: 'eq' }, { op: 'in' }])).toBe(false)
-    expect(hasSearchFilter([{ op: 'eq' }, { op: 'ilike' }])).toBe(true)
-    expect(hasSearchFilter([])).toBe(false)
-  })
-})
-
-describe('createSearchTokenAvailability', () => {
-  test('staticEnabled probes the table once per instance and rechecks config each call', async () => {
-    const { availability, probes } = buildAvailability({
-      rowsByTable: { 'information_schema.tables': { one: 1 } },
-    })
-    await expect(availability.staticEnabled()).resolves.toBe(true)
-    await expect(availability.staticEnabled()).resolves.toBe(true)
-    expect(countProbes(probes, 'information_schema.tables')).toBe(1)
-  })
-
-  test('staticEnabled short-circuits on disabled config without probing', async () => {
-    const { availability, probes } = buildAvailability({ enabled: false })
-    await expect(availability.staticEnabled()).resolves.toBe(false)
-    expect(probes).toHaveLength(0)
-  })
-
-  test('staticEnabled retries after a failed table probe instead of caching the rejection', async () => {
-    const options = { rowsByTable: { 'information_schema.tables': { one: 1 } }, failTables: ['information_schema.tables'] }
-    const { availability, probes } = buildAvailability(options)
-    await expect(availability.staticEnabled()).rejects.toThrow('probe failed')
-    options.failTables.length = 0
-    await expect(availability.staticEnabled()).resolves.toBe(true)
-    expect(countProbes(probes, 'information_schema.tables')).toBe(2)
-  })
-
-  test('hasTokens memoizes per (entity, tenant, org) key', async () => {
-    const { availability, probes } = buildAvailability({ rowsByTable: { search_tokens: { one: 1 } } })
-    const orgScope: OrganizationScope = { ids: ['org1'], includeNull: false }
-
-    await expect(availability.hasTokens('example:todo', 't1', orgScope)).resolves.toBe(true)
-    await expect(availability.hasTokens('example:todo', 't1', orgScope)).resolves.toBe(true)
-    expect(countProbes(probes, 'search_tokens')).toBe(1)
-
-    await availability.hasTokens('example:todo', 't2', orgScope)
-    await availability.hasTokens('example:other', 't1', orgScope)
-    await availability.hasTokens('example:todo', 't1', { ids: ['org2'], includeNull: false })
-    expect(countProbes(probes, 'search_tokens')).toBe(4)
-  })
-
-  test('hasTokens applies the injected organization scope', async () => {
-    const { availability, applyOrganizationScope } = buildAvailability()
-    const orgScope: OrganizationScope = { ids: ['org1'], includeNull: true }
-    await availability.hasTokens('example:todo', 't1', orgScope)
-    expect(applyOrganizationScope).toHaveBeenCalledWith(expect.anything(), 'search_tokens.organization_id', orgScope)
-
-    applyOrganizationScope.mockClear()
-    await availability.hasTokens('example:todo', 't1', null)
-    expect(applyOrganizationScope).not.toHaveBeenCalled()
-  })
-
-  test('hasTokens resolves false and logs search:has-tokens-error on probe failure', async () => {
-    const { availability, logDebug } = buildAvailability({ failTables: ['search_tokens'] })
-    await expect(availability.hasTokens('example:todo', 't1', null)).resolves.toBe(false)
-    expect(logDebug).toHaveBeenCalledWith('search:has-tokens-error', expect.objectContaining({
-      entity: 'example:todo',
-      tenantId: 't1',
-      error: expect.stringContaining('probe failed'),
-    }))
-  })
-
-  test('anySourceHasTokens stops at the first source with tokens and logs each probed source', async () => {
-    const { availability, probes, logDebug } = buildAvailability({ rowsByTable: { search_tokens: { one: 1 } } })
-    const result = await availability.anySourceHasTokens(
-      [
-        { entity: 'example:todo', recordIdColumn: 'b.id' },
-        { entity: 'example:other', recordIdColumn: 'cfs0.entity_id' },
-      ],
-      't1',
-      null,
-    )
-    expect(result).toBe(true)
-    expect(countProbes(probes, 'search_tokens')).toBe(1)
-    expect(logDebug).toHaveBeenCalledTimes(1)
-    expect(logDebug).toHaveBeenCalledWith('search:source-has-tokens', expect.objectContaining({
-      entity: 'example:todo',
-      recordIdColumn: 'b.id',
-      hasTokens: true,
-    }))
-  })
-
-  test('process-level TTL cache serves later resolver instances without re-probing', async () => {
-    const first = buildAvailability({ rowsByTable: { search_tokens: { one: 1 } } })
-    await expect(first.availability.hasTokens('example:todo', 't1', null)).resolves.toBe(true)
-    expect(countProbes(first.probes, 'search_tokens')).toBe(1)
-
-    const second = buildAvailability()
-    await expect(second.availability.hasTokens('example:todo', 't1', null)).resolves.toBe(true)
-    expect(countProbes(second.probes, 'search_tokens')).toBe(0)
-  })
-
-  test('process-level TTL cache expires and can be disabled', async () => {
-    const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(1_000_000)
-    try {
-      const first = buildAvailability()
-      await first.availability.hasTokens('example:todo', 't1', null)
-
-      nowSpy.mockReturnValue(1_000_000 + 30_001)
-      const second = buildAvailability()
-      await second.availability.hasTokens('example:todo', 't1', null)
-      expect(countProbes(second.probes, 'search_tokens')).toBe(1)
-
-      process.env.OM_SEARCH_TOKEN_PRESENCE_CACHE_MS = '0'
-      const third = buildAvailability()
-      await third.availability.hasTokens('example:todo', 't1', null)
-      expect(countProbes(third.probes, 'search_tokens')).toBe(1)
-    } finally {
-      nowSpy.mockRestore()
-    }
-  })
-
-  test('error-driven false results are not TTL-cached', async () => {
-    const first = buildAvailability({ failTables: ['search_tokens'] })
-    await expect(first.availability.hasTokens('example:todo', 't1', null)).resolves.toBe(false)
-
-    const second = buildAvailability({ rowsByTable: { search_tokens: { one: 1 } } })
-    await expect(second.availability.hasTokens('example:todo', 't1', null)).resolves.toBe(true)
-    expect(countProbes(second.probes, 'search_tokens')).toBe(1)
-  })
-
-  test('probe uses index-friendly tenant predicates instead of IS NOT DISTINCT FROM', async () => {
-    const { availability, probes } = buildAvailability()
-    await availability.hasTokens('example:todo', 't1', null)
-    await availability.hasTokens('example:todo', null, null)
-    const [scoped, global] = probes.filter((probe) => probe.table === 'search_tokens')
-    expect(scoped.wheres).toContainEqual(['tenant_id', '=', 't1'])
-    expect(global.wheres).toContainEqual(['tenant_id', 'is', null])
-  })
-
-  test('anySourceHasTokens sweeps all sources when none has tokens, sharing the memo with hasTokens', async () => {
-    const { availability, probes } = buildAvailability()
-    const sources = [
-      { entity: 'example:todo', recordIdColumn: 'b.id' },
-      { entity: 'example:other', recordIdColumn: 'cfs0.entity_id' },
-    ]
-    await expect(availability.anySourceHasTokens(sources, 't1', null)).resolves.toBe(false)
-    expect(countProbes(probes, 'search_tokens')).toBe(2)
-
-    await expect(availability.hasTokens('example:todo', 't1', null)).resolves.toBe(false)
-    expect(countProbes(probes, 'search_tokens')).toBe(2)
-  })
-})

package/src/lib/search/__tests__/tokenLookup.test.ts

@@ -1,206 +0,0 @@
-import {
-  findEntityIdsBySearchTokens,
-  findEntityIdsBySearchTokensCompat,
-} from '../tokenLookup'
-import { resolveSearchConfig } from '../config'
-import { tokenizeText } from '../tokenize'
-
-type KyselyCall = {
-  method: string
-  args: unknown[]
-}
-
-function createKyselyMock(rows: Array<{ entity_id: unknown }>) {
-  const calls: KyselyCall[] = []
-  const tableNameRef: { value: string | null } = { value: null }
-  const builder: Record<string, unknown> = {}
-  const passthrough = (method: string) =>
-    (...args: unknown[]) => {
-      calls.push({ method, args })
-      return builder
-    }
-  builder.select = passthrough('select')
-  builder.where = passthrough('where')
-  builder.groupBy = passthrough('groupBy')
-  builder.having = passthrough('having')
-  builder.execute = jest.fn(async () => rows)
-
-  const db = {
-    selectFrom: (table: string) => {
-      tableNameRef.value = table
-      return builder
-    },
-  }
-  return { db: db as never, calls, tableNameRef, builder }
-}
-
-function compileSql(raw: unknown): string {
-  if (raw && typeof raw === 'object' && 'toOperationNode' in raw && typeof raw.toOperationNode === 'function') {
-    const node = raw.toOperationNode() as { sqlFragments?: unknown }
-    return Array.isArray(node.sqlFragments) ? node.sqlFragments.join(' ? ') : ''
-  }
-  if (raw && typeof raw === 'object' && 'sql' in raw) return String(raw.sql)
-  return String(raw)
-}
-
-function rawWhereFragments(calls: KyselyCall[]): string[] {
-  return calls
-    .filter((call) => call.method === 'where' && call.args.length === 1)
-    .map((call) => compileSql(call.args[0]))
-}
-
-describe('findEntityIdsBySearchTokens', () => {
-  const baseInput = {
-    entityType: 'customers:customer_entity',
-    query: 'Hello',
-  }
-
-  it('skips the lookup for a blank query', async () => {
-    const { db, builder } = createKyselyMock([])
-    const result = await findEntityIdsBySearchTokens({ ...baseInput, db, query: '   ' })
-    expect(result).toEqual({ matched: false, reason: 'empty-query' })
-    expect(builder.execute).not.toHaveBeenCalled()
-  })
-
-  it('skips the lookup when token search is disabled', async () => {
-    const { db, builder } = createKyselyMock([])
-    const result = await findEntityIdsBySearchTokens({
-      ...baseInput,
-      db,
-      config: { ...resolveSearchConfig(), enabled: false },
-    })
-    expect(result).toEqual({ matched: false, reason: 'search-disabled' })
-    expect(builder.execute).not.toHaveBeenCalled()
-  })
-
-  it('skips the lookup when the query yields no indexable tokens', async () => {
-    const { db, builder } = createKyselyMock([])
-    const result = await findEntityIdsBySearchTokens({ ...baseInput, db, query: '!' })
-    expect(result).toEqual({ matched: false, reason: 'no-tokens' })
-    expect(builder.execute).not.toHaveBeenCalled()
-  })
-
-  it('requires every query token to be present on the record', async () => {
-    const { db, calls } = createKyselyMock([{ entity_id: 'a' }])
-    await findEntityIdsBySearchTokens({ ...baseInput, db, query: 'ada lovelace' })
-
-    const expectedHashes = tokenizeText('ada lovelace', resolveSearchConfig()).hashes
-    const hashFilter = calls.find((call) => call.args[0] === 'token_hash' && call.args[1] === 'in')
-    expect(hashFilter?.args[2]).toEqual(expectedHashes)
-
-    const having = calls.find((call) => call.method === 'having')
-    expect(compileSql(having?.args[0])).toContain('count(distinct token_hash) >=')
-  })
-
-  it('returns the matched ids and drops non-string rows', async () => {
-    const { db, tableNameRef } = createKyselyMock([
-      { entity_id: 'id-1' },
-      { entity_id: null },
-      { entity_id: 42 },
-      { entity_id: '' },
-      { entity_id: 'id-2' },
-    ])
-    const result = await findEntityIdsBySearchTokens({ ...baseInput, db })
-    expect(result).toEqual({ matched: true, ids: ['id-1', 'id-2'] })
-    expect(tableNameRef.value).toBe('search_tokens')
-  })
-
-  it('reports an empty match instead of a skip when nothing matched', async () => {
-    const { db } = createKyselyMock([])
-    const result = await findEntityIdsBySearchTokens({ ...baseInput, db })
-    expect(result).toEqual({ matched: true, ids: [] })
-  })
-
-  it('narrows a single field with equality and multiple fields with IN', async () => {
-    const single = createKyselyMock([])
-    await findEntityIdsBySearchTokens({ ...baseInput, db: single.db, fields: ['name'] })
-    expect(single.calls).toContainEqual({ method: 'where', args: ['field', '=', 'name'] })
-
-    const multi = createKyselyMock([])
-    await findEntityIdsBySearchTokens({ ...baseInput, db: multi.db, fields: ['name', 'email'] })
-    expect(multi.calls).toContainEqual({ method: 'where', args: ['field', 'in', ['name', 'email']] })
-  })
-
-  it('omits the field predicate when no fields are supplied', async () => {
-    const { db, calls } = createKyselyMock([])
-    await findEntityIdsBySearchTokens({ ...baseInput, db, fields: [] })
-    expect(calls.some((call) => call.args[0] === 'field')).toBe(false)
-  })
-
-  it('omits tenant and organization predicates when the scope is absent', async () => {
-    const { db, calls } = createKyselyMock([])
-    await findEntityIdsBySearchTokens({ ...baseInput, db })
-    expect(rawWhereFragments(calls)).toEqual([])
-    expect(calls.some((call) => call.args[0] === 'organization_id')).toBe(false)
-  })
-
-  it('emits a null-safe tenant predicate for an explicit null tenant', async () => {
-    const { db, calls } = createKyselyMock([])
-    await findEntityIdsBySearchTokens({ ...baseInput, db, scope: { tenantId: null } })
-    expect(rawWhereFragments(calls).some((s) => s.includes('tenant_id is not distinct from'))).toBe(true)
-  })
-
-  it('emits a null-safe organization predicate for an explicit null organization', async () => {
-    const { db, calls } = createKyselyMock([])
-    await findEntityIdsBySearchTokens({ ...baseInput, db, scope: { organizationId: null } })
-    expect(rawWhereFragments(calls).some((s) => s.includes('organization_id is not distinct from'))).toBe(true)
-  })
-
-  it('prefers a concrete organization over the visible-organization list', async () => {
-    const { db, calls } = createKyselyMock([])
-    await findEntityIdsBySearchTokens({
-      ...baseInput,
-      db,
-      scope: { organizationId: 'org-1', organizationIds: ['org-1', 'org-2'] },
-    })
-    expect(calls).toContainEqual({ method: 'where', args: ['organization_id', '=', 'org-1'] })
-    expect(calls.some((call) => call.args[1] === 'in' && call.args[0] === 'organization_id')).toBe(false)
-  })
-
-  it('falls back to the visible-organization list when no organization is selected', async () => {
-    const { db, calls } = createKyselyMock([])
-    await findEntityIdsBySearchTokens({
-      ...baseInput,
-      db,
-      scope: { organizationIds: ['org-1', 'org-2'] },
-    })
-    expect(calls).toContainEqual({ method: 'where', args: ['organization_id', 'in', ['org-1', 'org-2']] })
-  })
-})
-
-describe('findEntityIdsBySearchTokensCompat', () => {
-  it('returns null only for a blank query', async () => {
-    const { db } = createKyselyMock([])
-    await expect(findEntityIdsBySearchTokensCompat({
-      db,
-      entityType: 'customers:customer_entity',
-      query: ' ',
-    })).resolves.toBeNull()
-  })
-
-  it('returns an empty array for the remaining skip reasons', async () => {
-    const noTokens = createKyselyMock([])
-    await expect(findEntityIdsBySearchTokensCompat({
-      db: noTokens.db,
-      entityType: 'customers:customer_entity',
-      query: '!',
-    })).resolves.toEqual([])
-
-    const disabled = createKyselyMock([])
-    await expect(findEntityIdsBySearchTokensCompat({
-      db: disabled.db,
-      entityType: 'customers:customer_entity',
-      query: 'Hello',
-      config: { ...resolveSearchConfig(), enabled: false },
-    })).resolves.toEqual([])
-  })
-
-  it('returns the matched ids', async () => {
-    const { db } = createKyselyMock([{ entity_id: 'id-1' }])
-    await expect(findEntityIdsBySearchTokensCompat({
-      db,
-      entityType: 'customers:customer_entity',
-      query: 'Hello',
-    })).resolves.toEqual(['id-1'])
-  })
-})

package/src/lib/search/__tests__/tokenize.test.ts

@@ -1,49 +0,0 @@
-import type { SearchConfig } from '../config'
-import { tokenizeText } from '../tokenize'
-
-const baseConfig: SearchConfig = {
-  enabled: true,
-  minTokenLength: 3,
-  enablePartials: true,
-  hashAlgorithm: 'sha256',
-  storeRawTokens: false,
-  blocklistedFields: [],
-}
-
-describe('tokenizeText limits', () => {
-  test('truncates oversized field text before tokenizing', () => {
-    const config = { ...baseConfig, enablePartials: false, maxFieldChars: 10 }
-
-    const { tokens } = tokenizeText('aaaa bbbb cccc', config)
-
-    expect(tokens).toEqual(['aaaa', 'bbbb'])
-  })
-
-  test('bounds prefix expansion while collecting tokens', () => {
-    const config = { ...baseConfig, maxFieldChars: 100, maxTokensPerField: 5 }
-
-    const { tokens, hashes } = tokenizeText('a'.repeat(100), config)
-
-    expect(tokens).toEqual(['aaa', 'aaaa', 'aaaaa', 'aaaaaa', 'aaaaaaa'])
-    expect(hashes).toHaveLength(5)
-  })
-
-  test('applies safe defaults to legacy configs without limit fields', () => {
-    const { tokens } = tokenizeText('a'.repeat(50_000), baseConfig)
-
-    expect(tokens).toHaveLength(5_000)
-  })
-
-  test('allows a limit to be disabled explicitly', () => {
-    const config = {
-      ...baseConfig,
-      enablePartials: false,
-      maxFieldChars: 0,
-      maxTokensPerField: 0,
-    }
-
-    const { tokens } = tokenizeText('alpha beta gamma delta', config)
-
-    expect(tokens).toEqual(['alpha', 'beta', 'gamma', 'delta'])
-  })
-})

package/src/lib/search/auto-indexing.ts

@@ -1,22 +0,0 @@
-import { parseBooleanToken } from '../boolean'
-
-/**
- * Module id backing the tenant-scoped vector auto-indexing switch. Kept as `vector`
- * (rather than `search`) for backwards compatibility with rows written before the
- * search module absorbed the vector settings.
- */
-export const SEARCH_AUTO_INDEX_CONFIG_MODULE = 'vector'
-export const SEARCH_AUTO_INDEX_CONFIG_KEY = 'auto_index_enabled'
-
-/**
- * Instance-wide kill switch for vector auto-indexing. Lives in `@open-mercato/shared`
- * so consumers outside `@open-mercato/search` (for example the query index status page)
- * can report vector coverage honestly without duplicating the env-var contract.
- */
-export function envDisablesAutoIndexing(): boolean {
-  const raw =
-    process.env.OM_DISABLE_VECTOR_SEARCH_AUTOINDEXING ??
-    process.env.DISABLE_VECTOR_SEARCH_AUTOINDEXING
-  if (!raw) return false
-  return parseBooleanToken(raw) === true
-}