@open-mercato/core 0.9.1-develop.7474.1.51db10479d → 0.9.1-develop.7475.1.28ca93ed97

package/src/modules/catalog/lib/omnibusCache.ts

@@ -0,0 +1,111 @@
+import { runWithCacheTenant, type CacheStrategy } from '@open-mercato/cache'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+export const OMNIBUS_CACHE_TTL_MS = 5 * 60 * 1000
+
+const OMNIBUS_CACHE_PREFIX = 'catalog:omnibus'
+
+const logger = createLogger('catalog')
+
+export type OmnibusCacheScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type OmnibusCacheTargets = {
+  productId?: string | null
+  variantId?: string | null
+  offerId?: string | null
+}
+
+export type OmnibusInvalidationTarget = OmnibusCacheScope & OmnibusCacheTargets
+
+type ContainerLike = { resolve: <T = unknown>(name: string) => T }
+
+export function resolveOmnibusCache(container: ContainerLike | null | undefined): CacheStrategy | null {
+  if (!container) return null
+  try {
+    return container.resolve<CacheStrategy>('cache') ?? null
+  } catch {
+    return null
+  }
+}
+
+export function omnibusTenantWideTag(tenantId: string): string {
+  return `${OMNIBUS_CACHE_PREFIX}:${tenantId}`
+}
+
+export function omnibusTenantTag(scope: OmnibusCacheScope): string {
+  return `${OMNIBUS_CACHE_PREFIX}:${scope.tenantId}:${scope.organizationId}`
+}
+
+export function omnibusTargetTags(scope: OmnibusCacheScope, targets: OmnibusCacheTargets): string[] {
+  const base = omnibusTenantTag(scope)
+  const tags: string[] = []
+  if (targets.productId) tags.push(`${base}:product:${targets.productId}`)
+  if (targets.variantId) tags.push(`${base}:variant:${targets.variantId}`)
+  if (targets.offerId) tags.push(`${base}:offer:${targets.offerId}`)
+  return tags
+}
+
+export function buildOmnibusCacheTags(scope: OmnibusCacheScope, targets: OmnibusCacheTargets): string[] {
+  return [omnibusTenantWideTag(scope.tenantId), omnibusTenantTag(scope), ...omnibusTargetTags(scope, targets)]
+}
+
+export function buildOmnibusCacheKey(kind: string, parts: Array<string | number | null | undefined>): string {
+  return [OMNIBUS_CACHE_PREFIX, 'v1', kind, ...parts.map((part) => (part === null || part === undefined ? '-' : String(part)))].join(':')
+}
+
+export async function readOmnibusCache<T>(cache: CacheStrategy | null, tenantId: string, key: string): Promise<T | null> {
+  if (!cache) return null
+  try {
+    const value = await runWithCacheTenant(tenantId, () => cache.get(key))
+    return value === null || value === undefined ? null : (value as T)
+  } catch {
+    return null
+  }
+}
+
+export async function writeOmnibusCache(
+  cache: CacheStrategy | null,
+  tenantId: string,
+  key: string,
+  value: unknown,
+  tags: string[],
+): Promise<void> {
+  if (!cache) return
+  try {
+    await runWithCacheTenant(tenantId, () => cache.set(key, value, { ttl: OMNIBUS_CACHE_TTL_MS, tags }))
+  } catch {}
+}
+
+export async function invalidateOmnibusCache(
+  cache: CacheStrategy | null | undefined,
+  targets: OmnibusInvalidationTarget[],
+): Promise<void> {
+  if (!cache || !targets.length) return
+  const tagsByTenant = new Map<string, Set<string>>()
+  for (const target of targets) {
+    const tags = omnibusTargetTags(target, target)
+    if (!tags.length) continue
+    const bucket = tagsByTenant.get(target.tenantId) ?? new Set<string>()
+    for (const tag of tags) bucket.add(tag)
+    tagsByTenant.set(target.tenantId, bucket)
+  }
+  for (const [tenantId, tags] of tagsByTenant) {
+    try {
+      await runWithCacheTenant(tenantId, () => cache.deleteByTags(Array.from(tags)))
+    } catch (err) {
+      logger.warn('[internal] catalog omnibus cache invalidation failed', { tenantId, err })
+    }
+  }
+}
+
+export async function invalidateOmnibusTenantCache(cache: CacheStrategy | null | undefined, tenantId: string): Promise<void> {
+  if (!cache) return
+  try {
+    await runWithCacheTenant(tenantId, () => cache.deleteByTags([omnibusTenantWideTag(tenantId)]))
+  } catch (err) {
+    logger.warn('[internal] catalog omnibus tenant cache invalidation failed', { tenantId, err })
+  }
+}

package/src/modules/catalog/lib/omnibusConfig.ts

@@ -0,0 +1,73 @@
+import type { z } from 'zod'
+import type { OmnibusConfigPatch } from '../data/validators'
+import { omnibusConfigSchema, type OmnibusConfig } from './omnibusTypes'
+
+export type OmnibusConfigFieldErrors = Record<string, string[]>
+
+export type OmnibusConfigEvaluation =
+  | { ok: true; config: OmnibusConfig }
+  | { ok: false; status: 400; body: { error: string; details: { fieldErrors: OmnibusConfigFieldErrors } } }
+  | { ok: false; status: 422; body: { field: 'enabled'; error: 'backfill_required_before_enable'; channels: string[] } }
+
+export function parseStoredOmnibusConfig(raw: unknown): OmnibusConfig | null {
+  if (raw === null || raw === undefined) return null
+  const parsed = omnibusConfigSchema.safeParse(raw)
+  return parsed.success ? parsed.data : null
+}
+
+export function buildOmnibusFieldErrors(issues: z.core.$ZodIssue[]): OmnibusConfigFieldErrors {
+  const fieldErrors: OmnibusConfigFieldErrors = {}
+  for (const issue of issues) {
+    const basePath = issue.path.map((segment) => String(segment)).join('.')
+    const keys = issue.code === 'unrecognized_keys' ? issue.keys : null
+    const paths = keys ? keys.map((key) => (basePath ? `${basePath}.${key}` : key)) : [basePath || '_root']
+    for (const path of paths) {
+      const bucket = fieldErrors[path] ?? []
+      bucket.push(keys ? 'omnibus_field_not_supported' : issue.message)
+      fieldErrors[path] = bucket
+    }
+  }
+  return fieldErrors
+}
+
+export function invalidOmnibusConfig(fieldErrors: OmnibusConfigFieldErrors): OmnibusConfigEvaluation {
+  return { ok: false, status: 400, body: { error: 'Invalid config', details: { fieldErrors } } }
+}
+
+export function mergeOmnibusConfig(existing: OmnibusConfig | null, patch: OmnibusConfigPatch): OmnibusConfig {
+  const next: Record<string, unknown> = { ...(existing ?? {}) }
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined || key === 'backfillCoverage') continue
+    if (value === null) {
+      delete next[key]
+      continue
+    }
+    next[key] = value
+  }
+  return omnibusConfigSchema.parse(next)
+}
+
+export function listInScopeOmnibusChannels(config: OmnibusConfig): string[] {
+  const enabledCountries = new Set(config.enabledCountryCodes)
+  return Object.entries(config.channels)
+    .filter(([, channel]) => Boolean(channel.countryCode && enabledCountries.has(channel.countryCode)))
+    .map(([channelId]) => channelId)
+    .sort((left, right) => (left < right ? -1 : left > right ? 1 : 0))
+}
+
+export function evaluateOmnibusConfig(config: OmnibusConfig): OmnibusConfigEvaluation {
+  if (!config.enabled) return { ok: true, config }
+  const inScope = listInScopeOmnibusChannels(config)
+  if (!config.defaultPresentedPriceKindId && inScope.length === 0) {
+    return invalidOmnibusConfig({ defaultPresentedPriceKindId: ['omnibus_presented_price_kind_required'] })
+  }
+  const uncovered = inScope.filter((channelId) => !config.backfillCoverage[channelId])
+  if (uncovered.length > 0) {
+    return {
+      ok: false,
+      status: 422,
+      body: { field: 'enabled', error: 'backfill_required_before_enable', channels: uncovered },
+    }
+  }
+  return { ok: true, config }
+}

package/src/modules/catalog/lib/omnibusHistoryQueries.ts

@@ -0,0 +1,248 @@
+import { sql, type RawBuilder } from 'kysely'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { OMNIBUS_PRICE_REMOVING_UNDO_COMMAND } from './omnibusTypes'
+
+export const OMNIBUS_IN_WINDOW_LIMIT = 1000
+
+export type OmnibusScopeColumn = 'product_id' | 'variant_id' | 'offer_id'
+
+export type OmnibusWindowLookup = {
+  tenantId: string
+  organizationId: string
+  scopeColumn: OmnibusScopeColumn
+  scopeId: string
+  priceKindId: string
+  currencyCode: string
+  channelId: string | null
+  windowStart: Date
+  windowEnd: Date
+}
+
+export type OmnibusWindowLookupResult = {
+  baselineId: string | null
+  inWindowIds: string[]
+}
+
+export type OmnibusFirstOfferLookup = {
+  tenantId: string
+  organizationId: string
+  offerId: string
+  priceKindId: string
+  currencyCode: string
+  channelId: string | null
+}
+
+type LookupRow = { ord: string | number; part: string; id: string }
+
+type FirstOfferRow = { ord: string | number; id: string }
+
+const SCOPE_COLUMNS: Record<OmnibusScopeColumn, RawBuilder<unknown>> = {
+  product_id: sql.ref('h.product_id'),
+  variant_id: sql.ref('h.variant_id'),
+  offer_id: sql.ref('h.offer_id'),
+}
+
+const SCOPE_LEVEL_CLAUSES: Record<OmnibusScopeColumn, RawBuilder<unknown>> = {
+  product_id: sql`AND h.variant_id IS NULL`,
+  variant_id: sql``,
+  offer_id: sql``,
+}
+
+const OBSERVATION_CLAUSE = sql`AND h.change_type <> 'delete'
+        AND NOT (h.change_type = 'undo' AND h.metadata->>'undoneCommand' = ${OMNIBUS_PRICE_REMOVING_UNDO_COMMAND})`
+
+const NOT_ENDED_BEFORE_WINDOW_CLAUSE = sql`AND NOT EXISTS (
+          SELECT 1 FROM catalog_price_history_entries ended
+          WHERE ended.tenant_id = h.tenant_id
+            AND ended.organization_id = h.organization_id
+            AND ended.price_id = h.price_id
+            AND ended.recorded_at > h.recorded_at
+            AND ended.recorded_at <= w.window_start
+            AND (
+              ended.change_type = 'delete'
+              OR (ended.change_type = 'undo' AND ended.metadata->>'undoneCommand' = ${OMNIBUS_PRICE_REMOVING_UNDO_COMMAND})
+            )
+        )`
+
+function lookupGroupKey(lookup: OmnibusWindowLookup): string {
+  return `${lookup.scopeColumn}|${lookup.channelId ? 'channel' : 'any'}`
+}
+
+function kyselyFor(em: EntityManager) {
+  return em.fork().getKysely()
+}
+
+async function runWindowGroup(
+  em: EntityManager,
+  scopeColumn: OmnibusScopeColumn,
+  withChannel: boolean,
+  lookups: OmnibusWindowLookup[],
+): Promise<LookupRow[]> {
+  const scopeRef = SCOPE_COLUMNS[scopeColumn]
+  const scopeLevelClause = SCOPE_LEVEL_CLAUSES[scopeColumn]
+  const channelClause = withChannel ? sql`AND (h.channel_id = w.channel_id OR h.channel_id IS NULL)` : sql``
+  const tenantIds = lookups.map((lookup) => lookup.tenantId)
+  const organizationIds = lookups.map((lookup) => lookup.organizationId)
+  const scopeIds = lookups.map((lookup) => lookup.scopeId)
+  const priceKindIds = lookups.map((lookup) => lookup.priceKindId)
+  const currencyCodes = lookups.map((lookup) => lookup.currencyCode)
+  const channelIds = lookups.map((lookup) => lookup.channelId)
+  const windowStarts = lookups.map((lookup) => lookup.windowStart.toISOString())
+  const windowEnds = lookups.map((lookup) => lookup.windowEnd.toISOString())
+  const query = sql<LookupRow>`
+    WITH w AS (
+      SELECT * FROM unnest(
+        ${tenantIds}::uuid[],
+        ${organizationIds}::uuid[],
+        ${scopeIds}::uuid[],
+        ${priceKindIds}::uuid[],
+        ${currencyCodes}::text[],
+        ${channelIds}::uuid[],
+        ${windowStarts}::timestamptz[],
+        ${windowEnds}::timestamptz[]
+      ) WITH ORDINALITY AS t(tenant_id, organization_id, scope_id, price_kind_id, currency_code, channel_id, window_start, window_end, ord)
+    )
+    SELECT w.ord, 'baseline' AS part, baseline.id
+    FROM w
+    CROSS JOIN LATERAL (
+      SELECT h.id FROM catalog_price_history_entries h
+      WHERE h.tenant_id = w.tenant_id
+        AND h.organization_id = w.organization_id
+        AND ${scopeRef} = w.scope_id
+        ${scopeLevelClause}
+        ${channelClause}
+        AND h.price_kind_id = w.price_kind_id
+        AND h.currency_code = w.currency_code
+        ${OBSERVATION_CLAUSE}
+        AND h.recorded_at <= w.window_start
+        ${NOT_ENDED_BEFORE_WINDOW_CLAUSE}
+      ORDER BY h.recorded_at DESC, h.id DESC
+      LIMIT 1
+    ) baseline
+    UNION ALL
+    SELECT w.ord, 'window' AS part, in_window.id
+    FROM w
+    CROSS JOIN LATERAL (
+      SELECT h.id FROM catalog_price_history_entries h
+      WHERE h.tenant_id = w.tenant_id
+        AND h.organization_id = w.organization_id
+        AND ${scopeRef} = w.scope_id
+        ${scopeLevelClause}
+        ${channelClause}
+        AND h.price_kind_id = w.price_kind_id
+        AND h.currency_code = w.currency_code
+        ${OBSERVATION_CLAUSE}
+        AND h.recorded_at > w.window_start
+        AND h.recorded_at <= w.window_end
+      ORDER BY h.recorded_at DESC, h.id DESC
+      LIMIT ${OMNIBUS_IN_WINDOW_LIMIT}
+    ) in_window
+  `
+  const result = await query.execute(kyselyFor(em))
+  return result.rows
+}
+
+export async function fetchOmnibusWindowIds(
+  em: EntityManager,
+  lookups: OmnibusWindowLookup[],
+): Promise<OmnibusWindowLookupResult[]> {
+  const results: OmnibusWindowLookupResult[] = lookups.map(() => ({ baselineId: null, inWindowIds: [] }))
+  const groups = new Map<string, number[]>()
+  lookups.forEach((lookup, index) => {
+    const key = lookupGroupKey(lookup)
+    const bucket = groups.get(key) ?? []
+    bucket.push(index)
+    groups.set(key, bucket)
+  })
+  for (const indexes of groups.values()) {
+    const groupLookups = indexes.map((index) => lookups[index])
+    const first = groupLookups[0]
+    const rows = await runWindowGroup(em, first.scopeColumn, Boolean(first.channelId), groupLookups)
+    for (const row of rows) {
+      const target = results[indexes[Number(row.ord) - 1]]
+      if (!target) continue
+      if (row.part === 'baseline') target.baselineId = row.id
+      else target.inWindowIds.push(row.id)
+    }
+  }
+  return results
+}
+
+export async function fetchOmnibusFirstOfferIds(
+  em: EntityManager,
+  lookups: OmnibusFirstOfferLookup[],
+): Promise<Array<string | null>> {
+  if (!lookups.length) return []
+  const query = sql<FirstOfferRow>`
+    WITH w AS (
+      SELECT * FROM unnest(
+        ${lookups.map((lookup) => lookup.tenantId)}::uuid[],
+        ${lookups.map((lookup) => lookup.organizationId)}::uuid[],
+        ${lookups.map((lookup) => lookup.offerId)}::uuid[],
+        ${lookups.map((lookup) => lookup.priceKindId)}::uuid[],
+        ${lookups.map((lookup) => lookup.currencyCode)}::text[],
+        ${lookups.map((lookup) => lookup.channelId)}::uuid[]
+      ) WITH ORDINALITY AS t(tenant_id, organization_id, offer_id, price_kind_id, currency_code, channel_id, ord)
+    )
+    SELECT w.ord, first_offer.id
+    FROM w
+    CROSS JOIN LATERAL (
+      SELECT h.id FROM catalog_price_history_entries h
+      WHERE h.tenant_id = w.tenant_id
+        AND h.organization_id = w.organization_id
+        AND h.offer_id = w.offer_id
+        AND h.price_kind_id = w.price_kind_id
+        AND h.currency_code = w.currency_code
+        AND (h.channel_id = w.channel_id OR h.channel_id IS NULL)
+        ${OBSERVATION_CLAUSE}
+      ORDER BY h.recorded_at ASC, h.id ASC
+      LIMIT 1
+    ) first_offer
+  `
+  const result = await query.execute(kyselyFor(em))
+  const ids: Array<string | null> = lookups.map(() => null)
+  for (const row of result.rows) {
+    const index = Number(row.ord) - 1
+    if (index >= 0 && index < ids.length) ids[index] = row.id
+  }
+  return ids
+}
+
+export type OmnibusLatestPriceEntryLookup = {
+  tenantId: string
+  organizationId: string
+  priceId: string
+}
+
+export async function fetchOmnibusLatestPriceEntryIds(
+  em: EntityManager,
+  lookups: OmnibusLatestPriceEntryLookup[],
+): Promise<Array<string | null>> {
+  if (!lookups.length) return []
+  const query = sql<FirstOfferRow>`
+    WITH w AS (
+      SELECT * FROM unnest(
+        ${lookups.map((lookup) => lookup.tenantId)}::uuid[],
+        ${lookups.map((lookup) => lookup.organizationId)}::uuid[],
+        ${lookups.map((lookup) => lookup.priceId)}::uuid[]
+      ) WITH ORDINALITY AS t(tenant_id, organization_id, price_id, ord)
+    )
+    SELECT w.ord, latest.id
+    FROM w
+    CROSS JOIN LATERAL (
+      SELECT h.id FROM catalog_price_history_entries h
+      WHERE h.tenant_id = w.tenant_id
+        AND h.organization_id = w.organization_id
+        AND h.price_id = w.price_id
+      ORDER BY h.recorded_at DESC, h.id DESC
+      LIMIT 1
+    ) latest
+  `
+  const result = await query.execute(kyselyFor(em))
+  const ids: Array<string | null> = lookups.map(() => null)
+  for (const row of result.rows) {
+    const index = Number(row.ord) - 1
+    if (index >= 0 && index < ids.length) ids[index] = row.id
+  }
+  return ids
+}

package/src/modules/catalog/lib/omnibusPresentedEntry.ts

@@ -0,0 +1,76 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CatalogPriceHistoryEntry } from '../data/entities'
+import { fetchOmnibusLatestPriceEntryIds } from './omnibusHistoryQueries'
+import type { OmnibusPresentedEntry } from './omnibusTypes'
+import { resolvePriceOfferId, type PriceRow } from './pricing'
+
+export function isPromotionPriceKind(price: PriceRow | null | undefined): boolean {
+  if (!price || !price.priceKind || typeof price.priceKind === 'string') return false
+  return price.priceKind.isPromotion === true
+}
+
+function fallbackPresentedEntry(price: PriceRow): OmnibusPresentedEntry {
+  return {
+    priceId: price.id,
+    changeType: 'update',
+    recordedAt: price.updatedAt ?? price.createdAt ?? new Date(),
+    startsAt: price.startsAt ?? null,
+    offerId: resolvePriceOfferId(price),
+    isAnnounced: null,
+  }
+}
+
+export async function resolveOmnibusPresentedEntries(
+  em: EntityManager,
+  prices: PriceRow[],
+): Promise<Map<string, OmnibusPresentedEntry>> {
+  const entries = new Map<string, OmnibusPresentedEntry>()
+  const unique = new Map<string, PriceRow>()
+  for (const price of prices) {
+    if (price?.id && !unique.has(price.id)) unique.set(price.id, price)
+  }
+  if (!unique.size) return entries
+  const priced = Array.from(unique.values())
+  const ids = await fetchOmnibusLatestPriceEntryIds(
+    em,
+    priced.map((price) => ({ tenantId: price.tenantId, organizationId: price.organizationId, priceId: price.id })),
+  )
+  const idsByScope = new Map<string, { tenantId: string; organizationId: string; ids: string[] }>()
+  priced.forEach((price, index) => {
+    const id = ids[index]
+    if (!id) return
+    const key = `${price.tenantId}|${price.organizationId}`
+    const bucket = idsByScope.get(key) ?? { tenantId: price.tenantId, organizationId: price.organizationId, ids: [] }
+    bucket.ids.push(id)
+    idsByScope.set(key, bucket)
+  })
+  const rows = new Map<string, CatalogPriceHistoryEntry>()
+  for (const scope of idsByScope.values()) {
+    const found = await findWithDecryption(
+      em,
+      CatalogPriceHistoryEntry,
+      { id: { $in: scope.ids }, tenantId: scope.tenantId, organizationId: scope.organizationId },
+      undefined,
+      { tenantId: scope.tenantId, organizationId: scope.organizationId },
+    )
+    for (const row of found) rows.set(row.id, row)
+  }
+  priced.forEach((price, index) => {
+    const id = ids[index]
+    const row = id ? rows.get(id) : undefined
+    if (!row || row.priceId !== price.id) {
+      entries.set(price.id, fallbackPresentedEntry(price))
+      return
+    }
+    entries.set(price.id, {
+      priceId: price.id,
+      changeType: row.changeType,
+      recordedAt: row.recordedAt,
+      startsAt: row.startsAt ?? price.startsAt ?? null,
+      offerId: row.offerId ?? resolvePriceOfferId(price),
+      isAnnounced: row.isAnnounced ?? null,
+    })
+  })
+  return entries
+}

package/src/modules/catalog/lib/omnibusProductListEnrichment.ts

@@ -0,0 +1,125 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
+import type { CatalogOmnibusService } from '../services/catalogOmnibusService'
+import type { OmnibusBlock, OmnibusConfig, OmnibusResolutionRequest } from './omnibusTypes'
+import { isPromotionPriceKind, resolveOmnibusPresentedEntries } from './omnibusPresentedEntry'
+import {
+  resolvePriceChannelId,
+  resolvePriceKindId,
+  resolvePriceVariantId,
+  selectBestPrice,
+  type PriceRow,
+  type PricingContext,
+} from './pricing'
+
+const logger = createLogger('catalog')
+
+export type OmnibusProductListEntry = {
+  item: { omnibus?: OmnibusBlock }
+  productId: string
+  candidates: PriceRow[]
+  best: PriceRow
+  context: PricingContext
+}
+
+export type AttachProductListOmnibusParams = {
+  em: EntityManager
+  container: { resolve: <T = unknown>(name: string) => T }
+  tenantId: string | null | undefined
+  entries: OmnibusProductListEntry[]
+}
+
+type EnabledEntry = OmnibusProductListEntry & {
+  config: OmnibusConfig
+  channelId: string | null
+  presentedPriceKindId: string | null
+  presentedPrice: PriceRow | null
+}
+
+async function loadEnabledConfigs(
+  service: CatalogOmnibusService,
+  tenantId: string,
+  organizationIds: string[],
+): Promise<Map<string, OmnibusConfig>> {
+  const configs = await Promise.all(
+    organizationIds.map((organizationId) => service.getConfig({ tenantId, organizationId })),
+  )
+  const enabled = new Map<string, OmnibusConfig>()
+  organizationIds.forEach((organizationId, index) => {
+    const config = configs[index]
+    if (config && config.enabled === true) enabled.set(organizationId, config)
+  })
+  return enabled
+}
+
+function selectPresentedPrice(entry: OmnibusProductListEntry, presentedPriceKindId: string | null): PriceRow | null {
+  if (!presentedPriceKindId || presentedPriceKindId === resolvePriceKindId(entry.best)) return entry.best
+  return selectBestPrice(entry.candidates, {
+    ...entry.context,
+    priceKindId: presentedPriceKindId,
+    currencyCode: entry.best.currencyCode,
+  })
+}
+
+export async function attachProductListOmnibusBlocks(params: AttachProductListOmnibusParams): Promise<void> {
+  const { em, container, entries } = params
+  const tenantId = params.tenantId ?? null
+  if (!tenantId || !entries.length) return
+  try {
+    const service = container.resolve<CatalogOmnibusService>('catalogOmnibusService')
+    const organizationIds = Array.from(new Set(entries.map((entry) => entry.best.organizationId).filter(Boolean)))
+    const configs = await loadEnabledConfigs(service, tenantId, organizationIds)
+    if (!configs.size) return
+    const enabled: EnabledEntry[] = []
+    for (const entry of entries) {
+      const config = configs.get(entry.best.organizationId)
+      if (!config) continue
+      const channelId = entry.context.channelId ?? resolvePriceChannelId(entry.best) ?? null
+      const presentedPriceKindId = service.resolvePresentedPriceKindId(config, channelId, resolvePriceKindId(entry.best))
+      enabled.push({
+        ...entry,
+        config,
+        channelId,
+        presentedPriceKindId,
+        presentedPrice: selectPresentedPrice(entry, presentedPriceKindId),
+      })
+    }
+    if (!enabled.length) return
+    const presentedEntries = await resolveOmnibusPresentedEntries(
+      em,
+      enabled.map((entry) => entry.presentedPrice).filter((price): price is PriceRow => price !== null),
+    )
+    const requests: OmnibusResolutionRequest[] = enabled.map((entry) => ({
+      context: {
+        tenantId,
+        organizationId: entry.best.organizationId,
+        productId: entry.productId,
+        variantId: entry.presentedPrice ? resolvePriceVariantId(entry.presentedPrice) : null,
+        offerId: entry.context.offerId ?? null,
+        channelId: entry.channelId,
+        priceKindId: entry.presentedPriceKindId,
+        currencyCode: entry.presentedPrice?.currencyCode ?? entry.best.currencyCode,
+        isStorefront: false,
+      },
+      presentedEntry: entry.presentedPrice ? presentedEntries.get(entry.presentedPrice.id) ?? null : null,
+      priceKindIsPromotion: isPromotionPriceKind(entry.presentedPrice),
+    }))
+    const blocks = await service.resolveOmnibusBlocks(em, requests)
+    enabled.forEach((entry, index) => {
+      const block = blocks[index]
+      if (block) entry.item.omnibus = block
+    })
+  } catch (err) {
+    logger.error('[internal] catalog products omnibus enrichment failed', {
+      tenantId,
+      productCount: entries.length,
+      err,
+    })
+    getTelemetryRuntime()?.reportError(err, {
+      module: 'catalog',
+      code: 'catalog.omnibus_list_enrichment_failed',
+      attributes: { productCount: entries.length },
+    })
+  }
+}