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

package/src/modules/query_index/lib/indexer.ts

@@ -2,21 +2,10 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import { resolveEntityTableName } from '@open-mercato/shared/lib/query/engine'
 import { resolveTenantEncryptionService } from '@open-mercato/shared/lib/encryption/customFieldValues'
 import { decryptIndexDocForSearch, encryptIndexDocForStorage } from '@open-mercato/shared/lib/encryption/indexDoc'
-import {
-  buildCustomFieldDefinitionIndexFromRows,
-  normalizeDefinitionKey,
-  selectDefinitionForRecord,
-  type CustomFieldDefinitionRow,
-} from '@open-mercato/shared/lib/crud/custom-field-definition-index'
-import { type Kysely, type Transaction, sql } from 'kysely'
-import { createLogger } from '@open-mercato/shared/lib/logger'
+import { sql } from 'kysely'
 import { replaceSearchTokensForRecord, deleteSearchTokensForRecord } from './search-tokens'
 import { attachAggregateSearchField } from './document'
 
-const logger = createLogger('query_index').child({ component: 'indexer' })
-
-type QueryIndexExecutor = Kysely<any> | Transaction<any>
-
 type BuildDocParams = {
   entityType: string // '<module>:<entity>'
   recordId: string
@@ -104,74 +93,9 @@ export async function buildIndexDoc(em: EntityManager, params: BuildDocParams):
     if (!cfMap[cfKey]) cfMap[cfKey] = []
     cfMap[cfKey].push(val)
   }
-
-  const multiKeys = new Set<string>()
-  const fieldKeys = Object.keys(cfMap).map((key) => key.slice(3))
-  if (fieldKeys.length > 0) {
-    let defQuery = db
-      .selectFrom('custom_field_defs' as any)
-      .select([
-        'key' as any,
-        'kind' as any,
-        'config_json' as any,
-        'organization_id' as any,
-        'tenant_id' as any,
-        'deleted_at' as any,
-        'updated_at' as any,
-      ])
-      .where('entity_id' as any, '=', params.entityType)
-      .where('key' as any, 'in', fieldKeys)
-      .where('is_active' as any, '=', true)
-      .where('deleted_at' as any, 'is', null)
-
-    if (params.organizationId != null) {
-      defQuery = defQuery.where((eb: any) => eb.or([
-        eb('organization_id' as any, '=', params.organizationId),
-        eb('organization_id' as any, 'is', null),
-      ]))
-    } else {
-      defQuery = defQuery.where('organization_id' as any, 'is', null)
-    }
-
-    if (params.tenantId != null) {
-      defQuery = defQuery.where((eb: any) => eb.or([
-        eb('tenant_id' as any, '=', params.tenantId),
-        eb('tenant_id' as any, 'is', null),
-      ]))
-    } else {
-      defQuery = defQuery.where('tenant_id' as any, 'is', null)
-    }
-
-    const defRows = await defQuery.execute() as Array<Record<string, any>>
-    const definitionIndex = buildCustomFieldDefinitionIndexFromRows(
-      defRows.map((row): CustomFieldDefinitionRow => ({
-        key: String(row.key ?? ''),
-        entityId: params.entityType,
-        kind: typeof row.kind === 'string' ? row.kind : null,
-        configJson: row.config_json,
-        organizationId: row.organization_id ?? null,
-        tenantId: row.tenant_id ?? null,
-        deletedAt: row.deleted_at ?? null,
-        updatedAt: row.updated_at ?? null,
-      })),
-      { organizationIds: params.organizationId ? [params.organizationId] : [] },
-    )
-    for (const key of fieldKeys) {
-      const definitions = definitionIndex.get(normalizeDefinitionKey(key)) ?? []
-      const definition = selectDefinitionForRecord(
-        definitions,
-        params.organizationId ?? null,
-        params.tenantId ?? null,
-      )
-      if (definition?.multi) multiKeys.add(key)
-    }
-  }
-
   for (const [key, arr] of Object.entries(cfMap)) {
-    // Cardinality belongs to the field definition, not the current row count:
-    // a multi field containing one value must still hydrate as an array.
-    const fieldKey = key.slice(3)
-    doc[key] = multiKeys.has(fieldKey) || arr.length > 1 ? arr : arr[0]
+    // Store singletons as simple value; multis as array
+    doc[key] = arr.length <= 1 ? arr[0] : arr
   }
 
   // Attach translations under flat keys 'l10n:{locale}:{field}'
@@ -197,12 +121,8 @@ export async function buildIndexDoc(em: EntityManager, params: BuildDocParams):
     }
   } catch {}
 
-  // Kept outside the guard below: a failure while building the aggregate search field is a
-  // bug in the aggregation or its configuration, and must surface instead of being mistaken
-  // for an encryption failure and silently skipping encryption.
-  doc = attachAggregateSearchField(doc, { entityType: params.entityType })
-
   try {
+    doc = attachAggregateSearchField(doc)
     const encryption = resolveTenantEncryptionService(em as any)
     doc = await encryptIndexDocForStorage(
       params.entityType,
@@ -210,23 +130,7 @@ export async function buildIndexDoc(em: EntityManager, params: BuildDocParams):
       { tenantId: params.tenantId ?? null, organizationId: params.organizationId ?? null },
       encryption,
     )
-  } catch (error) {
-    // `encryptIndexDocForStorage` already returns the document untouched when encryption is
-    // absent or disabled, so a throw here is always a genuine encryption failure. Returning
-    // `doc` would hand the caller the plaintext document to write into `entity_indexes`,
-    // which must stay encrypted at rest; returning `null` would mean "record gone" and make
-    // `upsertIndexRow` delete a healthy index row. Fail loudly instead: the projection keeps
-    // its previous, correctly encrypted contents and the `query_index.upsert_one` subscriber
-    // persists the error via `recordIndexerError`.
-    logger.error('Index document encryption failed; refusing to return an unencrypted document', {
-      entityType: params.entityType,
-      recordId: params.recordId,
-      tenantId: params.tenantId ?? null,
-      organizationId: params.organizationId ?? null,
-      err: error,
-    })
-    throw error
-  }
+  } catch {}
 
   return doc
 }
@@ -254,13 +158,12 @@ function scopeEntityIndexes<QB extends { where: (...args: any[]) => QB }>(
 
 export async function upsertIndexRow(
   em: EntityManager,
-  args: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null; searchTokenDoc?: Record<string, unknown> | null; deferSearchTokens?: boolean; trx?: QueryIndexExecutor }
+  args: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null; searchTokenDoc?: Record<string, unknown> | null; deferSearchTokens?: boolean }
 ): Promise<UpsertIndexResult> {
   const db = (em as any).getKysely()
-  const executor = args.trx ?? db
 
   const existing = await scopeEntityIndexes(
-    executor.selectFrom('entity_indexes' as any).select(['id' as any, 'deleted_at' as any]),
+    db.selectFrom('entity_indexes' as any).select(['id' as any, 'deleted_at' as any]),
     args,
   ).executeTakeFirst() as { id: string; deleted_at: Date | null } | undefined
 
@@ -279,15 +182,12 @@ export async function upsertIndexRow(
           organizationId: args.organizationId ?? null,
           tenantId: args.tenantId ?? null,
           doc: null,
-          trx: args.trx,
         })
-      } catch (error) {
-        if (args.trx) throw error
-      }
+      } catch {}
     }
     if (existed) {
       await scopeEntityIndexes(
-        executor.deleteFrom('entity_indexes' as any) as any,
+        db.deleteFrom('entity_indexes' as any) as any,
         args,
       ).execute()
     }
@@ -307,7 +207,7 @@ export async function upsertIndexRow(
 
   // Prefer modern upsert keyed by coalesced org id when available; fallback to update-then-insert
   try {
-    await executor
+    await db
       .insertInto('entity_indexes' as any)
       .values({ ...payload, created_at: sql`now()` } as any)
       .onConflict((oc: any) => oc
@@ -323,18 +223,16 @@ export async function upsertIndexRow(
   } catch {
     // Fallback for schemas without organization_id_coalesced column/index
     const updated = await scopeEntityIndexes(
-      executor.updateTable('entity_indexes' as any).set(payload as any) as any,
+      db.updateTable('entity_indexes' as any).set(payload as any) as any,
       args,
     ).executeTakeFirst() as { numUpdatedRows?: bigint | number } | undefined
     if (!updated || Number(updated.numUpdatedRows ?? 0) === 0) {
       try {
-        await executor
+        await db
           .insertInto('entity_indexes' as any)
           .values({ ...payload, created_at: sql`now()` } as any)
           .execute()
-      } catch (error) {
-        if (args.trx) throw error
-      }
+      } catch {}
     }
   }
 
@@ -352,11 +250,8 @@ export async function upsertIndexRow(
         tenantId: args.tenantId ?? null,
         doc,
         searchTokenDoc: args.searchTokenDoc ?? null,
-        trx: args.trx,
       })
-    } catch (error) {
-      if (args.trx) throw error
-    }
+    } catch {}
   }
   return { doc, existed, wasDeleted, created, revived }
 }
@@ -376,7 +271,6 @@ export async function reindexSearchTokensForRecord(
     tenantId?: string | null
     doc: Record<string, any> | null
     searchTokenDoc?: Record<string, unknown> | null
-    trx?: QueryIndexExecutor
   },
 ): Promise<void> {
   const db = (em as any).getKysely()
@@ -386,7 +280,7 @@ export async function reindexSearchTokensForRecord(
       recordId: args.recordId,
       organizationId: args.organizationId ?? null,
       tenantId: args.tenantId ?? null,
-    }, { trx: args.trx })
+    })
     return
   }
   const tokenDoc = args.searchTokenDoc ?? (() => {
@@ -406,17 +300,16 @@ export async function reindexSearchTokensForRecord(
     organizationId: args.organizationId ?? null,
     tenantId: args.tenantId ?? null,
     doc: await tokenDoc,
-  }, { trx: args.trx })
+  })
 }
 
 export async function markDeleted(
   em: EntityManager,
-  args: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null; trx?: QueryIndexExecutor }
+  args: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null }
 ): Promise<{ wasActive: boolean }> {
   const db = (em as any).getKysely()
-  const executor = args.trx ?? db
   const existing = await scopeEntityIndexes(
-    executor.selectFrom('entity_indexes' as any).select(['deleted_at' as any]),
+    db.selectFrom('entity_indexes' as any).select(['deleted_at' as any]),
     args,
   ).executeTakeFirst() as { deleted_at: Date | null } | undefined
 
@@ -429,12 +322,10 @@ export async function markDeleted(
         recordId: args.recordId,
         organizationId: args.organizationId ?? null,
         tenantId: args.tenantId ?? null,
-      }, { trx: args.trx })
-    } catch (error) {
-      if (args.trx) throw error
-    }
+      })
+    } catch {}
     await scopeEntityIndexes(
-      executor.deleteFrom('entity_indexes' as any) as any,
+      db.deleteFrom('entity_indexes' as any) as any,
       args,
     ).execute()
   }

package/src/modules/query_index/lib/reindexer.ts

@@ -323,77 +323,55 @@ export async function reindexEntity(
 
   options?.onProgress?.({ processed, total, chunkSize: 0 })
 
-  // Partitions run concurrently, so a scope-wide purge here would delete rows a sibling
-  // partition has already written and never rebuild them (the run still reports success
-  // because progress counts attempted writes). Each partition therefore purges only the
-  // slice it is about to rebuild, and every partition purges — restricting the purge to
-  // the coverage-resetting partition would otherwise leave the other slices' stale rows
-  // behind on a forced rebuild.
-  if (force && (resetCoverage || usingPartitions)) {
-    try {
-      let purgeQuery = db
-        .deleteFrom('entity_indexes' as any)
-        .where('entity_type' as any, '=', entityType)
-      if (tenantId !== undefined) {
-        purgeQuery = purgeQuery.where(sql<boolean>`tenant_id is not distinct from ${tenantId ?? null}`)
-      }
-      if (organizationId !== undefined) {
-        purgeQuery = purgeQuery.where(sql<boolean>`organization_id is not distinct from ${organizationId ?? null}`)
-      }
-      if (usingPartitions && partitionIndex !== null) {
-        purgeQuery = purgeQuery.where(
-          sql<boolean>`mod(abs(hashtext(entity_id::text)), ${partitionCountRaw}) = ${partitionIndex}`,
-        )
-      }
-      await purgeQuery.execute()
-    } catch (error) {
-      logger.warn('Failed to purge index rows before force reindex', {
-        entityType,
-        tenantId: tenantId ?? null,
-        organizationId: organizationId ?? null,
-        partitionIndex: usingPartitions ? partitionIndex : null,
-        error: error instanceof Error ? error.message : error,
-      })
-    }
-  }
-
-  // The vector purge is scope-wide and cannot be partitioned — the queued job deletes every
-  // vector for the scope. Emitting it from one partition while siblings are already queueing
-  // per-record vectorize jobs is the same race the row purge just had, so a partitioned run
-  // leaves it to the caller that owns the fan-out (`api/reindex.ts` queues it once, before
-  // dispatching any partition).
-  if (force && resetCoverage && !usingPartitions && emitVectorize && eventBus) {
-    if (tenantId !== undefined) {
-      const payload: Record<string, unknown> = {
-        entityType,
-        tenantId: tenantId ?? null,
-      }
-      if (organizationId !== undefined) payload.organizationId = organizationId ?? null
+  if (resetCoverage) {
+    if (force) {
       try {
-        await eventBus.emitEvent('query_index.vectorize_purge', payload)
-      } catch (err) {
-        logger.warn('Failed to queue vector purge before force reindex', {
+        let purgeQuery = db
+          .deleteFrom('entity_indexes' as any)
+          .where('entity_type' as any, '=', entityType)
+        if (tenantId !== undefined) {
+          purgeQuery = purgeQuery.where(sql<boolean>`tenant_id is not distinct from ${tenantId ?? null}`)
+        }
+        if (organizationId !== undefined) {
+          purgeQuery = purgeQuery.where(sql<boolean>`organization_id is not distinct from ${organizationId ?? null}`)
+        }
+        await purgeQuery.execute()
+      } catch (error) {
+        logger.warn('Failed to purge index rows before force reindex', {
           entityType,
           tenantId: tenantId ?? null,
           organizationId: organizationId ?? null,
-          error: err instanceof Error ? err.message : err,
+          error: error instanceof Error ? error.message : error,
         })
       }
-    } else {
-      logger.warn('Skipping vector purge for force reindex without tenant scope', {
-        entityType,
-      })
+
+      if (emitVectorize && eventBus) {
+        if (tenantId !== undefined) {
+          const payload: Record<string, unknown> = {
+            entityType,
+            tenantId: tenantId ?? null,
+          }
+          if (organizationId !== undefined) payload.organizationId = organizationId ?? null
+          try {
+            await eventBus.emitEvent('query_index.vectorize_purge', payload)
+          } catch (err) {
+            logger.warn('Failed to queue vector purge before force reindex', {
+              entityType,
+              tenantId: tenantId ?? null,
+              organizationId: organizationId ?? null,
+              error: err instanceof Error ? err.message : err,
+            })
+          }
+        } else {
+          logger.warn('Skipping vector purge for force reindex without tenant scope', {
+            entityType,
+          })
+        }
+      }
     }
-  }
 
-  if (resetCoverage) {
-    // Only meaningful for an unpartitioned run: `baseCounts` holds this partition's slice,
-    // so writing it as the scope's base count under-reports by the partition factor, and
-    // zeroing indexed_count scope-wide discards deltas siblings have already applied. The
-    // authoritative `refreshCoverageSnapshot` at the end of every partition owns the counts
-    // for partitioned runs.
     const nowTs = Date.now()
-    for (const scope of usingPartitions ? [] : baseCounts.values()) {
+    for (const scope of baseCounts.values()) {
       const key = `${entityType}|${scopeKey(scope.tenantId, scope.organizationId)}`
       const last = lastCoverageReset.get(key) ?? 0
       if (force || nowTs - last >= COVERAGE_REFRESH_THROTTLE_MS) {

package/src/modules/query_index/lib/search-tokens.ts

@@ -1,10 +1,5 @@
-import { type Kysely, type Transaction, sql } from 'kysely'
-import {
-  isSearchFieldBlocklisted,
-  resolveSearchConfig,
-  resolveSearchTokenLimits,
-  type SearchConfig,
-} from '@open-mercato/shared/lib/search/config'
+import { type Kysely, sql } from 'kysely'
+import { resolveSearchConfig, type SearchConfig } from '@open-mercato/shared/lib/search/config'
 import { tokenizeText } from '@open-mercato/shared/lib/search/tokenize'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 import { createLogger } from '@open-mercato/shared/lib/logger'
@@ -41,7 +36,6 @@ type BuildTokenOptions = {
 
 const DEFAULT_SCOPE = { organizationId: null, tenantId: null }
 type EntityFieldPair = [string, string]
-type SearchTokenExecutor = Kysely<any> | Transaction<any>
 
 export const isSearchDebugEnabled = (): boolean => {
   return parseBooleanToken(process.env.OM_SEARCH_DEBUG ?? '') === true
@@ -68,19 +62,16 @@ function collectTextValues(value: unknown): string[] {
   return []
 }
 
-function shouldIndexField(
-  field: string,
-  value: unknown,
-  config: SearchConfig,
-  entityType: string | null,
-): boolean {
+function shouldIndexField(field: string, value: unknown, config: SearchConfig): boolean {
   if (typeof value !== 'string' && !Array.isArray(value)) return false
   const lower = field.toLowerCase()
   if (lower === 'id' || lower.endsWith('_id') || lower.endsWith('.id')) return false
   if (lower.endsWith('_at')) return false
   if (['created_at', 'updated_at', 'deleted_at', 'tenant_id', 'organization_id'].includes(lower)) return false
-  if (isSearchFieldBlocklisted(field, entityType, config)) return false
-  return collectTextValues(value).some((text) => text.length > 0)
+  if (config.blocklistedFields.some((blocked) => lower.includes(blocked))) return false
+  const values = collectTextValues(value)
+  if (!values.length) return false
+  return values.some((text) => tokenizeText(text, config).tokens.length > 0)
 }
 
 export function buildSearchTokenRows(params: BuildTokenOptions): SearchTokenRow[] {
@@ -94,32 +85,19 @@ export function buildSearchTokenRows(params: BuildTokenOptions): SearchTokenRow[
     organizationId: params.organizationId ?? DEFAULT_SCOPE.organizationId,
     tenantId: params.tenantId ?? DEFAULT_SCOPE.tenantId,
   }
-  const limits = resolveSearchTokenLimits(config)
-  const recordLimit = limits.maxTokensPerRecord > 0 ? limits.maxTokensPerRecord : Number.POSITIVE_INFINITY
-  const fieldLimit = limits.maxTokensPerField > 0 ? limits.maxTokensPerField : Number.POSITIVE_INFINITY
 
   for (const [field, rawValue] of Object.entries(params.doc)) {
-    if (tokens.length >= recordLimit) break
-    if (!shouldIndexField(field, rawValue, config, params.entityType)) continue
+    if (!shouldIndexField(field, rawValue, config)) continue
     const values = collectTextValues(rawValue)
     const seen = new Set<string>()
-    let fieldTokenCount = 0
     for (const text of values) {
-      if (tokens.length >= recordLimit || fieldTokenCount >= fieldLimit) break
-      const remainingLimit = Math.min(recordLimit - tokens.length, fieldLimit - fieldTokenCount)
-      const candidateLimit = fieldTokenCount + remainingLimit
-      const tokenConfig = Number.isFinite(candidateLimit)
-        ? { ...config, maxTokensPerField: candidateLimit }
-        : config
-      const { tokens: textTokens, hashes } = tokenizeText(text, tokenConfig)
+      const { tokens: textTokens, hashes } = tokenizeText(text, config)
       for (let i = 0; i < textTokens.length; i += 1) {
-        if (tokens.length >= recordLimit || fieldTokenCount >= fieldLimit) break
         const token = textTokens[i]
         const hash = hashes[i]
         const dedupeKey = `${field}|${hash}`
         if (seen.has(dedupeKey)) continue
         seen.add(dedupeKey)
-        fieldTokenCount += 1
         debug('token.generated', { entityType: params.entityType, recordId: params.recordId, field, hash })
         tokens.push({
           entity_type: params.entityType,
@@ -164,8 +142,7 @@ function buildFieldPairs(recordId: string, doc?: Record<string, unknown> | null)
 
 export async function replaceSearchTokensForRecord(
   db: Kysely<any>,
-  params: BuildTokenOptions,
-  options?: { trx?: SearchTokenExecutor },
+  params: BuildTokenOptions
 ): Promise<void> {
   const rows = buildSearchTokenRows(params)
   const config = params.config ?? resolveSearchConfig()
@@ -174,8 +151,8 @@ export async function replaceSearchTokensForRecord(
   const tenantId = params.tenantId ?? null
   const fieldPairs = buildFieldPairs(String(params.recordId), params.doc)
 
-  const writeTokens = async (executor: SearchTokenExecutor): Promise<void> => {
-    let deleteQuery = executor
+  await db.transaction().execute(async (trx) => {
+    let deleteQuery = trx
       .deleteFrom('search_tokens' as any)
       .where('entity_type' as any, '=', params.entityType)
       .where(sql<boolean>`organization_id is not distinct from ${organizationId}`)
@@ -194,27 +171,18 @@ export async function replaceSearchTokensForRecord(
     if (!rows.length) return
     const payloads = rows.map((row) => ({ ...row, created_at: sql`now()` }))
     for (const batch of chunk(payloads, INSERT_BATCH_SIZE)) {
-      await executor.insertInto('search_tokens' as any).values(batch as any).execute()
+      await trx.insertInto('search_tokens' as any).values(batch as any).execute()
     }
-  }
-
-  if (options?.trx) {
-    await writeTokens(options.trx)
-    return
-  }
-
-  await db.transaction().execute(writeTokens)
+  })
 }
 
 export async function deleteSearchTokensForRecord(
   db: Kysely<any>,
-  params: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null },
-  options?: { trx?: SearchTokenExecutor },
+  params: { entityType: string; recordId: string; organizationId?: string | null; tenantId?: string | null }
 ): Promise<void> {
   const organizationId = params.organizationId ?? null
   const tenantId = params.tenantId ?? null
-  const executor = options?.trx ?? db
-  await executor
+  await db
     .deleteFrom('search_tokens' as any)
     .where('entity_type' as any, '=', params.entityType)
     .where('entity_id' as any, '=', String(params.recordId))

package/src/modules/query_index/lib/subscriber-scope.ts

@@ -1,7 +1,6 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { getEntityIds } from '@open-mercato/shared/lib/encryption/entityIds'
 import { resolveRegisteredEntityTableName } from '@open-mercato/shared/lib/query/engine'
-import { listEntityMetadata } from '@open-mercato/shared/lib/db/entityMetadata'
 
 export type QueryIndexScope = {
   tenantId: string | null
@@ -59,7 +58,13 @@ export function resolveQueryIndexSourceMetadata(
     throw new QueryIndexScopeError(`Query index entity type has no registered ORM table: ${entityType}`)
   }
 
-  const allMetadata = listEntityMetadata(em) as unknown as QueryIndexEntityMetadata[]
+  const registry = em.getMetadata?.()
+  const allMetadataRaw = typeof registry?.getAll === 'function' ? registry.getAll() : null
+  const allMetadata: QueryIndexEntityMetadata[] = Array.isArray(allMetadataRaw)
+    ? allMetadataRaw as QueryIndexEntityMetadata[]
+    : allMetadataRaw instanceof Map
+      ? Array.from(allMetadataRaw.values()) as QueryIndexEntityMetadata[]
+      : Object.values(allMetadataRaw ?? {}) as QueryIndexEntityMetadata[]
   const metadata = allMetadata.find((candidate) => String(candidate.tableName ?? '') === table)
   if (!metadata) {
     throw new QueryIndexScopeError(`Query index entity metadata was not found for table: ${table}`)

package/src/modules/query_index/migrations/.snapshot-open-mercato.json

@@ -1365,18 +1365,6 @@
           "primary": false,
           "unique": false
         },
-        {
-          "columnNames": [
-            "entity_type",
-            "tenant_id",
-            "organization_id"
-          ],
-          "composite": true,
-          "constraint": false,
-          "keyName": "search_tokens_presence_idx",
-          "primary": false,
-          "unique": false
-        },
         {
           "columnNames": [
             "id"

package/src/modules/query_index/subscribers/coverage_refresh.ts

@@ -1,6 +1,5 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
-import { isReadProjectionAlwaysConsistent } from '@open-mercato/shared/lib/data/consistency'
 import { refreshCoverageSnapshot } from '../lib/coverage'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
@@ -71,9 +70,6 @@ export default async function handle(payload: Payload, ctx: { resolve: <T = any>
           payload,
         },
       )
-      if (isReadProjectionAlwaysConsistent()) {
-        throw err
-      }
     }
   }
 

package/src/modules/query_index/subscribers/delete_one.ts

@@ -1,5 +1,4 @@
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
-import { isReadProjectionAlwaysConsistent } from '@open-mercato/shared/lib/data/consistency'
 import { sql } from 'kysely'
 import { markDeleted } from '../lib/indexer'
 import { applyCoverageAdjustments, createCoverageAdjustments } from '../lib/coverage'
@@ -40,9 +39,7 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
   if (!entityType || !recordId) return
   let organizationId: string | null = payload?.organizationId ?? null
   let tenantId: string | null = payload?.tenantId ?? null
-  const suppressCoverage = payload?.suppressCoverage === true
   const coverageDelayMs = typeof payload?.coverageDelayMs === 'number' ? payload.coverageDelayMs : undefined
-  const alwaysConsistent = isReadProjectionAlwaysConsistent()
   try {
     const hasPayloadOrganizationId = Object.prototype.hasOwnProperty.call(payload ?? {}, 'organizationId')
     const hasPayloadTenantId = Object.prototype.hasOwnProperty.call(payload ?? {}, 'tenantId')
@@ -58,68 +55,6 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
     organizationId = resolvedScope.organizationId
     tenantId = resolvedScope.tenantId
 
-    if (alwaysConsistent) {
-      const db = (em as any).getKysely()
-      await db.transaction().execute(async (trx: any) => {
-        const { wasActive } = await markDeleted(em, { entityType, recordId, organizationId, tenantId, trx })
-
-        let baseQuery = trx
-          .selectFrom(source.table as any)
-          .select(['deleted_at' as any])
-          .where('id' as any, '=', recordId)
-        if (source.organizationColumn) {
-          baseQuery = baseQuery.where(
-            source.organizationColumn as any,
-            organizationId === null ? 'is' : '=',
-            organizationId as any,
-          )
-        }
-        if (source.tenantColumn) {
-          baseQuery = baseQuery.where(sql`${sql.ref(source.tenantColumn)} is not distinct from ${tenantId}`)
-        }
-        const row = await baseQuery.executeTakeFirst() as { deleted_at: Date | null } | undefined
-        const baseDelta = !row || row.deleted_at != null ? -1 : 0
-
-        const baseDeltaOverride =
-          typeof payload?.coverageBaseDelta === 'number' ? payload.coverageBaseDelta : undefined
-        const indexDeltaOverride =
-          typeof payload?.coverageIndexDelta === 'number' ? payload.coverageIndexDelta : undefined
-        let effectiveBaseDelta = baseDeltaOverride ?? baseDelta
-        let effectiveIndexDelta = indexDeltaOverride ?? (wasActive ? -1 : 0)
-
-        if (!Number.isFinite(effectiveBaseDelta)) effectiveBaseDelta = 0
-        if (!Number.isFinite(effectiveIndexDelta)) effectiveIndexDelta = 0
-
-        if (effectiveBaseDelta !== 0 || effectiveIndexDelta !== 0) {
-          const adjustments = createCoverageAdjustments({
-            entityType,
-            tenantId: tenantId ?? null,
-            organizationId: organizationId ?? null,
-            baseDelta: effectiveBaseDelta,
-            indexDelta: effectiveIndexDelta,
-          })
-          if (adjustments.length) {
-            await applyCoverageAdjustments(em, adjustments, { trx })
-          }
-        }
-      })
-
-      const bus = ctx.resolve<any>('eventBus')
-      const shouldRefreshCoverage =
-        !suppressCoverage && (coverageDelayMs === undefined || coverageDelayMs >= 0)
-      const coverageRefreshDelay = coverageDelayMs ?? 0
-      if (shouldRefreshCoverage) {
-        await bus.emitEvent('query_index.coverage.refresh', {
-          entityType,
-          tenantId: tenantId ?? null,
-          organizationId: organizationId ?? null,
-          delayMs: coverageRefreshDelay,
-        }, { rethrowHandlerErrors: true })
-      }
-      await bus.emitEvent('search.delete_record', { entityId: entityType, recordId, organizationId, tenantId }, { rethrowHandlerErrors: true })
-      return
-    }
-
     const { wasActive } = await markDeleted(em, { entityType, recordId, organizationId, tenantId })
 
     let baseDelta = 0
@@ -175,6 +110,7 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
     // awaits this subscriber) so list reads are consistent immediately. The coverage
     // recompute (a COUNT, run inline when delayMs is 0) and the fulltext delete are
     // secondary, so defer them fire-and-forget to keep write/bulk-delete latency bounded.
+    const suppressCoverage = payload?.suppressCoverage === true
     const explicitDelayRequested = typeof payload?.coverageDelayMs === 'number'
     const shouldRefreshCoverage =
       !suppressCoverage &&