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

package/src/modules/catalog/components/PriceEditorOmnibusRow.tsx

@@ -0,0 +1,219 @@
+"use client"
+
+import * as React from 'react'
+import { Spinner } from '@open-mercato/ui/primitives/spinner'
+import { StatusBadge, type StatusBadgeVariant } from '@open-mercato/ui/primitives/status-badge'
+import { useBackendChrome } from '@open-mercato/ui/backend/BackendChromeProvider'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { hasFeature } from '@open-mercato/shared/security/features'
+import { useLocale, useT } from '@open-mercato/shared/lib/i18n/context'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
+import type { OmnibusApplicabilityReason, OmnibusBlock } from '../lib/omnibusTypes'
+
+const logger = createLogger('catalog').child({ component: 'PriceEditorOmnibusRow' })
+
+const PRICE_HISTORY_VIEW_FEATURE = 'catalog.price_history.view'
+
+const NOT_APPLICABLE_REASONS: ReadonlySet<OmnibusApplicabilityReason> = new Set([
+  'no_history',
+  'not_in_eu_market',
+  'missing_channel_context',
+  'perishable_exempt',
+])
+
+const REASON_VARIANTS: Record<OmnibusApplicabilityReason, StatusBadgeVariant> = {
+  no_history: 'neutral',
+  not_in_eu_market: 'neutral',
+  missing_channel_context: 'warning',
+  insufficient_history: 'warning',
+  announced_promotion: 'info',
+  not_announced: 'neutral',
+  progressive_reduction_frozen: 'info',
+  perishable_exempt: 'neutral',
+  perishable_last_price: 'info',
+  new_arrival_reduced_window: 'info',
+}
+
+type PreviewState =
+  | { status: 'loading' }
+  | { status: 'hidden' }
+  | { status: 'error' }
+  | { status: 'ready'; block: OmnibusBlock }
+
+export type PriceEditorOmnibusRowProps = {
+  priceKindId: string
+  currencyCode: string | null | undefined
+  productId?: string | null
+  variantId?: string | null
+  offerId?: string | null
+  channelId?: string | null
+  channelSelectable?: boolean
+}
+
+function isOmnibusBlock(value: unknown): value is OmnibusBlock {
+  if (!value || typeof value !== 'object') return false
+  const candidate = value as Partial<OmnibusBlock>
+  return typeof candidate.applicabilityReason === 'string' && typeof candidate.lookbackDays === 'number'
+}
+
+function pickAxisAmount(block: OmnibusBlock, net: string | null, gross: string | null): string | null {
+  return block.minimizationAxis === 'net' ? net ?? gross : gross ?? net
+}
+
+function formatAmount(amount: string | null, currencyCode: string, locale: string): string | null {
+  if (!amount) return null
+  const numeric = Number(amount)
+  const code = currencyCode.toUpperCase()
+  if (!Number.isFinite(numeric)) return `${code} ${amount}`
+  try {
+    return new Intl.NumberFormat(locale, { style: 'currency', currency: code }).format(numeric)
+  } catch {
+    const formatted = new Intl.NumberFormat(locale, { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(numeric)
+    return `${code} ${formatted}`
+  }
+}
+
+function formatDate(value: string | null, locale: string): string | null {
+  if (!value) return null
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? value : new Intl.DateTimeFormat(locale, { dateStyle: 'medium' }).format(date)
+}
+
+export function PriceEditorOmnibusRow({
+  priceKindId,
+  currencyCode,
+  productId,
+  variantId,
+  offerId,
+  channelId,
+  channelSelectable = true,
+}: PriceEditorOmnibusRowProps) {
+  const t = useT()
+  const locale = useLocale()
+  const { payload: chromePayload, isReady: chromeReady } = useBackendChrome()
+  const canView = chromeReady && hasFeature(chromePayload?.grantedFeatures, PRICE_HISTORY_VIEW_FEATURE)
+  const normalizedCurrency = typeof currencyCode === 'string' ? currencyCode.trim().toUpperCase() : ''
+  const hasTarget = Boolean(productId || variantId || offerId)
+  const [state, setState] = React.useState<PreviewState>({ status: 'loading' })
+
+  React.useEffect(() => {
+    if (!canView || !hasTarget || !priceKindId || !normalizedCurrency) {
+      setState({ status: 'hidden' })
+      return
+    }
+    let cancelled = false
+    setState({ status: 'loading' })
+    const params = new URLSearchParams({ priceKindId, currencyCode: normalizedCurrency })
+    if (productId) params.set('productId', productId)
+    if (variantId) params.set('variantId', variantId)
+    if (offerId) params.set('offerId', offerId)
+    if (channelId) params.set('channelId', channelId)
+    apiCall<unknown>(`/api/catalog/prices/omnibus-preview?${params.toString()}`)
+      .then((call) => {
+        if (cancelled) return
+        if (!call.ok) {
+          setState(call.status === 403 || call.status === 404 ? { status: 'hidden' } : { status: 'error' })
+          return
+        }
+        setState(isOmnibusBlock(call.result) ? { status: 'ready', block: call.result } : { status: 'hidden' })
+      })
+      .catch((err) => {
+        logger.error('catalog.omnibus.preview.load failed', { err })
+        getTelemetryRuntime()?.reportError(err, { module: 'catalog', code: 'catalog.omnibus_preview_load_failed' })
+        if (!cancelled) setState({ status: 'error' })
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [canView, channelId, hasTarget, normalizedCurrency, offerId, priceKindId, productId, variantId])
+
+  const reasonLabels = React.useMemo<Record<OmnibusApplicabilityReason, string>>(() => ({
+    no_history: t('catalog.omnibus.reason.noHistory', 'No price history'),
+    not_in_eu_market: t('catalog.omnibus.reason.notInEuMarket', 'Not an EU market'),
+    missing_channel_context: t('catalog.omnibus.reason.missingChannelContext', 'Channel required'),
+    insufficient_history: t('catalog.omnibus.reason.insufficientHistory', 'Insufficient history'),
+    announced_promotion: t('catalog.omnibus.reason.announcedPromotion', 'Announced promotion'),
+    not_announced: t('catalog.omnibus.reason.notAnnounced', 'No announced reduction'),
+    progressive_reduction_frozen: t('catalog.omnibus.reason.progressiveReductionFrozen', 'Progressive reduction'),
+    perishable_exempt: t('catalog.omnibus.reason.perishableExempt', 'Perishable goods exemption'),
+    perishable_last_price: t('catalog.omnibus.reason.perishableLastPrice', 'Perishable goods: last price'),
+    new_arrival_reduced_window: t('catalog.omnibus.reason.newArrivalReducedWindow', 'New arrival: shorter window'),
+  }), [t])
+
+  if (state.status === 'hidden') return null
+
+  if (state.status === 'loading') {
+    return (
+      <div className="mt-2 flex items-center gap-2 text-xs text-muted-foreground" data-testid="catalog-price-omnibus-row">
+        <Spinner className="size-3" />
+        {t('catalog.omnibus.priceEditor.loading', 'Loading Omnibus reference price…')}
+      </div>
+    )
+  }
+
+  if (state.status === 'error') {
+    return (
+      <p className="mt-2 text-xs text-status-error-text" data-testid="catalog-price-omnibus-row">
+        {t('catalog.omnibus.priceEditor.loadError', 'Could not load the Omnibus reference price.')}
+      </p>
+    )
+  }
+
+  const { block } = state
+  const reason = block.applicabilityReason
+  const reasonBadge = (
+    <StatusBadge variant={REASON_VARIANTS[reason] ?? 'neutral'}>{reasonLabels[reason] ?? reason}</StatusBadge>
+  )
+  const lowest = formatAmount(pickAxisAmount(block, block.lowestPriceNet, block.lowestPriceGross), block.currencyCode, locale)
+
+  if (NOT_APPLICABLE_REASONS.has(reason) || !lowest) {
+    return (
+      <div className="mt-2 space-y-1 text-xs" data-testid="catalog-price-omnibus-row">
+        <div className="flex flex-wrap items-center gap-2 text-muted-foreground">
+          <span>{t('catalog.omnibus.priceEditor.notApplicable', 'Omnibus reference price not applicable')}</span>
+          {reasonBadge}
+        </div>
+        {reason === 'missing_channel_context' ? (
+          <p className="text-status-warning-text">
+            {channelSelectable
+              ? t('catalog.omnibus.priceEditor.missingChannel', 'Select a channel to compute the reference price.')
+              : t('catalog.omnibus.priceEditor.perChannelReference', 'The reference price is computed per sales channel.')}
+          </p>
+        ) : null}
+      </div>
+    )
+  }
+
+  const isProgressive = reason === 'progressive_reduction_frozen'
+  const previous = isProgressive
+    ? formatAmount(pickAxisAmount(block, block.previousPriceNet, block.previousPriceGross), block.currencyCode, locale)
+    : null
+  const coverageStart = reason === 'insufficient_history' ? formatDate(block.coverageStartAt, locale) : null
+
+  return (
+    <div className="mt-2 space-y-1 text-xs" data-testid="catalog-price-omnibus-row">
+      <div className="flex flex-wrap items-center gap-2">
+        <span className="text-muted-foreground">
+          {isProgressive
+            ? t('catalog.omnibus.priceEditor.progressiveRef', 'Reference price (frozen for the progressive reduction)')
+            : t('catalog.omnibus.priceEditor.lowestInDays', 'Lowest price in the last {{days}} days', { days: block.lookbackDays })}
+        </span>
+        <span className="font-medium" data-testid="catalog-price-omnibus-reference">{lowest}</span>
+        {reasonBadge}
+      </div>
+      {previous ? (
+        <p className="text-muted-foreground">
+          {t('catalog.omnibus.priceEditor.previousPrice', 'Price before the reduction: {{price}}', { price: previous })}
+        </p>
+      ) : null}
+      {reason === 'insufficient_history' ? (
+        <p className="text-status-warning-text">
+          {coverageStart
+            ? t('catalog.omnibus.priceEditor.insufficientHistorySince', 'Price history is only available since {{date}}; the reference may be incomplete.', { date: coverageStart })
+            : t('catalog.omnibus.priceEditor.insufficientHistory', 'Price history does not cover the full window; the reference may be incomplete.')}
+        </p>
+      ) : null}
+    </div>
+  )
+}

package/src/modules/catalog/components/lookupSources.ts

@@ -0,0 +1,29 @@
+import {
+  createIdsLookupSource,
+  pickLookupString,
+  type LookupSource,
+} from '@open-mercato/ui/backend/inputs/lookupSources'
+
+export const categoryLookupSource: LookupSource = createIdsLookupSource(
+  'categories',
+  '/api/catalog/categories',
+  (item) => {
+    const value = pickLookupString(item, 'id')
+    if (!value) return null
+    return { value, label: pickLookupString(item, 'pathLabel', 'name') || value }
+  },
+  { view: 'manage' },
+)
+
+export const productLookupSource: LookupSource = createIdsLookupSource('products', '/api/catalog/products', (item) => {
+  const value = pickLookupString(item, 'id')
+  if (!value) return null
+  const sku = pickLookupString(item, 'sku')
+  return { value, label: pickLookupString(item, 'title', 'name') || value, description: sku || null }
+})
+
+export const tagLookupSource: LookupSource = createIdsLookupSource('tags', '/api/catalog/tags', (item) => {
+  const value = pickLookupString(item, 'id')
+  if (!value) return null
+  return { value, label: pickLookupString(item, 'label') || value }
+})

package/src/modules/catalog/components/prices/PriceScopeSelectors.tsx

@@ -164,9 +164,11 @@ export function PriceCustomerSelect({
 export function PriceChannelSelect({
   value,
   onChange,
+  disabled,
 }: {
   value: string
   onChange: (next: string) => void
+  disabled?: boolean
 }) {
   const t = useT()
   const mapItem = React.useCallback((item: RemoteItem): ComboboxOption | null => {
@@ -180,6 +182,7 @@ export function PriceChannelSelect({
     <ComboboxInput
       value={value}
       onChange={onChange}
+      disabled={disabled}
       allowCustomValues={false}
       clearable
       placeholder={t('catalog.prices.select.channel.placeholder', 'Select a channel…')}
@@ -192,9 +195,13 @@ export function PriceChannelSelect({
 export function PricePriceKindSelect({
   value,
   onChange,
+  disabled,
+  clearable,
 }: {
   value: string
   onChange: (next: string) => void
+  disabled?: boolean
+  clearable?: boolean
 }) {
   const t = useT()
   const mapItem = React.useCallback((item: RemoteItem): ComboboxOption | null => {
@@ -208,7 +215,9 @@ export function PricePriceKindSelect({
     <ComboboxInput
       value={value}
       onChange={onChange}
+      disabled={disabled}
       allowCustomValues={false}
+      clearable={clearable}
       placeholder={t('catalog.prices.select.priceKind.placeholder', 'Select a price kind…')}
       loadSuggestions={(query) => loadOptions('/api/catalog/price-kinds', buildLookupParams(query, '20'), mapItem)}
       resolveLabel={(id) => resolveOne('/api/catalog/price-kinds', 'ids', id, mapItem)}

package/src/modules/catalog/components/products/VariantBuilder.tsx

@@ -15,6 +15,7 @@ import {
 import { Switch } from '@open-mercato/ui/primitives/switch'
 import { ProductMediaManager } from './ProductMediaManager'
 import { MetadataEditor } from './MetadataEditor'
+import { PriceEditorOmnibusRow } from '../PriceEditorOmnibusRow'
 import type { PriceKindSummary, TaxRateSummary } from './productForm'
 import { formatTaxRateLabel } from './productForm'
 import type { OptionDefinition, VariantFormValues, VariantPriceDraft } from './variantForm'
@@ -444,6 +445,14 @@ export function VariantPricesSection({
                   onChange={(event) => updatePrice(kind.id, { amount: event.target.value })}
                   placeholder="0.00"
                 />
+                {values.id && draft?.priceId ? (
+                  <PriceEditorOmnibusRow
+                    variantId={values.id}
+                    priceKindId={kind.id}
+                    currencyCode={draft.currencyCode ?? kind.currencyCode}
+                    channelSelectable={false}
+                  />
+                ) : null}
               </div>
             )
           })

package/src/modules/catalog/data/entities.ts

@@ -1,5 +1,5 @@
 import { Collection, OptionalProps } from '@mikro-orm/core'
-import { Entity, Index, ManyToOne, OneToMany, PrimaryKey, Property, Unique } from '@mikro-orm/decorators/legacy'
+import { Entity, Enum, Index, ManyToOne, OneToMany, PrimaryKey, Property, Unique } from '@mikro-orm/decorators/legacy'
 import type {
   CatalogExciseCategory,
   CatalogGtinType,
@@ -10,6 +10,7 @@ import type {
   CatalogProductType,
 } from './types'
 import type { ReferenceUnitCode } from '@open-mercato/shared/lib/units/unitCodes'
+import type { PriceHistoryChangeType, PriceHistorySource } from '../lib/omnibusTypes'
 
 @Entity({ tableName: 'catalog_product_option_schemas' })
 @Index({
@@ -785,6 +786,20 @@ export class CatalogPriceKind {
   name: 'catalog_product_variant_prices_product_scope_idx',
   properties: ['product', 'organizationId', 'tenantId'],
 })
+@Index({
+  name: 'catalog_product_variant_prices_customer_idx',
+  expression:
+    'create index "catalog_product_variant_prices_customer_idx" on "catalog_product_variant_prices" ("customer_id", "organization_id", "tenant_id") where "customer_id" is not null',
+})
+@Index({
+  name: 'catalog_product_variant_prices_customer_group_idx',
+  expression:
+    'create index "catalog_product_variant_prices_customer_group_idx" on "catalog_product_variant_prices" ("customer_group_id", "organization_id", "tenant_id") where "customer_group_id" is not null',
+})
+@Index({
+  name: 'catalog_product_variant_prices_product_lookup_idx',
+  properties: ['product', 'currencyCode', 'channelId', 'organizationId', 'tenantId'],
+})
 export class CatalogProductPrice {
   [OptionalProps]?: 'createdAt' | 'updatedAt'
 
@@ -863,3 +878,110 @@ export class CatalogProductPrice {
   @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
   updatedAt: Date = new Date()
 }
+
+@Entity({ tableName: 'catalog_price_history_entries' })
+@Index({
+  name: 'catalog_price_history_product_idx',
+  properties: ['tenantId', 'organizationId', 'productId', 'priceKindId', 'currencyCode', 'recordedAt'],
+})
+@Index({
+  name: 'catalog_price_history_product_channel_idx',
+  properties: ['tenantId', 'organizationId', 'productId', 'channelId', 'priceKindId', 'currencyCode', 'recordedAt'],
+})
+@Index({
+  name: 'catalog_price_history_variant_idx',
+  properties: ['tenantId', 'organizationId', 'variantId', 'priceKindId', 'currencyCode', 'recordedAt'],
+})
+@Index({
+  name: 'catalog_price_history_variant_channel_idx',
+  properties: ['tenantId', 'organizationId', 'variantId', 'channelId', 'priceKindId', 'currencyCode', 'recordedAt'],
+})
+@Index({
+  name: 'catalog_price_history_offer_idx',
+  properties: ['tenantId', 'organizationId', 'offerId', 'priceKindId', 'currencyCode', 'recordedAt'],
+})
+@Index({
+  name: 'catalog_price_history_price_idx',
+  properties: ['tenantId', 'organizationId', 'priceId'],
+})
+@Index({
+  name: 'catalog_price_history_idempotency_uq',
+  expression:
+    'create unique index "catalog_price_history_idempotency_uq" on "catalog_price_history_entries" ("tenant_id", "organization_id", "idempotency_key") where "idempotency_key" is not null',
+})
+export class CatalogPriceHistoryEntry {
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'price_id', type: 'uuid' })
+  priceId!: string
+
+  @Property({ name: 'product_id', type: 'uuid' })
+  productId!: string
+
+  @Property({ name: 'variant_id', type: 'uuid', nullable: true })
+  variantId?: string | null
+
+  @Property({ name: 'offer_id', type: 'uuid', nullable: true })
+  offerId?: string | null
+
+  @Property({ name: 'channel_id', type: 'uuid', nullable: true })
+  channelId?: string | null
+
+  @Property({ name: 'price_kind_id', type: 'uuid' })
+  priceKindId!: string
+
+  @Property({ name: 'price_kind_code', type: 'text' })
+  priceKindCode!: string
+
+  @Property({ name: 'currency_code', type: 'varchar', length: 3 })
+  currencyCode!: string
+
+  @Property({ name: 'unit_price_net', type: 'numeric', precision: 16, scale: 4, nullable: true })
+  unitPriceNet?: string | null
+
+  @Property({ name: 'unit_price_gross', type: 'numeric', precision: 16, scale: 4, nullable: true })
+  unitPriceGross?: string | null
+
+  @Property({ name: 'tax_rate', type: 'numeric', precision: 7, scale: 4, nullable: true })
+  taxRate?: string | null
+
+  @Property({ name: 'tax_amount', type: 'numeric', precision: 16, scale: 4, nullable: true })
+  taxAmount?: string | null
+
+  @Property({ name: 'min_quantity', type: 'integer', nullable: true })
+  minQuantity?: number | null
+
+  @Property({ name: 'max_quantity', type: 'integer', nullable: true })
+  maxQuantity?: number | null
+
+  @Property({ name: 'starts_at', type: Date, nullable: true })
+  startsAt?: Date | null
+
+  @Property({ name: 'ends_at', type: Date, nullable: true })
+  endsAt?: Date | null
+
+  @Property({ name: 'recorded_at', type: Date })
+  recordedAt!: Date
+
+  @Enum({ items: ['create', 'update', 'delete', 'undo'], type: 'text', name: 'change_type' })
+  changeType!: PriceHistoryChangeType
+
+  @Enum({ items: ['api', 'system'], type: 'text', name: 'source' })
+  source!: PriceHistorySource
+
+  @Property({ name: 'is_announced', type: 'boolean', nullable: true })
+  isAnnounced?: boolean | null
+
+  @Property({ name: 'idempotency_key', type: 'text', nullable: true })
+  idempotencyKey?: string | null
+
+  @Property({ name: 'metadata', type: 'jsonb', nullable: true })
+  metadata?: Record<string, unknown> | null
+}

package/src/modules/catalog/data/validators.ts

@@ -13,6 +13,12 @@ import {
   getCatalogPriceAmountValidationMessage,
   validateCatalogPriceAmountInput,
 } from '../lib/priceValidation'
+import { ISO_COUNTRIES } from '@open-mercato/shared/lib/location/countries'
+import {
+  omnibusLookbackDaysSchema,
+  omnibusMinimizationAxisSchema,
+  omnibusNoChannelModeSchema,
+} from '../lib/omnibusTypes'
 
 const uuid = () => z.string().uuid()
 
@@ -579,6 +585,113 @@ export const productUnitConversionDeleteSchema = scoped.extend({
   id: uuid(),
 })
 
+export const PRICE_HISTORY_MAX_PAGE_SIZE = 100
+
+export const PRICE_HISTORY_DEFAULT_PAGE_SIZE = 50
+
+export const priceHistoryQuerySchema = z
+  .object({
+    productId: uuid().optional(),
+    variantId: uuid().optional(),
+    priceKindId: uuid().optional(),
+    channelId: uuid().optional(),
+    currencyCode: z
+      .string()
+      .trim()
+      .toUpperCase()
+      .regex(/^[A-Z]{3}$/, 'currency code must be a three-letter ISO code')
+      .optional(),
+    from: z.string().datetime({ offset: true }).optional(),
+    to: z.string().datetime({ offset: true }).optional(),
+    pageSize: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(PRICE_HISTORY_MAX_PAGE_SIZE)
+      .default(PRICE_HISTORY_DEFAULT_PAGE_SIZE),
+    cursor: z.string().trim().max(512).optional(),
+    includeTotal: z.enum(['true', 'false']).optional(),
+  })
+  .strict()
+  .refine((value) => Boolean(value.productId || value.variantId), {
+    message: 'one of productId or variantId is required',
+    path: ['productId'],
+  })
+  .refine(
+    (value) => !value.from || !value.to || new Date(value.from).getTime() <= new Date(value.to).getTime(),
+    { message: 'from must not be later than to', path: ['from'] },
+  )
+
+export const omnibusPreviewQuerySchema = z
+  .object({
+    priceKindId: uuid(),
+    currencyCode: z
+      .string()
+      .trim()
+      .toUpperCase()
+      .regex(/^[A-Z]{3}$/, 'currency code must be a three-letter ISO code'),
+    productId: uuid().optional(),
+    variantId: uuid().optional(),
+    offerId: uuid().optional(),
+    channelId: uuid().optional(),
+  })
+  .strict()
+  .refine((value) => Boolean(value.productId || value.variantId || value.offerId), {
+    message: 'one of productId, variantId or offerId is required',
+    path: ['productId'],
+  })
+
+const ISO_COUNTRY_CODES = new Set(ISO_COUNTRIES.map((country) => country.code))
+
+const omnibusConfigCountryCodeSchema = z
+  .string()
+  .regex(/^[A-Z]{2}$/, 'omnibus_country_code_alpha2_required')
+  .refine((value) => value !== 'EU', 'omnibus_country_code_eu_not_allowed')
+  .refine((value) => value === 'EU' || ISO_COUNTRY_CODES.has(value), 'omnibus_country_code_unknown')
+
+const unsupportedOmnibusField = (code: string) => z.undefined({ error: code }).optional()
+
+const omnibusChannelConfigPatchSchema = z
+  .object({
+    presentedPriceKindId: uuid(),
+    countryCode: omnibusConfigCountryCodeSchema.optional(),
+    lookbackDays: omnibusLookbackDaysSchema.optional(),
+    minimizationAxis: omnibusMinimizationAxisSchema.optional(),
+    progressiveReductionRule: unsupportedOmnibusField('omnibus_derogation_not_supported'),
+    progressiveMaxGapDays: unsupportedOmnibusField('omnibus_derogation_not_supported'),
+    perishableGoodsRule: unsupportedOmnibusField('omnibus_derogation_not_supported'),
+    newArrivalRule: unsupportedOmnibusField('omnibus_derogation_not_supported'),
+    newArrivalsLookbackDays: unsupportedOmnibusField('omnibus_derogation_not_supported'),
+  })
+  .strict()
+
+export const omnibusConfigPatchSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    enabledCountryCodes: z.array(omnibusConfigCountryCodeSchema).optional(),
+    noChannelMode: omnibusNoChannelModeSchema.optional(),
+    lookbackDays: omnibusLookbackDaysSchema.optional(),
+    minimizationAxis: omnibusMinimizationAxisSchema.optional(),
+    defaultPresentedPriceKindId: uuid().nullable().optional(),
+    channels: z.record(uuid(), omnibusChannelConfigPatchSchema).optional(),
+    backfillCoverage: unsupportedOmnibusField('omnibus_backfill_coverage_read_only'),
+  })
+  .strict()
+
+export const omnibusBackfillOptionsSchema = z
+  .object({
+    tenantId: uuid(),
+    organizationId: uuid().optional(),
+    channelId: uuid().optional(),
+    unscoped: z.boolean().default(false),
+    batchSize: z.number().int().min(1).max(1000).default(500),
+    dryRun: z.boolean().default(false),
+  })
+  .refine((value) => !(value.channelId && value.unscoped), {
+    message: 'omnibus_backfill_channel_and_unscoped_exclusive',
+    path: ['unscoped'],
+  })
+
 export type ProductCreateInput = z.infer<typeof productCreateSchema>
 export type ProductUpdateInput = z.infer<typeof productUpdateSchema>
 export type ProductBulkCreateRow = z.infer<typeof productBulkCreateRowSchema>
@@ -601,3 +714,8 @@ export type OfferUpdateInput = z.infer<typeof offerUpdateSchema>
 export type ProductUnitConversionCreateInput = z.infer<typeof productUnitConversionCreateSchema>
 export type ProductUnitConversionUpdateInput = z.infer<typeof productUnitConversionUpdateSchema>
 export type ProductUnitConversionDeleteInput = z.infer<typeof productUnitConversionDeleteSchema>
+export type PriceHistoryQuery = z.infer<typeof priceHistoryQuerySchema>
+export type OmnibusPreviewQuery = z.infer<typeof omnibusPreviewQuerySchema>
+export type OmnibusConfigPatch = z.infer<typeof omnibusConfigPatchSchema>
+export type OmnibusBackfillOptionsInput = z.input<typeof omnibusBackfillOptionsSchema>
+export type OmnibusBackfillOptions = z.infer<typeof omnibusBackfillOptionsSchema>

package/src/modules/catalog/di.ts

@@ -1,20 +1,43 @@
 import { asFunction, asValue } from 'awilix'
+import type { CacheStrategy } from '@open-mercato/cache'
 import type { EventBus } from '@open-mercato/events'
 import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
+import { registerIndexDocEnricher } from '@open-mercato/core/modules/query_index/lib/doc-enrichers'
 import { DefaultCatalogPricingService } from './services/catalogPricingService'
+import { DefaultCatalogOmnibusService } from './services/catalogOmnibusService'
 import { CatalogProduct, CatalogProductPrice, CatalogProductVariant } from './data/entities'
+import { catalogProductScopeKeysEnricher } from './lib/productScopeKeys'
 
 type AppCradle = AppContainer['cradle'] & {
   eventBus?: EventBus | null
 }
 
+function softCradle<T>(cradle: AppCradle, name: string): T | null {
+  try {
+    const value = (cradle as Record<string, unknown>)[name]
+    return value === undefined || value === null ? null : (value as T)
+  } catch {
+    return null
+  }
+}
+
 export function register(container: AppContainer) {
+  registerIndexDocEnricher(catalogProductScopeKeysEnricher)
   container.register({
     catalogPricingService: asFunction(({ eventBus }: AppCradle) => {
       return new DefaultCatalogPricingService(eventBus ?? null)
     })
       .singleton()
       .proxy(),
+    catalogOmnibusService: asFunction((cradle: AppCradle) => {
+      return new DefaultCatalogOmnibusService(
+        softCradle<ModuleConfigService>(cradle, 'moduleConfigService'),
+        softCradle<CacheStrategy>(cradle, 'cache'),
+      )
+    })
+      .scoped()
+      .proxy(),
     CatalogProduct: asValue(CatalogProduct),
     CatalogProductPrice: asValue(CatalogProductPrice),
     CatalogProductVariant: asValue(CatalogProductVariant),