@open-mercato/search 0.6.8-develop.7072.1.19c2a8bbe0 → 0.6.8-develop.7077.1.94f1126c13

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

@@ -198,6 +198,113 @@ describe('GET /api/search/search/global presenter localization', () => {
       expect(result.links?.[0]?.label).toBe('Otwórz osobę')
     }
   })
+
+  // Covers OM_SEARCH_CUSTOMERS_INDEX_BASE_ENTITY=true, where base customer rows are tokenized and
+  // the route can therefore receive both halves of a pair. Under the default the token strategy
+  // never returns the base rows at all (see token-strategy-entity-exclusion.test.ts); the strategy
+  // here is a stub that yields them regardless, so this pins the merge itself.
+  it('merges a customer entity and profile pair into one navigable result when both are indexed', async () => {
+    const rows = [
+      {
+        entity_type: 'customers:customer_entity',
+        entity_id: 'person-entity',
+        doc: { id: 'person-entity', display_name: 'Ada Lovelace', kind: 'person' },
+      },
+      {
+        entity_type: 'customers:customer_person_profile',
+        entity_id: 'person-profile',
+        doc: { id: 'person-profile', entity_id: 'person-entity', display_name: 'Ada Lovelace' },
+      },
+      {
+        entity_type: 'customers:customer_entity',
+        entity_id: 'company-entity',
+        doc: { id: 'company-entity', display_name: 'Analytical Engines', kind: 'company' },
+      },
+      {
+        entity_type: 'customers:customer_company_profile',
+        entity_id: 'company-profile',
+        doc: { id: 'company-profile', entity_id: 'company-entity', display_name: 'Analytical Engines' },
+      },
+      {
+        entity_type: 'orders:order',
+        entity_id: 'order-1',
+        doc: { id: 'order-1', title: 'Order 1' },
+      },
+    ]
+    const personEntityId = 'customers:customer_person_profile' as EntityId
+    const companyEntityId = 'customers:customer_company_profile' as EntityId
+    const configMap = new Map<EntityId, SearchEntityConfig>([
+      [personEntityId, {
+        entityId: personEntityId,
+        formatResult: async (context) => ({ title: String(context.record.display_name) }),
+        resolveUrl: async (context) => `/backend/customers/people-v2/${String(context.record.entity_id)}`,
+      }],
+      [companyEntityId, {
+        entityId: companyEntityId,
+        formatResult: async (context) => ({ title: String(context.record.display_name) }),
+        resolveUrl: async (context) => `/backend/customers/companies-v2/${String(context.record.entity_id)}`,
+      }],
+    ])
+    const scoresByRecordId: Record<string, number> = {
+      'person-profile': 0.95,
+      'company-profile': 0.85,
+      'order-1': 0.5,
+      'person-entity': 0.2,
+      'company-entity': 0.1,
+    }
+    const results: SearchResult[] = rows
+      .map((row) => ({
+        entityId: row.entity_type as EntityId,
+        recordId: row.entity_id,
+        organizationId: 'org-1',
+        score: scoresByRecordId[row.entity_id] ?? 0,
+        source: 'tokens' as const,
+      }))
+      .sort((left, right) => right.score - left.score)
+    const strategy: SearchStrategy = {
+      id: 'tokens',
+      name: 'tokens',
+      priority: 10,
+      isAvailable: async () => true,
+      ensureReady: async () => undefined,
+      search: async () => results,
+      index: async () => undefined,
+      delete: async () => undefined,
+    }
+    const searchService = new SearchService({
+      strategies: [strategy],
+      defaultStrategies: ['tokens'],
+      presenterEnricher: createPresenterEnricher(createDatabase(rows), configMap),
+    })
+    mockCreateRequestContainer.mockResolvedValue(
+      createContainer(searchService, configMap, { features: ['search.global'], isSuperAdmin: true }),
+    )
+
+    const response = await GET(new Request('http://localhost/api/search/search/global?q=customer'))
+    const body = await response.json() as { results: SearchResult[] }
+
+    expect(response.status).toBe(200)
+    expect(body.results).toEqual([
+      expect.objectContaining({
+        entityId: 'customers:customer_entity',
+        recordId: 'person-entity',
+        presenter: expect.objectContaining({ title: 'Ada Lovelace' }),
+        url: '/backend/customers/people-v2/person-entity',
+      }),
+      expect.objectContaining({
+        entityId: 'customers:customer_entity',
+        recordId: 'company-entity',
+        presenter: expect.objectContaining({ title: 'Analytical Engines' }),
+        url: '/backend/customers/companies-v2/company-entity',
+      }),
+      expect.objectContaining({
+        entityId: 'orders:order',
+        recordId: 'order-1',
+      }),
+    ])
+    expect(body.results[0]?.score).toBeGreaterThan(body.results[1]?.score ?? 0)
+    expect(body.results[1]?.score).toBeGreaterThan(body.results[2]?.score ?? 0)
+  })
 })
 
 describe('GET /api/search/search/global per-entity access control', () => {

package/src/strategies/token.strategy.ts

@@ -67,10 +67,21 @@ export class TokenSearchStrategy implements SearchStrategy {
     // Dynamically import tokenization to avoid circular dependencies
     const { tokenizeText } = await import('@open-mercato/shared/lib/search/tokenize')
     const { resolveSearchConfig } = await import('@open-mercato/shared/lib/search/config')
+    const { listSearchTokenExcludedEntityTypes } = await import(
+      '@open-mercato/core/modules/query_index/lib/search-entity-policy'
+    )
 
     const config = resolveSearchConfig()
     if (!config.enabled) return []
 
+    // The rows themselves stay in `search_tokens` — list routes and the query engines' encrypted
+    // like/ilike rewrite depend on them — so the exclusion is enforced here, at read time.
+    const excludedEntityTypes = listSearchTokenExcludedEntityTypes()
+    const requestedEntityTypes = options.entityTypes?.length
+      ? options.entityTypes.filter((entityType) => !excludedEntityTypes.includes(entityType))
+      : undefined
+    if (options.entityTypes?.length && !requestedEntityTypes?.length) return []
+
     const { hashes } = tokenizeText(query, config)
     if (hashes.length === 0) return []
 
@@ -96,8 +107,10 @@ export class TokenSearchStrategy implements SearchStrategy {
       queryBuilder = queryBuilder.where('organization_id' as any, 'in', organizationIds)
     }
 
-    if (options.entityTypes?.length) {
-      queryBuilder = queryBuilder.where('entity_type' as any, 'in', options.entityTypes)
+    if (requestedEntityTypes?.length) {
+      queryBuilder = queryBuilder.where('entity_type' as any, 'in', requestedEntityTypes)
+    } else if (excludedEntityTypes.length) {
+      queryBuilder = queryBuilder.where('entity_type' as any, 'not in', excludedEntityTypes)
     }
 
     const rows = await queryBuilder.execute() as Array<{