@open-mercato/search 0.10.1-develop.7769.1.0e6458bb99 → 0.10.1-develop.7770.1.970b396ebb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/search",
-  "version": "0.10.1-develop.7769.1.0e6458bb99",
+  "version": "0.10.1-develop.7770.1.970b396ebb",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -127,9 +127,9 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@open-mercato/core": "0.10.1-develop.7769.1.0e6458bb99",
-    "@open-mercato/queue": "0.10.1-develop.7769.1.0e6458bb99",
-    "@open-mercato/shared": "0.10.1-develop.7769.1.0e6458bb99"
+    "@open-mercato/core": "0.10.1-develop.7770.1.970b396ebb",
+    "@open-mercato/queue": "0.10.1-develop.7770.1.970b396ebb",
+    "@open-mercato/shared": "0.10.1-develop.7770.1.970b396ebb"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

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

@@ -70,6 +70,26 @@ describe('createPresenterEnricher', () => {
     mockedDecryptIndexDocForSearch.mockReset()
   })
 
+  it.each(['throw', 'null'])('keeps protected contacts out of the read-time fallback when callbacks %s', async (failure) => {
+    const doc = { id: 'person-1', name: 'Safe display name', email: 'private-contact@example.com', password_hash: 'private-password' }
+    mockedDecryptIndexDocForSearch.mockResolvedValue(doc)
+    const unavailable = () => {
+      if (failure === 'throw') throw new Error('[internal] Injected formatter failure')
+      return null
+    }
+    const config = createConfig({
+      fieldPolicy: { searchable: ['name', 'email', 'password_hash'], hashOnly: ['email'], excluded: ['password_hash'] },
+      formatResult: unavailable, buildSource: unavailable,
+    })
+    const enrich = createPresenterEnricher(
+      createKyselyMock([{ entity_type: config.entityId, entity_id: doc.id, doc }]),
+      new Map([[config.entityId, config]]),
+    )
+    const [enriched] = await enrich([createResult()], 'tenant-1', 'org-1')
+    expect(enriched.presenter?.title).toBe('Safe display name')
+    expect(JSON.stringify(enriched.presenter)).not.toContain('private-')
+  })
+
   it('uses search config presenters and the stored organization scope for doc decryption', async () => {
     const decryptedDoc = {
       id: 'person-1',

package/src/__tests__/vector-index-security.test.ts

@@ -3,7 +3,21 @@ import type { EmbeddingService } from '../vector/services/embedding'
 import type { VectorDriver, VectorDriverDocument } from '../vector/types'
 import type { VectorModuleConfig } from '@open-mercato/shared/modules/vector'
 import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
-import type { TenantDataEncryptionService } from '@open-mercato/shared/lib/encryption/tenantDataEncryptionService'
+import { TenantDataEncryptionService } from '@open-mercato/shared/lib/encryption/tenantDataEncryptionService'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { searchConfig as customersSearchConfig } from '@open-mercato/core/modules/customers/search'
+import { searchConfig as accountsSearchConfig } from '@open-mercato/core/modules/customer_accounts/search'
+import { SearchIndexer } from '../indexer/search-indexer'
+import { SearchService } from '../service'
+import { VectorSearchStrategy } from '../strategies/vector.strategy'
+import type { SearchStrategy } from '../types'
+import { asValue, createContainer } from 'awilix'
+import { registerSearchModule } from '../di'
+
+jest.mock('@open-mercato/shared/lib/i18n/server', () => ({
+  resolveTranslations: async () => ({ t: (_key: string, fallback: string) => fallback }),
+}))
+jest.mock('../fulltext/drivers', () => ({ createFulltextDriver: jest.fn() }))
 
 type CapturedEmbeddingInput = { value: string | string[] | null }
 
@@ -41,6 +55,25 @@ function createQueryEngine(record: Record<string, unknown>): QueryEngine {
   } as unknown as QueryEngine
 }
 
+function createCustomerIndexer(args: {
+  driver: VectorDriver
+  embeddingService: EmbeddingService
+  queryEngine: QueryEngine
+  encryptionService?: Pick<TenantDataEncryptionService, 'getEncryptedFieldNames'>
+  otherStrategy?: SearchStrategy
+}): SearchIndexer {
+  const container = createContainer()
+  container.register({
+    vectorDrivers: asValue([args.driver]),
+    vectorEmbeddingService: asValue(args.embeddingService),
+    queryEngine: asValue(args.queryEngine),
+    tenantEncryptionService: asValue(args.encryptionService ?? { getEncryptedFieldNames: async () => [] }),
+  })
+  registerSearchModule(container, { skipTokens: true, skipFulltext: true, moduleConfigs: [customersSearchConfig, accountsSearchConfig] })
+  if (args.otherStrategy) container.resolve<SearchService>('searchService').registerStrategy(args.otherStrategy)
+  return container.resolve<SearchIndexer>('searchIndexer')
+}
+
 function createService(args: {
   driver: VectorDriver
   embeddingService: EmbeddingService
@@ -140,6 +173,252 @@ describe('VectorIndexService default source field protection (issue #2716)', ()
   })
 })
 
+describe('Customer vector privacy at provider and storage boundaries (issue #7826)', () => {
+  it.each(['true', 'false'].flatMap((toggle) => ['single', 'by-id', 'batch', 'bulk'].map((mode) => ({ toggle, mode }))))(
+    'protects real-service live declarations with encryption $toggle through $mode indexing', async ({ toggle, mode }) => {
+      const previousToggle = process.env.TENANT_DATA_ENCRYPTION
+      try {
+        process.env.TENANT_DATA_ENCRYPTION = 'true'
+        const execute = jest.fn(async (_sql: string, params?: readonly unknown[]) => [{
+          entity_id: params?.[0], tenant_id: 'tenant-privacy', organization_id: 'org-privacy',
+          fields_json: [{ field: params?.[0] === 'customers:customer_company_profile' ? 'size_bucket' : 'status' }],
+        }])
+        const encryptionService = new TenantDataEncryptionService({ execute } as unknown as EntityManager, {
+          kms: { isHealthy: () => false, getTenantDek: async () => null, createTenantDek: async () => null },
+        })
+        await expect(encryptionService.getEncryptedFieldNames('customers:customer_company_profile', 'tenant-privacy', 'org-privacy', { ignoreRuntimeHealth: true })).resolves.toEqual(['size_bucket'])
+        execute.mockClear()
+        process.env.TENANT_DATA_ENCRYPTION = toggle
+        const driver = createDriver()
+        const captured: CapturedEmbeddingInput = { value: null }
+        const otherIndex = jest.fn(async () => {})
+        const record = { id: 'real-policy-company', entity_id: 'real-policy-entity', size_bucket: 'private-size' }
+        const indexer = createCustomerIndexer({
+          driver, embeddingService: createEmbeddingService(captured), encryptionService,
+          queryEngine: { query: async (entityId: string) => ({ items: [entityId === 'customers:customer_entity' ? { id: 'real-policy-entity', status: 'private-status' } : record], total: 1 }) } as QueryEngine,
+          otherStrategy: { id: 'fulltext', name: 'Fake fulltext', priority: 1, ensureReady: async () => {}, isAvailable: async () => true, search: async () => [], index: otherIndex, delete: async () => {} },
+        })
+        const params = { entityId: 'customers:customer_company_profile', recordId: record.id, tenantId: 'tenant-privacy', organizationId: 'org-privacy' }
+        if (mode === 'single') await indexer.indexRecord({ ...params, record })
+        if (mode === 'by-id') await indexer.indexRecordById(params)
+        if (mode === 'batch') await indexer.indexRecordsById({ ...params, items: [params] })
+        if (mode === 'bulk') await indexer.bulkIndexRecords([{ ...params, record }])
+        if (toggle === 'false') {
+          expect(captured.value).toBeNull()
+          expect(driver.upsertCalls).toHaveLength(0)
+          expect(execute).not.toHaveBeenCalled()
+        } else {
+          expect(captured.value).not.toBeNull()
+          expect(driver.upsertCalls).toHaveLength(1)
+          expect(JSON.stringify(captured.value)).not.toContain('private-')
+          expect(execute).toHaveBeenCalled()
+          for (const [, policyParams] of execute.mock.calls) expect(policyParams).toEqual(expect.arrayContaining(['tenant-privacy', 'org-privacy']))
+        }
+        expect(otherIndex).toHaveBeenCalledTimes(1)
+      } finally {
+        if (previousToggle === undefined) delete process.env.TENANT_DATA_ENCRYPTION
+        else process.env.TENANT_DATA_ENCRYPTION = previousToggle
+      }
+    },
+  )
+
+  it.each(['protected-scope', 'other-scope', 'tenant-wide', 'related-scope'])('applies live profile and related-entity declarations for the trusted %s', async (scope) => {
+    const driver = createDriver()
+    const captured: CapturedEmbeddingInput = { value: null }
+    const getEncryptedFieldNames = jest.fn(async (entityId: string, tenantId: string | null | undefined, organizationId?: string | null) => {
+      if (tenantId !== 'tenant-privacy' || organizationId !== 'protected-scope') return []
+      return entityId === 'customers:customer_company_profile' ? ['cf:sizeBucket'] : ['status', 'lifecycleStage']
+    })
+    const organizationId = scope === 'tenant-wide' || scope === 'related-scope' ? undefined : scope
+    const record = { id: 'live-company', entity_id: 'live-entity', tenant_id: 'untrusted-tenant', organization_id: scope === 'tenant-wide' ? 'protected-scope' : scope === 'related-scope' ? undefined : 'untrusted-org', sizeBucket: 'private-size', 'cf:size_bucket': 'private-custom-size' }
+    const queryEngine = { query: async (entityId: string) => ({ items: [
+      entityId === 'customers:customer_entity'
+        ? { id: 'live-entity', organization_id: scope === 'related-scope' ? 'protected-scope' : undefined, status: 'private-status', lifecycleStage: 'private-stage' }
+        : record,
+    ], total: 1 }) } as QueryEngine
+    const indexer = createCustomerIndexer({ driver, embeddingService: createEmbeddingService(captured), queryEngine, encryptionService: { getEncryptedFieldNames } })
+    await indexer.indexRecordById({ entityId: 'customers:customer_company_profile', recordId: record.id, tenantId: 'tenant-privacy', organizationId })
+    expect(driver.upsertCalls).toHaveLength(1)
+    if (scope !== 'other-scope') expect(JSON.stringify(captured.value)).not.toContain('private-')
+    else expect(JSON.stringify(captured.value)).toContain('private-custom-size')
+    for (const entityId of ['customers:customer_company_profile', 'customers:customer_entity']) {
+      expect(getEncryptedFieldNames).toHaveBeenCalledWith(entityId, 'tenant-privacy', organizationId, { ignoreRuntimeHealth: true })
+    }
+  })
+
+  it('does not send decrypted fields when live encryption policy lookup fails', async () => {
+    const driver = createDriver()
+    const captured: CapturedEmbeddingInput = { value: null }
+    const indexer = createCustomerIndexer({
+      driver, embeddingService: createEmbeddingService(captured),
+      queryEngine: createQueryEngine({ id: 'policy-failure', size_bucket: 'private-size' }),
+      encryptionService: { getEncryptedFieldNames: async () => { throw new Error('[internal] Policy unavailable') } },
+    })
+    await indexer.indexRecordById({ entityId: 'customers:customer_company_profile', recordId: 'policy-failure', tenantId: 'tenant-privacy', organizationId: 'org-privacy' })
+    expect(captured.value).toBeNull()
+    expect(driver.upsertCalls).toHaveLength(0)
+  })
+
+  it.each(['missing-container', 'missing-service'])('does not embed customer fields with %s', async (failure) => {
+    const driver = createDriver()
+    const captured: CapturedEmbeddingInput = { value: null }
+    const company = customersSearchConfig.entities.find((entity) => entity.entityId === 'customers:customer_company_profile')!
+    const indexer = new SearchIndexer(new SearchService({ strategies: [new VectorSearchStrategy(createEmbeddingService(captured), driver)] }), [{ entities: [{
+      ...company,
+      buildSource: (ctx) => company.buildSource!({ ...ctx, container: failure === 'missing-service' ? { resolve: () => undefined } : undefined }),
+    }] }])
+    await indexer.indexRecord({ entityId: company.entityId, recordId: 'missing-policy', tenantId: 'tenant-privacy', record: { size_bucket: 'private-size' } })
+    expect(captured.value).toBeNull()
+    expect(driver.upsertCalls).toHaveLength(0)
+  })
+
+  it.each(['throw', 'null', 'empty-string', 'empty-array', 'whitespace'].flatMap((failure) =>
+    ['single', 'by-id', 'batch', 'bulk'].map((mode) => ({ failure, mode })),
+  ))('fails closed for $failure sources through $mode indexing without blocking other strategies', async ({ failure, mode }) => {
+    const captured: CapturedEmbeddingInput = { value: null }
+    const driver = createDriver()
+    const otherIndex = jest.fn(async () => {})
+    const otherStrategy: SearchStrategy = {
+      id: 'fulltext', name: 'Fake fulltext', priority: 1,
+      isAvailable: async () => true, ensureReady: async () => {}, search: async () => [],
+      index: otherIndex, delete: async () => {},
+    }
+    const record = { id: 'source-failure', email: 'private-email@example.com', password_hash: 'private-password-hash' }
+    const indexer = new SearchIndexer(new SearchService({ strategies: [
+      new VectorSearchStrategy(createEmbeddingService(captured), driver), otherStrategy,
+    ] }), [{ entities: [{
+      entityId: 'customer_accounts:customer_user',
+      buildSource: () => {
+        if (failure === 'throw') throw new Error('[internal] Injected source failure')
+        if (failure === 'null') return null
+        return { text: failure === 'empty-string' ? '' : failure === 'whitespace' ? ' \n ' : [] }
+      },
+    }] }], { queryEngine: createQueryEngine(record) })
+    const params = { entityId: 'customer_accounts:customer_user', recordId: record.id, tenantId: 'tenant-privacy', organizationId: 'org-privacy' }
+    if (mode === 'single') await indexer.indexRecord({ ...params, record })
+    if (mode === 'by-id') await indexer.indexRecordById(params)
+    if (mode === 'batch') await indexer.indexRecordsById({ ...params, items: [params] })
+    if (mode === 'bulk') await indexer.bulkIndexRecords([{ ...params, record }])
+    expect(captured.value).toBeNull()
+    expect(driver.upsertCalls).toHaveLength(0)
+    expect(otherIndex).toHaveBeenCalledTimes(1)
+    expect(otherIndex).toHaveBeenCalledWith(expect.objectContaining({ tenantId: 'tenant-privacy', organizationId: 'org-privacy' }))
+  })
+
+  it('keeps protected fields out of a generated presenter when a custom source omits its presenter', async () => {
+    const driver = createDriver()
+    const service = createService({
+      driver,
+      embeddingService: createEmbeddingService({ value: null }),
+      queryEngine: createQueryEngine({
+        id: 'fallback-record',
+        title: 'private-title',
+        description: 'private-description',
+        'cf:summary': 'private-summary',
+      }),
+      moduleConfigs: [{ entities: [{
+        entityId: 'demo:item',
+        fieldPolicy: { searchable: ['title', 'description', 'summary'], hashOnly: ['title'], excluded: ['description', 'summary'] },
+        buildSource: () => ({ input: 'Safe source', checksumSource: 'safe-checksum' }),
+      }] }],
+    })
+
+    await service.indexRecord({ entityId: 'demo:item', recordId: 'fallback-record', tenantId: 'tenant-privacy' })
+    expect(driver.upsertCalls).toHaveLength(1)
+    expect(JSON.stringify(driver.upsertCalls[0])).not.toContain('private-')
+    expect(driver.upsertCalls[0].resultTitle).toBe('fallback-record')
+  })
+
+  const customerIndexingCases = [
+    'customers:customer_person_profile',
+    'customers:customer_company_profile',
+    'customer_accounts:customer_user',
+  ].flatMap((entityId) => ['by-id', 'single', 'bulk'].map((mode) => ({ entityId, mode })))
+  it.each(customerIndexingCases)('keeps contact and excluded custom values out of $entityId $mode embeddings and stored metadata', async ({ entityId, mode }) => {
+    const driver = createDriver()
+    const captured: CapturedEmbeddingInput = { value: null }
+    const record = {
+      id: `record-${entityId}`,
+      entity_id: `entity-${entityId}`,
+      display_name: 'Permitted Presenter Name',
+      email: 'private-account@example.com',
+      primary_email: 'private-profile@example.com',
+      primary_phone: '+48-555-030-7826',
+      password_hash: 'private-password-hash',
+      'cf:personal_email': 'private-custom@example.com',
+      cf_government_id: 'private-government-id',
+      'cf:bank_account': 'private-bank-account',
+      'cf:summary': 'private-summary',
+      cf_unknown: 'private-unknown',
+    }
+    const related = {
+      id: `entity-${entityId}`,
+      display_name: 'Permitted Customer Name',
+      primary_email: 'private-related@example.com',
+      primary_phone: '+48-555-040-7826',
+      status: 'active',
+      'cf:government_id': 'private-related-government',
+      cf_personal_email: 'private-related-custom@example.com',
+    }
+    const query = jest.fn(async (queriedEntity: string, _options: unknown) => ({
+      items: [queriedEntity === 'customers:customer_entity' ? related : record],
+      total: 1,
+    }))
+    const indexer = createCustomerIndexer({ driver, embeddingService: createEmbeddingService(captured), queryEngine: { query } as unknown as QueryEngine })
+
+    const params = {
+      entityId,
+      recordId: record.id,
+      tenantId: 'tenant-privacy',
+      organizationId: 'org-privacy',
+    }
+    if (mode === 'by-id') {
+      await indexer.indexRecordById(params)
+    } else {
+      const recordParams = { ...params, record, customFields: { personal_email: 'private-separate@example.com' } }
+      if (mode === 'bulk') {
+        await indexer.bulkIndexRecords([recordParams])
+      } else {
+        await indexer.indexRecord(recordParams)
+      }
+    }
+
+    expect(captured.value).not.toBeNull()
+    expect(driver.upsertCalls).toHaveLength(1)
+    const serialized = JSON.stringify({ input: captured.value, document: driver.upsertCalls[0] })
+    expect(serialized).not.toContain('private-')
+    expect(serialized).not.toContain('+48-555-')
+    expect(JSON.stringify(captured.value)).not.toContain('Permitted')
+    expect(driver.upsertCalls[0].tenantId).toBe('tenant-privacy')
+    expect(driver.upsertCalls[0].organizationId).toBe('org-privacy')
+    for (const [, options] of query.mock.calls) {
+      expect(options).toEqual(expect.objectContaining({ tenantId: 'tenant-privacy', organizationId: 'org-privacy' }))
+    }
+  })
+
+  it.each(['excluded', 'hashOnly', 'unlisted'] as const)('does not restore a %s custom summary through vector snapshot fallback', async (protection) => {
+    const driver = createDriver()
+    const service = createService({
+      driver,
+      embeddingService: createEmbeddingService({ value: null }),
+      queryEngine: createQueryEngine({ id: 'snapshot-record', name: 'Safe name', 'cf:summary': 'private-snapshot' }),
+      moduleConfigs: [{ entities: [{
+        entityId: 'demo:item',
+        fieldPolicy: {
+          searchable: protection === 'unlisted' ? ['name'] : ['name', 'summary'],
+          hashOnly: protection === 'hashOnly' ? ['summary'] : [],
+          excluded: protection === 'excluded' ? ['summary'] : [],
+        },
+        buildSource: () => ({ input: 'Safe source', presenter: { title: 'Safe name' }, checksumSource: 'safe-checksum' }),
+      }] }],
+    })
+
+    await service.indexRecord({ entityId: 'demo:item', recordId: 'snapshot-record', tenantId: 'tenant-privacy' })
+    expect(driver.upsertCalls).toHaveLength(1)
+    expect(JSON.stringify(driver.upsertCalls[0])).not.toContain('private-snapshot')
+  })
+})
+
 describe('VectorIndexService encryption fail-closed (issue #2716)', () => {
   const enabledEncryptionThatThrows = (): TenantDataEncryptionService =>
     ({

package/src/di.ts

@@ -95,6 +95,15 @@ export function registerSearchModule(
   container: SearchContainer,
   options?: SearchModuleOptions,
 ): void {
+  const moduleConfigs = (options?.moduleConfigs ?? []).map((moduleConfig) => ({
+    ...moduleConfig,
+    entities: moduleConfig.entities.map((entityConfig) => {
+      const buildSource = entityConfig.buildSource
+      return buildSource
+        ? { ...entityConfig, buildSource: (ctx: Parameters<typeof buildSource>[0]) => buildSource.call(entityConfig, { ...ctx, container }) }
+        : entityConfig
+    }),
+  }))
   const strategies: SearchStrategy[] = []
 
   // Token strategy (always available unless explicitly skipped)
@@ -127,7 +136,7 @@ export function registerSearchModule(
 
   // Build entity config map for field policy resolution
   const entityConfigMap = new Map<EntityId, SearchEntityConfig>()
-  for (const moduleConfig of (options?.moduleConfigs ?? [])) {
+  for (const moduleConfig of moduleConfigs) {
     for (const entityConfig of moduleConfig.entities) {
       if (entityConfig.enabled !== false) {
         entityConfigMap.set(entityConfig.entityId as EntityId, entityConfig)
@@ -226,9 +235,6 @@ export function registerSearchModule(
     presenterEnricher,
   })
 
-  // Create search indexer with module configs
-  const moduleConfigs = options?.moduleConfigs ?? []
-
   // Try to resolve fulltextIndexQueue for queue-based reindexing
   let fulltextQueue: Queue<FulltextIndexJobPayload> | undefined
   try {

package/src/indexer/search-indexer.ts

@@ -191,9 +191,16 @@ export class SearchIndexer {
    * Index a record in the search service.
    */
   async indexRecord(params: IndexRecordParams): Promise<void> {
+    const indexableRecord = await this.buildIndexableRecord(params)
+    if (indexableRecord) {
+      await this.searchService.index(indexableRecord)
+    }
+  }
+
+  private async buildIndexableRecord(params: IndexRecordParams): Promise<IndexableRecord | null> {
     const config = this.entityConfigMap.get(params.entityId)
     if (!config || config.enabled === false) {
-      return // Entity not configured for search
+      return null
     }
 
     const buildContext: SearchBuildContext = {
@@ -205,7 +212,7 @@ export class SearchIndexer {
     }
 
     // Try buildSource first (provides text, presenter, links, checksumSource)
-    let text: string | string[] | undefined
+    let text: string | string[] | undefined = config.buildSource ? [] : undefined
     let presenter: SearchResultPresenter | undefined
     let url: string | undefined
     let links: SearchResultLink[] | undefined
@@ -215,7 +222,7 @@ export class SearchIndexer {
       try {
         const source = await config.buildSource(buildContext)
         if (source) {
-          text = source.text
+          text = source.text ?? []
           if (source.presenter) presenter = source.presenter
           if (source.links) links = source.links
           if (source.checksumSource !== undefined) checksumSource = source.checksumSource
@@ -271,8 +278,7 @@ export class SearchIndexer {
       }
     }
 
-    // Build IndexableRecord
-    const indexableRecord: IndexableRecord = {
+    return {
       entityId: params.entityId,
       recordId: params.recordId,
       tenantId: params.tenantId,
@@ -284,8 +290,6 @@ export class SearchIndexer {
       text,
       checksumSource,
     }
-
-    await this.searchService.index(indexableRecord)
   }
 
   /**
@@ -591,58 +595,10 @@ export class SearchIndexer {
     const indexableRecords: IndexableRecord[] = []
 
     for (const param of params) {
-      const config = this.entityConfigMap.get(param.entityId)
-      if (!config || config.enabled === false) {
-        continue
+      const indexableRecord = await this.buildIndexableRecord(param)
+      if (indexableRecord) {
+        indexableRecords.push(indexableRecord)
       }
-
-      const buildContext: SearchBuildContext = {
-        record: param.record,
-        customFields: param.customFields ?? {},
-        organizationId: param.organizationId,
-        tenantId: param.tenantId,
-      }
-
-      let presenter: SearchResultPresenter | undefined
-      if (config.formatResult) {
-        try {
-          const result = await config.formatResult(buildContext)
-          if (result) presenter = result
-        } catch {
-          // Skip presenter on error
-        }
-      }
-
-      let url: string | undefined
-      if (config.resolveUrl) {
-        try {
-          const result = await config.resolveUrl(buildContext)
-          if (result) url = result
-        } catch {
-          // Skip URL on error
-        }
-      }
-
-      let links: SearchResultLink[] | undefined
-      if (config.resolveLinks) {
-        try {
-          const result = await config.resolveLinks(buildContext)
-          if (result) links = result
-        } catch {
-          // Skip links on error
-        }
-      }
-
-      indexableRecords.push({
-        entityId: param.entityId,
-        recordId: param.recordId,
-        tenantId: param.tenantId,
-        organizationId: param.organizationId,
-        fields: param.record,
-        presenter,
-        url,
-        links,
-      })
     }
 
     if (indexableRecords.length > 0) {
@@ -1171,7 +1127,7 @@ export class SearchIndexer {
       }
 
       // Try buildSource first (provides text, presenter, links, checksumSource)
-      let text: string | string[] | undefined
+      let text: string | string[] | undefined = config.buildSource ? [] : undefined
       let presenter: SearchResultPresenter | undefined
       let url: string | undefined
       let links: SearchResultLink[] | undefined
@@ -1181,7 +1137,7 @@ export class SearchIndexer {
         try {
           const source = await config.buildSource(buildContext)
           if (source) {
-            text = source.text
+            text = source.text ?? []
             if (source.presenter) presenter = source.presenter
             if (source.links) links = source.links
             if (source.checksumSource !== undefined) checksumSource = source.checksumSource

package/src/lib/presenter-enricher.ts

@@ -18,6 +18,7 @@ import {
 } from '@open-mercato/shared/lib/custom-fields/kinds'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 import { extractFallbackPresenter } from './fallback-presenter'
+import { extractSearchableFields } from './field-policy'
 import { needsSearchResultEnrichment } from './search-result-enrichment'
 
 /** Maximum number of record IDs per batch query to avoid hitting DB parameter limits */
@@ -308,7 +309,7 @@ async function computePresenterAndLinks(
 
   // Fallback presenter: extract from doc fields directly
   if (!presenter) {
-    presenter = extractFallbackPresenter(doc, entityId, recordId)
+    presenter = extractFallbackPresenter(extractSearchableFields(doc, { fieldPolicy: config?.fieldPolicy }), entityId, recordId)
   }
 
   // Resolve URL from config

package/src/strategies/vector.strategy.ts

@@ -138,10 +138,10 @@ export class VectorSearchStrategy implements SearchStrategy {
   async index(record: IndexableRecord): Promise<void> {
     await this.ensureReady()
     // Use text from buildSource if available, otherwise fall back to generic extraction
-    const textContent = record.text
+    const textContent = record.text !== undefined
       ? (Array.isArray(record.text) ? record.text.join('\n') : record.text)
       : this.buildTextContent(record)
-    if (!textContent) return
+    if (!textContent.trim()) return
 
     const embedding = await this.embeddingService.createEmbedding(textContent)
 

package/src/vector/services/vector-index.service.ts

@@ -20,6 +20,7 @@ import { computeChecksum } from './checksum'
 import { EmbeddingService } from './embedding'
 import { logVectorOperation } from '../lib/vector-logs'
 import { searchDebug, searchDebugWarn } from '../../lib/debug'
+import { extractSearchableFields } from '../../lib/field-policy'
 
 type ContainerResolver = () => unknown
 const VECTOR_ENTRY_ENCRYPTION_ENTITY_ID = 'vector:vector_search'
@@ -476,10 +477,12 @@ export class VectorIndexService {
       organizationId: resolvedOrgId,
     })
 
-    const normalizedPresenter = this.ensurePresenter(presenter, record, customFields, args.recordId, args.entityId)
+    const metadataRecord = extractSearchableFields(record, { fieldPolicy: entry.config.fieldPolicy })
+    const metadataCustomFields = extractSearchableFields(customFields, { fieldPolicy: entry.config.fieldPolicy })
+    const normalizedPresenter = this.ensurePresenter(presenter, metadataRecord, metadataCustomFields, args.recordId, args.entityId)
     const normalizedLinks = Array.isArray(links) && links.length ? links : null
-    const snapshot = this.deriveSnapshot(record, customFields)
-    const rawResultTitle = this.resolveResultTitle(normalizedPresenter, record, customFields, args.recordId)
+    const snapshot = this.deriveSnapshot(metadataRecord, metadataCustomFields)
+    const rawResultTitle = this.resolveResultTitle(normalizedPresenter, metadataRecord, metadataCustomFields, args.recordId)
     const rawResultSubtitle = normalizedPresenter.subtitle ?? snapshot ?? null
     const rawResultIcon = normalizedPresenter.icon ?? this.mapDefaultIcon(args.entityId)
     const resultBadge = normalizedPresenter.badge ?? null
@@ -761,9 +764,10 @@ export class VectorIndexService {
       if (formatted) return formatted
     }
     if (fallback) return fallback
-    const nameLike = ctx.record.displayName || ctx.record.title || ctx.record.name
+    const fields = extractSearchableFields(ctx.record, { fieldPolicy: config.fieldPolicy })
+    const nameLike = fields.displayName || fields.title || fields.name
     if (typeof nameLike === 'string' && nameLike.trim().length > 0) {
-      const subtitle = ctx.record.description || ctx.record.summary
+      const subtitle = fields.description || fields.summary
       return {
         title: nameLike,
         subtitle: typeof subtitle === 'string' ? subtitle : undefined,