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

package/src/modules/ecommerce/components/storeEditTabs.tsx

@@ -0,0 +1,76 @@
+import type * as React from 'react'
+import { StoreBrandingTab } from './StoreBrandingTab'
+import { StoreChannelsTab } from './StoreChannelsTab'
+import { StoreDomainsTab } from './StoreDomainsTab'
+import { StoreGeneralTab } from './StoreGeneralTab'
+import { StoreSeoTab } from './StoreSeoTab'
+import { STORE_LIST_HREF, type StoreAdminRecord } from './storeAdmin'
+
+export const STORE_TAB_QUERY_PARAM = 'tab'
+
+export const STORE_EDIT_TAB_IDS = ['general', 'branding', 'domains', 'channels', 'seo'] as const
+
+export type StoreEditTabId = (typeof STORE_EDIT_TAB_IDS)[number]
+
+export type StoreEditTabContext = {
+  store: StoreAdminRecord
+  reload: () => Promise<void>
+}
+
+export type StoreEditTabDefinition = {
+  id: StoreEditTabId
+  labelKey: string
+  fallbackLabel: string
+  render: (context: StoreEditTabContext) => React.ReactNode
+}
+
+export const STORE_EDIT_TABS: readonly StoreEditTabDefinition[] = [
+  {
+    id: 'general',
+    labelKey: 'ecommerce.backend.store.tabs.general',
+    fallbackLabel: 'General',
+    render: ({ store, reload }) => <StoreGeneralTab store={store} reload={reload} />,
+  },
+  {
+    id: 'branding',
+    labelKey: 'ecommerce.backend.store.tabs.branding',
+    fallbackLabel: 'Branding',
+    render: ({ store, reload }) => <StoreBrandingTab store={store} reload={reload} />,
+  },
+  {
+    id: 'domains',
+    labelKey: 'ecommerce.backend.store.tabs.domains',
+    fallbackLabel: 'Domains',
+    render: ({ store, reload }) => <StoreDomainsTab store={store} reload={reload} />,
+  },
+  {
+    id: 'channels',
+    labelKey: 'ecommerce.backend.store.tabs.channels',
+    fallbackLabel: 'Channels',
+    render: ({ store, reload }) => <StoreChannelsTab store={store} reload={reload} />,
+  },
+  {
+    id: 'seo',
+    labelKey: 'ecommerce.backend.store.tabs.seo',
+    fallbackLabel: 'SEO',
+    render: ({ store, reload }) => <StoreSeoTab store={store} reload={reload} />,
+  },
+]
+
+export function isStoreEditTabId(value: unknown): value is StoreEditTabId {
+  return typeof value === 'string' && (STORE_EDIT_TAB_IDS as readonly string[]).includes(value)
+}
+
+export function buildStoreEditHref(storeId: string, tab?: StoreEditTabId): string {
+  const base = `${STORE_LIST_HREF}/${encodeURIComponent(storeId)}`
+  return tab ? `${base}?${STORE_TAB_QUERY_PARAM}=${tab}` : base
+}
+
+export function resolveActiveStoreTab(
+  requested: string | null | undefined,
+  tabs: readonly StoreEditTabDefinition[],
+): StoreEditTabId | null {
+  if (!tabs.length) return null
+  const match = tabs.find((tab) => tab.id === requested)
+  return (match ?? tabs[0]).id
+}

package/src/modules/ecommerce/components/storeGeneral.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod'
+import { refineDefaultLocaleSupported, storeIdentityFormShape } from './StoreCreateDialog'
+import { STORE_STATUSES, type StoreAdminRecord, type StoreStatus } from './storeAdmin'
+
+export type StoreGeneralFormValues = {
+  name: string
+  code: string
+  slug: string
+  status: StoreStatus
+  defaultLocale: string
+  supportedLocales: string[]
+  defaultCurrencyCode: string
+}
+
+export const storeGeneralFormSchema = z
+  .object({ ...storeIdentityFormShape, status: z.enum(STORE_STATUSES) })
+  .superRefine(refineDefaultLocaleSupported)
+
+export function buildStoreGeneralInitialValues(store: StoreAdminRecord): StoreGeneralFormValues {
+  return {
+    name: store.name,
+    code: store.code,
+    slug: store.slug,
+    status: store.status,
+    defaultLocale: store.defaultLocale,
+    supportedLocales: [...store.supportedLocales],
+    defaultCurrencyCode: store.defaultCurrencyCode,
+  }
+}
+
+export type StoreGeneralUpdatePayload = StoreGeneralFormValues & { id: string }
+
+export function buildStoreGeneralPayload(storeId: string, values: StoreGeneralFormValues): StoreGeneralUpdatePayload {
+  return {
+    id: storeId,
+    name: values.name.trim(),
+    code: values.code.trim(),
+    slug: values.slug.trim(),
+    status: values.status,
+    defaultLocale: values.defaultLocale.trim(),
+    supportedLocales: values.supportedLocales.map((locale) => locale.trim()),
+    defaultCurrencyCode: values.defaultCurrencyCode.trim().toUpperCase(),
+  }
+}
+
+export type StoreDefaultPolicy = {
+  id: string
+  storeId: string | null
+  productId: string | null
+  variantId: string | null
+  allowBackorder: boolean
+  backorderLeadTimeDays: number | null
+  hideWhenOutOfStock: boolean
+  updatedAt: string | null
+}
+
+export type PolicyListResponse = {
+  items: StoreDefaultPolicy[]
+  total: number
+  totalPages: number
+}
+
+export function isStoreDefaultPolicy(policy: StoreDefaultPolicy, storeId: string): boolean {
+  return policy.storeId === storeId && !policy.productId && !policy.variantId
+}
+
+export type AvailabilityDefaultsFormValues = {
+  hideWhenOutOfStock: boolean
+  allowBackorder: boolean
+  backorderLeadTimeDays?: number | string | null
+}
+
+export const AVAILABILITY_LEAD_TIME_REQUIRED_MESSAGE = 'ecommerce.validation.backorderLeadTimeRequired'
+
+function parseLeadTimeDays(value: number | string | null | undefined): number | null {
+  if (value === null || value === undefined) return null
+  if (typeof value === 'number') return Number.isInteger(value) && value >= 0 ? value : null
+  const trimmed = value.trim()
+  if (!/^\d+$/.test(trimmed)) return null
+  return Number.parseInt(trimmed, 10)
+}
+
+export const availabilityDefaultsFormSchema = z
+  .object({
+    hideWhenOutOfStock: z.boolean(),
+    allowBackorder: z.boolean(),
+    backorderLeadTimeDays: z.union([z.number(), z.string(), z.null()]).optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.allowBackorder) return
+    if (parseLeadTimeDays(value.backorderLeadTimeDays) !== null) return
+    ctx.addIssue({
+      code: 'custom',
+      path: ['backorderLeadTimeDays'],
+      message: AVAILABILITY_LEAD_TIME_REQUIRED_MESSAGE,
+    })
+  })
+
+export function buildAvailabilityInitialValues(policy: StoreDefaultPolicy | null): AvailabilityDefaultsFormValues {
+  return {
+    hideWhenOutOfStock: policy?.hideWhenOutOfStock ?? false,
+    allowBackorder: policy?.allowBackorder ?? false,
+    backorderLeadTimeDays: policy?.backorderLeadTimeDays ?? null,
+  }
+}
+
+type AvailabilityPolicyFields = {
+  hideWhenOutOfStock: boolean
+  allowBackorder: boolean
+  backorderLeadTimeDays?: number
+}
+
+function buildAvailabilityFields(values: AvailabilityDefaultsFormValues): AvailabilityPolicyFields {
+  const fields: AvailabilityPolicyFields = {
+    hideWhenOutOfStock: values.hideWhenOutOfStock,
+    allowBackorder: values.allowBackorder,
+  }
+  if (values.allowBackorder) {
+    const leadTime = parseLeadTimeDays(values.backorderLeadTimeDays)
+    if (leadTime !== null) fields.backorderLeadTimeDays = leadTime
+  }
+  return fields
+}
+
+export type AvailabilityCreatePayload = AvailabilityPolicyFields & {
+  organizationId: string
+  tenantId: string
+  storeId: string
+  productId: null
+  variantId: null
+}
+
+export function buildAvailabilityCreatePayload(
+  store: Pick<StoreAdminRecord, 'id' | 'organizationId' | 'tenantId'>,
+  values: AvailabilityDefaultsFormValues,
+): AvailabilityCreatePayload | null {
+  if (!store.organizationId || !store.tenantId) return null
+  return {
+    organizationId: store.organizationId,
+    tenantId: store.tenantId,
+    storeId: store.id,
+    productId: null,
+    variantId: null,
+    ...buildAvailabilityFields(values),
+  }
+}
+
+export type AvailabilityUpdatePayload = AvailabilityPolicyFields & { id: string }
+
+export function buildAvailabilityUpdatePayload(
+  policyId: string,
+  values: AvailabilityDefaultsFormValues,
+): AvailabilityUpdatePayload {
+  return { id: policyId, ...buildAvailabilityFields(values) }
+}

package/src/modules/ecommerce/components/storeSeo.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod'
+import {
+  ECOMMERCE_SEO_GOOGLE_VERIFICATION_MAX,
+  ECOMMERCE_SEO_META_DESCRIPTION_MAX,
+  ECOMMERCE_SEO_ROBOTS_TXT_MAX,
+  ECOMMERCE_SEO_SITE_NAME_MAX,
+  ecommerceStoreSeoSchema,
+} from '../data/validators'
+import type { StoreAdminRecord } from './storeAdmin'
+
+export const STORE_SEO_FIELD_KEYS = ['siteName', 'defaultMetaDescription', 'googleSiteVerification', 'robotsTxt'] as const
+
+export type StoreSeoFieldKey = (typeof STORE_SEO_FIELD_KEYS)[number]
+
+export type StoreSeoFormValues = Record<StoreSeoFieldKey, string>
+
+export const STORE_SEO_FIELD_LIMITS: Record<StoreSeoFieldKey, number> = {
+  siteName: ECOMMERCE_SEO_SITE_NAME_MAX,
+  defaultMetaDescription: ECOMMERCE_SEO_META_DESCRIPTION_MAX,
+  googleSiteVerification: ECOMMERCE_SEO_GOOGLE_VERIFICATION_MAX,
+  robotsTxt: ECOMMERCE_SEO_ROBOTS_TXT_MAX,
+}
+
+const SEO_FIELD_ERROR_PREFIX = 'settings.seo.'
+
+type StoreSeoPayloadInput = Partial<Record<StoreSeoFieldKey, string>>
+
+function buildStoreSeoInput(values: Partial<Record<StoreSeoFieldKey, unknown>>): StoreSeoPayloadInput {
+  const input: StoreSeoPayloadInput = {}
+  for (const key of STORE_SEO_FIELD_KEYS) {
+    const value = values[key]
+    if (typeof value !== 'string') continue
+    if (value.trim().length === 0) continue
+    input[key] = value
+  }
+  return input
+}
+
+const seoFormShape = {
+  siteName: z.string(),
+  defaultMetaDescription: z.string(),
+  googleSiteVerification: z.string(),
+  robotsTxt: z.string(),
+} satisfies Record<StoreSeoFieldKey, z.ZodString>
+
+export const storeSeoFormSchema = z.object(seoFormShape).superRefine((values, context) => {
+  const result = ecommerceStoreSeoSchema.safeParse(buildStoreSeoInput(values))
+  if (result.success) return
+  for (const issue of result.error.issues) {
+    context.addIssue({ code: 'custom', path: issue.path, message: issue.message })
+  }
+})
+
+export function buildStoreSeoInitialValues(store: Pick<StoreAdminRecord, 'settings'>): StoreSeoFormValues {
+  const parsed = ecommerceStoreSeoSchema.safeParse(store.settings?.seo ?? {})
+  const stored = parsed.success ? parsed.data : {}
+  return {
+    siteName: stored.siteName ?? '',
+    defaultMetaDescription: stored.defaultMetaDescription ?? '',
+    googleSiteVerification: stored.googleSiteVerification ?? '',
+    robotsTxt: stored.robotsTxt ?? '',
+  }
+}
+
+export type StoreSeoUpdatePayload = { id: string; settings: { seo: StoreSeoPayloadInput } }
+
+export function buildStoreSeoPayload(storeId: string, values: Partial<Record<StoreSeoFieldKey, unknown>>): StoreSeoUpdatePayload {
+  return { id: storeId, settings: { seo: buildStoreSeoInput(values) } }
+}
+
+export function remapStoreSeoFieldErrors(fieldErrors: Record<string, string> | undefined): Record<string, string> | undefined {
+  if (!fieldErrors) return undefined
+  const mapped: Record<string, string> = {}
+  for (const [key, message] of Object.entries(fieldErrors)) {
+    mapped[key.startsWith(SEO_FIELD_ERROR_PREFIX) ? key.slice(SEO_FIELD_ERROR_PREFIX.length) : key] = message
+  }
+  return mapped
+}

package/src/modules/ecommerce/components/useChannelAssortmentCount.ts

@@ -0,0 +1,67 @@
+'use client'
+
+import * as React from 'react'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import {
+  ASSORTMENT_COUNT_DEBOUNCE_MS,
+  buildAssortmentCountUrl,
+  type AssortmentCountDraft,
+  type AssortmentCountResult,
+} from './storeChannels'
+
+export type AssortmentCountState =
+  | { status: 'idle' }
+  | { status: 'loading' }
+  | { status: 'error' }
+  | { status: 'ready'; result: AssortmentCountResult; refreshing: boolean }
+
+function isCountResult(value: unknown): value is AssortmentCountResult {
+  if (!value || typeof value !== 'object') return false
+  const record = value as Record<string, unknown>
+  return typeof record.count === 'number' && typeof record.countWithoutAuthentication === 'number'
+}
+
+/**
+ * Live product count for one channel binding. With a draft it asks for the unsaved scope and
+ * require-authentication switch, debounced so typing in a picker sends one request per pause;
+ * without a binding id (an unsaved binding) it stays idle. A changed `refreshKey` (the binding's
+ * `updatedAt`) refetches the same URL, so a saved edit is reflected without a remount.
+ */
+export function useChannelAssortmentCount(
+  bindingId: string | null,
+  draft: AssortmentCountDraft | null,
+  delayMs: number = ASSORTMENT_COUNT_DEBOUNCE_MS,
+  refreshKey: string | null = null,
+): AssortmentCountState {
+  const url = bindingId ? buildAssortmentCountUrl(bindingId, draft) : null
+  const [state, setState] = React.useState<AssortmentCountState>(() => (url ? { status: 'loading' } : { status: 'idle' }))
+
+  React.useEffect(() => {
+    if (!url) {
+      setState({ status: 'idle' })
+      return
+    }
+    let cancelled = false
+    setState((previous) => (previous.status === 'ready' ? { ...previous, refreshing: true } : { status: 'loading' }))
+    const timer = setTimeout(() => {
+      void apiCall<AssortmentCountResult>(url, { cache: 'no-store' })
+        .then((call) => {
+          if (cancelled) return
+          if (call.ok && isCountResult(call.result)) {
+            setState({ status: 'ready', result: call.result, refreshing: false })
+          } else {
+            setState({ status: 'error' })
+          }
+        })
+        .catch(() => {
+          if (!cancelled) setState({ status: 'error' })
+        })
+    }, delayMs)
+    return () => {
+      cancelled = true
+      clearTimeout(timer)
+    }
+  }, [delayMs, url, refreshKey])
+
+  return state
+}

package/src/modules/ecommerce/components/useStoreAccess.ts

@@ -0,0 +1,36 @@
+'use client'
+
+import { useBackendChrome } from '@open-mercato/ui/backend/BackendChromeProvider'
+import { hasFeature } from '@open-mercato/shared/security/features'
+import {
+  AVAILABILITY_MANAGE_FEATURE,
+  AVAILABILITY_VIEW_FEATURE,
+  BRANDING_MANAGE_FEATURE,
+  CHANNELS_MANAGE_FEATURE,
+  DOMAINS_MANAGE_FEATURE,
+  STORE_MANAGE_FEATURE,
+} from './storeAdmin'
+
+export type StoreAccess = {
+  isResolved: boolean
+  canManage: boolean
+  canManageBranding: boolean
+  canManageDomains: boolean
+  canManageChannels: boolean
+  canViewAvailability: boolean
+  canManageAvailability: boolean
+}
+
+export function useStoreAccess(): StoreAccess {
+  const { payload } = useBackendChrome()
+  const granted = payload?.grantedFeatures
+  return {
+    isResolved: Array.isArray(granted),
+    canManage: hasFeature(granted, STORE_MANAGE_FEATURE),
+    canManageBranding: hasFeature(granted, BRANDING_MANAGE_FEATURE),
+    canManageDomains: hasFeature(granted, DOMAINS_MANAGE_FEATURE),
+    canManageChannels: hasFeature(granted, CHANNELS_MANAGE_FEATURE),
+    canViewAvailability: hasFeature(granted, AVAILABILITY_VIEW_FEATURE),
+    canManageAvailability: hasFeature(granted, AVAILABILITY_MANAGE_FEATURE),
+  }
+}

package/src/modules/ecommerce/data/enrichers.ts

@@ -0,0 +1,213 @@
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import type { EnricherContext, ResponseEnricher } from '@open-mercato/shared/lib/crud/response-enricher'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { SalesChannel } from '@open-mercato/core/modules/sales/data/entities'
+import { E } from '#generated/entities.ids.generated'
+import { loadOrganizationDomainMappings, type DomainMappingSummary } from '../lib/domainMappingSummaries'
+import { EcommerceStoreChannelBinding, EcommerceStoreDomainBinding } from './entities'
+
+type StoreRecord = Record<string, unknown> & { id: string }
+
+export type StoreListPrimaryDomain = {
+  hostname: string
+  pathPrefix: string | null
+}
+
+export type StoreListDefaultChannel = {
+  id: string
+  name: string
+}
+
+export type StoreListBindingSummary = {
+  primaryDomain: StoreListPrimaryDomain | null
+  defaultChannel: StoreListDefaultChannel | null
+}
+
+type StoreListEnrichment = {
+  _ecommerce: StoreListBindingSummary
+}
+
+const EMPTY_SUMMARY: StoreListBindingSummary = { primaryDomain: null, defaultChannel: null }
+
+function hasRecordId(record: Record<string, unknown>): record is StoreRecord {
+  return typeof record.id === 'string' && record.id.length > 0
+}
+
+async function loadPrimaryDomains(
+  em: EntityManager,
+  storeIds: string[],
+  context: EnricherContext,
+): Promise<Map<string, StoreListPrimaryDomain>> {
+  const result = new Map<string, StoreListPrimaryDomain>()
+  const bindings = await findWithDecryption(
+    em,
+    EcommerceStoreDomainBinding,
+    {
+      storeId: { $in: storeIds },
+      tenantId: context.tenantId,
+      organizationId: context.organizationId,
+      isPrimary: true,
+      deletedAt: null,
+    } as FilterQuery<EcommerceStoreDomainBinding>,
+    undefined,
+    { tenantId: context.tenantId, organizationId: context.organizationId },
+  )
+  if (!bindings.length) return result
+  const mappings = await loadOrganizationDomainMappings(context.container, {
+    organizationId: context.organizationId,
+    tenantId: context.tenantId,
+  })
+  if (!mappings) return result
+  const hostnameById = new Map<string, string>()
+  for (const mapping of mappings) hostnameById.set(mapping.id, mapping.hostname)
+  for (const binding of bindings) {
+    const hostname = hostnameById.get(binding.domainMappingId)
+    if (hostname) result.set(binding.storeId, { hostname, pathPrefix: binding.pathPrefix ?? null })
+  }
+  return result
+}
+
+async function loadDefaultChannels(
+  em: EntityManager,
+  storeIds: string[],
+  context: EnricherContext,
+): Promise<Map<string, StoreListDefaultChannel>> {
+  const result = new Map<string, StoreListDefaultChannel>()
+  const bindings = await findWithDecryption(
+    em,
+    EcommerceStoreChannelBinding,
+    {
+      storeId: { $in: storeIds },
+      tenantId: context.tenantId,
+      organizationId: context.organizationId,
+      isDefault: true,
+      deletedAt: null,
+    } as FilterQuery<EcommerceStoreChannelBinding>,
+    undefined,
+    { tenantId: context.tenantId, organizationId: context.organizationId },
+  )
+  if (!bindings.length) return result
+  const channelIds = Array.from(new Set(bindings.map((binding) => binding.salesChannelId)))
+  const channels = await findWithDecryption(
+    em,
+    SalesChannel,
+    {
+      id: { $in: channelIds },
+      tenantId: context.tenantId,
+      organizationId: context.organizationId,
+      deletedAt: null,
+    } as FilterQuery<SalesChannel>,
+    undefined,
+    { tenantId: context.tenantId, organizationId: context.organizationId },
+  )
+  const nameById = new Map<string, string>()
+  for (const channel of channels) nameById.set(channel.id, channel.name)
+  for (const binding of bindings) {
+    const name = nameById.get(binding.salesChannelId)
+    if (name !== undefined) result.set(binding.storeId, { id: binding.salesChannelId, name })
+  }
+  return result
+}
+
+async function enrichStoreList(
+  records: StoreRecord[],
+  context: EnricherContext,
+): Promise<Array<StoreRecord & StoreListEnrichment>> {
+  const storeIds = Array.from(new Set(records.filter(hasRecordId).map((record) => record.id)))
+  if (!storeIds.length) return records.map((record) => ({ ...record, _ecommerce: EMPTY_SUMMARY }))
+  const em = context.em as EntityManager
+  const [domains, channels] = await Promise.all([
+    loadPrimaryDomains(em, storeIds, context),
+    loadDefaultChannels(em, storeIds, context),
+  ])
+  return records.map((record) => ({
+    ...record,
+    _ecommerce: {
+      primaryDomain: domains.get(record.id) ?? null,
+      defaultChannel: channels.get(record.id) ?? null,
+    },
+  }))
+}
+
+export const storeBindingSummaryEnricher: ResponseEnricher<StoreRecord, StoreListEnrichment> = {
+  id: 'ecommerce.store-binding-summary',
+  targetEntity: E.ecommerce.ecommerce_store,
+  features: ['ecommerce.stores.view'],
+  priority: 10,
+  timeout: 2000,
+  critical: false,
+  cacheableOnListHit: false,
+  fallback: { _ecommerce: EMPTY_SUMMARY },
+
+  async enrichOne(record, context) {
+    const enriched = await this.enrichMany!([record], context)
+    return enriched[0]
+  },
+
+  async enrichMany(records, context) {
+    return enrichStoreList(records, context)
+  },
+}
+
+export type DomainBindingMappingState =
+  | ({ state: 'found' } & Omit<DomainMappingSummary, 'id'>)
+  | { state: 'removed' }
+  | { state: 'unavailable' }
+
+type DomainBindingRecord = Record<string, unknown> & { id: string; domainMappingId?: unknown }
+
+type DomainBindingMappingEnrichment = {
+  _domainMapping: DomainBindingMappingState
+}
+
+const UNAVAILABLE_DOMAIN_MAPPING: DomainBindingMappingState = { state: 'unavailable' }
+
+async function enrichDomainBindings(
+  records: DomainBindingRecord[],
+  context: EnricherContext,
+): Promise<Array<DomainBindingRecord & DomainBindingMappingEnrichment>> {
+  const mappings = await loadOrganizationDomainMappings(context.container, {
+    organizationId: context.organizationId,
+    tenantId: context.tenantId,
+  })
+  const mappingById = new Map<string, DomainMappingSummary>()
+  for (const mapping of mappings ?? []) mappingById.set(mapping.id, mapping)
+  return records.map((record) => {
+    if (!mappings) return { ...record, _domainMapping: UNAVAILABLE_DOMAIN_MAPPING }
+    const mapping = typeof record.domainMappingId === 'string' ? mappingById.get(record.domainMappingId) : undefined
+    if (!mapping) return { ...record, _domainMapping: { state: 'removed' } }
+    return {
+      ...record,
+      _domainMapping: {
+        state: 'found',
+        hostname: mapping.hostname,
+        status: mapping.status,
+        lastDnsCheckAt: mapping.lastDnsCheckAt,
+        dnsFailureReason: mapping.dnsFailureReason,
+        tlsFailureReason: mapping.tlsFailureReason,
+      },
+    }
+  })
+}
+
+export const storeDomainBindingMappingEnricher: ResponseEnricher<DomainBindingRecord, DomainBindingMappingEnrichment> = {
+  id: 'ecommerce.store-domain-binding-mapping',
+  targetEntity: E.ecommerce.ecommerce_store_domain_binding,
+  features: ['ecommerce.stores.view'],
+  priority: 10,
+  timeout: 2000,
+  critical: false,
+  cacheableOnListHit: false,
+  fallback: { _domainMapping: UNAVAILABLE_DOMAIN_MAPPING },
+
+  async enrichOne(record, context) {
+    const enriched = await this.enrichMany!([record], context)
+    return enriched[0]
+  },
+
+  async enrichMany(records, context) {
+    return enrichDomainBindings(records, context)
+  },
+}
+
+export const enrichers: ResponseEnricher[] = [storeBindingSummaryEnricher, storeDomainBindingMappingEnricher]