@open-mercato/core 0.9.1-develop.7473.1.de5b22888f → 0.9.1-develop.7475.1.28ca93ed97

package/src/modules/ecommerce/lib/crudEvents.ts

@@ -0,0 +1,128 @@
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import { canonicalizeResourceTag, invalidateCrudCache } from '@open-mercato/shared/lib/crud/cache'
+import type { EcommerceStore, EcommerceStoreChannelBinding, EcommerceStoreDomainBinding } from '../data/entities'
+import { emitEcommerceEvent, type EcommerceEventId } from '../events'
+
+export const ECOMMERCE_EVENTS_MODULE = 'ecommerce'
+export const STORE_EVENT_ENTITY = 'store'
+export const STORE_DOMAIN_BINDING_EVENT_ENTITY = 'store_domain_binding'
+export const STORE_CHANNEL_BINDING_EVENT_ENTITY = 'store_channel_binding'
+
+export type StoreEventPayload = { id: string; tenantId: string; organizationId: string }
+export type StoreDomainBindingEventPayload = StoreEventPayload & {
+  storeId: string
+  domainMappingId: string
+  previousStoreId?: string
+  previousDomainMappingId?: string
+}
+export type StoreChannelBindingEventPayload = StoreEventPayload & {
+  storeId: string
+  salesChannelId: string
+  previousStoreId?: string
+}
+
+type DomainBindingPlacementSnapshot = Pick<EcommerceStoreDomainBinding, 'storeId' | 'domainMappingId'>
+
+const previousDomainBindingPlacements = new WeakMap<EcommerceStoreDomainBinding, DomainBindingPlacementSnapshot>()
+const previousChannelBindingStores = new WeakMap<EcommerceStoreChannelBinding, string>()
+
+/**
+ * Records where a domain binding pointed before an update, so its `updated` event also names the
+ * store and domain mapping it moved away from and their cached storefront entries are evicted.
+ */
+export function rememberDomainBindingPlacement(binding: EcommerceStoreDomainBinding): void {
+  previousDomainBindingPlacements.set(binding, { storeId: binding.storeId, domainMappingId: binding.domainMappingId })
+}
+
+/** Channel-binding counterpart of `rememberDomainBindingPlacement`: the store it moved away from. */
+export function rememberChannelBindingStore(binding: EcommerceStoreChannelBinding): void {
+  previousChannelBindingStores.set(binding, binding.storeId)
+}
+
+export function buildStoreEventPayload(store: EcommerceStore): StoreEventPayload {
+  return { id: store.id, tenantId: store.tenantId, organizationId: store.organizationId }
+}
+
+export function buildStoreDomainBindingEventPayload(binding: EcommerceStoreDomainBinding): StoreDomainBindingEventPayload {
+  const payload: StoreDomainBindingEventPayload = {
+    id: binding.id,
+    storeId: binding.storeId,
+    domainMappingId: binding.domainMappingId,
+    tenantId: binding.tenantId,
+    organizationId: binding.organizationId,
+  }
+  const previous = previousDomainBindingPlacements.get(binding)
+  if (previous && previous.storeId !== binding.storeId) payload.previousStoreId = previous.storeId
+  if (previous && previous.domainMappingId !== binding.domainMappingId) {
+    payload.previousDomainMappingId = previous.domainMappingId
+  }
+  return payload
+}
+
+export function buildStoreChannelBindingEventPayload(
+  binding: EcommerceStoreChannelBinding,
+): StoreChannelBindingEventPayload {
+  const payload: StoreChannelBindingEventPayload = {
+    id: binding.id,
+    storeId: binding.storeId,
+    salesChannelId: binding.salesChannelId,
+    tenantId: binding.tenantId,
+    organizationId: binding.organizationId,
+  }
+  const previousStoreId = previousChannelBindingStores.get(binding)
+  if (previousStoreId && previousStoreId !== binding.storeId) payload.previousStoreId = previousStoreId
+  return payload
+}
+
+export function resourceKindFor(entity: string): string {
+  const raw = `${ECOMMERCE_EVENTS_MODULE}.${entity}`
+  return canonicalizeResourceTag(raw) ?? raw
+}
+
+type ScopedRow = { id: string; tenantId: string; organizationId: string }
+
+async function announceUpdatedRows<TRow extends ScopedRow>(
+  container: CrudCtx['container'],
+  entity: string,
+  eventId: EcommerceEventId,
+  rows: TRow[],
+  buildPayload: (row: TRow) => StoreEventPayload,
+): Promise<void> {
+  const resourceKind = resourceKindFor(entity)
+  for (const row of rows) {
+    await invalidateCrudCache(
+      container,
+      resourceKind,
+      { id: row.id, tenantId: row.tenantId, organizationId: row.organizationId },
+      row.tenantId,
+      'updated',
+    )
+    await emitEcommerceEvent(eventId, buildPayload(row), {
+      persistent: true,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+    })
+  }
+}
+
+export function announceStoresUpdated(container: CrudCtx['container'], stores: EcommerceStore[]): Promise<void> {
+  return announceUpdatedRows(container, STORE_EVENT_ENTITY, 'ecommerce.store.updated', stores, buildStoreEventPayload)
+}
+
+export function announceStoreBrandingUpdated(container: CrudCtx['container'], store: EcommerceStore): Promise<void> {
+  return announceUpdatedRows(container, STORE_EVENT_ENTITY, 'ecommerce.store.branding_updated', [store], buildStoreEventPayload)
+}
+
+export function announceStoreDomainBindingsUpdated(
+  container: CrudCtx['container'],
+  bindings: EcommerceStoreDomainBinding[],
+): Promise<void> {
+  return announceUpdatedRows(container, STORE_DOMAIN_BINDING_EVENT_ENTITY, 'ecommerce.store_domain_binding.updated', bindings, buildStoreDomainBindingEventPayload)
+}
+
+export function announceStoreChannelBindingsUpdated(
+  container: CrudCtx['container'],
+  bindings: EcommerceStoreChannelBinding[],
+): Promise<void> {
+  return announceUpdatedRows(container, STORE_CHANNEL_BINDING_EVENT_ENTITY, 'ecommerce.store_channel_binding.updated', bindings, buildStoreChannelBindingEventPayload)
+}

package/src/modules/ecommerce/lib/crudSupport.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { EntityName, FilterQuery } from '@mikro-orm/core'
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+
+export type Translate = (key: string, fallback?: string) => string
+
+export type EcommerceWriteScope = { tenantId: string; organizationId: string }
+
+export function resolveWriteScope(ctx: CrudCtx): EcommerceWriteScope {
+  const tenantId = ctx.auth?.tenantId ?? null
+  if (!tenantId) throw new CrudHttpError(400, { error: '[internal] ecommerce write scope is missing a tenant id' })
+  const organizationId = resolveScopeOrganizationId(ctx)
+  if (!organizationId) {
+    throw new CrudHttpError(400, { error: '[internal] ecommerce write scope is missing an organization id' })
+  }
+  return { tenantId, organizationId }
+}
+
+export function resolveScopeOrganizationId(ctx: CrudCtx): string | null {
+  return ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+}
+
+const recordIdSchema = z.string().uuid()
+
+type ScopedRecord = { id: string; tenantId: string; organizationId: string; deletedAt?: Date | null }
+
+/**
+ * Writes, reference checks, enrichers and the branding routes all work in the single organization of
+ * `resolveWriteScope`, while the CRUD factory also admits descendant organizations. Updates and
+ * deletes are held to that organization too, so a parent selection cannot half-edit a child
+ * organization's record; a record outside it answers the same 404 as a missing one.
+ */
+export async function assertRecordInWriteScope<T extends ScopedRecord>(
+  ctx: CrudCtx,
+  entityName: EntityName<T>,
+  id: unknown,
+  notFound: { key: string; fallback: string },
+): Promise<void> {
+  const tenantId = ctx.auth?.tenantId ?? null
+  const organizationId = resolveScopeOrganizationId(ctx)
+  if (typeof id !== 'string' || !recordIdSchema.safeParse(id).success || !tenantId || !organizationId) return
+  const em = (ctx.container.resolve('em') as EntityManager).fork()
+  const record = await findOneWithDecryption(
+    em,
+    entityName,
+    { id, tenantId, deletedAt: null } as FilterQuery<T>,
+    undefined,
+    { tenantId, organizationId },
+  )
+  if (!record || record.organizationId === organizationId) return
+  throw new CrudHttpError(404, { error: await translateEcommerceError(notFound.key, notFound.fallback) })
+}
+
+export function hasOwn(input: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(input, key)
+}
+
+/**
+ * A client-facing error message from the `ecommerce.errors.*` catalogue, falling back to `fallback`
+ * when translations cannot be loaded (route catch blocks must still answer).
+ */
+export async function translateEcommerceError(key: string, fallback: string): Promise<string> {
+  try {
+    const { translate } = await resolveTranslations()
+    return translate(key, fallback)
+  } catch {
+    return fallback
+  }
+}
+
+export const ECOMMERCE_INTERNAL_ERROR_KEY = 'ecommerce.errors.internal'
+export const ECOMMERCE_INTERNAL_ERROR_FALLBACK = 'Something went wrong. Try again.'
+
+export async function ecommerceInternalErrorBody(): Promise<{ error: string }> {
+  return { error: await translateEcommerceError(ECOMMERCE_INTERNAL_ERROR_KEY, ECOMMERCE_INTERNAL_ERROR_FALLBACK) }
+}
+
+export function fieldError(status: number, fieldErrors: Record<string, string>): CrudHttpError {
+  const [message] = Object.values(fieldErrors)
+  return new CrudHttpError(status, { error: message, fieldErrors })
+}

package/src/modules/ecommerce/lib/domainBindingRebind.ts

@@ -0,0 +1,138 @@
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import type { AwilixContainer } from 'awilix'
+import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
+import { invalidateCrudCache } from '@open-mercato/shared/lib/crud/cache'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { EcommerceStoreDomainBinding } from '../data/entities'
+import { resourceKindFor, STORE_DOMAIN_BINDING_EVENT_ENTITY } from './crudEvents'
+import { domainBindingEvents, domainBindingIndexer } from './storeBindingCascade'
+import {
+  asPayloadRecord,
+  readEventScope,
+  readPayloadString,
+  tryResolveService,
+  type EcommerceSubscriberContext,
+} from './subscriberSupport'
+
+/**
+ * Follows `customer_accounts` domain supersession (SPEC-029 §5.2, D5): when a replacement mapping
+ * becomes active, `customer_accounts.domain_mapping.replaced` carries the new mapping as `id` and the
+ * superseded one as `replacedDomainId`. Every live binding on the superseded id is re-pointed to the
+ * new id within the same tenant and organization. Re-running is a no-op because no binding is left
+ * on the superseded id; a binding whose `path_prefix` is already taken on the new mapping stays on
+ * the superseded id (dangling, R3) and is logged.
+ */
+
+export type DomainMappingReplacement = {
+  domainMappingId: string
+  replacedDomainMappingId: string
+  tenantId: string
+  organizationId: string
+}
+
+export type DomainBindingRebindResult = {
+  rebound: EcommerceStoreDomainBinding[]
+  skipped: EcommerceStoreDomainBinding[]
+}
+
+const logger = createLogger('ecommerce').child({ component: 'domain-binding-rebind' })
+
+export function readDomainMappingReplacement(
+  payload: unknown,
+  ctx: EcommerceSubscriberContext,
+): DomainMappingReplacement | null {
+  const record = asPayloadRecord(payload)
+  const domainMappingId = readPayloadString(record, 'id')
+  const replacedDomainMappingId = readPayloadString(record, 'replacedDomainId')
+  const { tenantId, organizationId } = readEventScope(record, ctx)
+  if (!domainMappingId || !replacedDomainMappingId || !tenantId || !organizationId) return null
+  if (domainMappingId === replacedDomainMappingId) return null
+  return { domainMappingId, replacedDomainMappingId, tenantId, organizationId }
+}
+
+function prefixKey(binding: EcommerceStoreDomainBinding): string {
+  return binding.pathPrefix ?? ''
+}
+
+function findLiveBindings(
+  em: EntityManager,
+  domainMappingId: string,
+  replacement: DomainMappingReplacement,
+): Promise<EcommerceStoreDomainBinding[]> {
+  const scope = { tenantId: replacement.tenantId, organizationId: replacement.organizationId }
+  return findWithDecryption(
+    em,
+    EcommerceStoreDomainBinding,
+    { domainMappingId, ...scope, deletedAt: null } as FilterQuery<EcommerceStoreDomainBinding>,
+    undefined,
+    scope,
+  )
+}
+
+async function announceRebound(
+  ctx: EcommerceSubscriberContext,
+  bindings: EcommerceStoreDomainBinding[],
+): Promise<void> {
+  const dataEngine = tryResolveService<DataEngine>(ctx, 'dataEngine')
+  if (dataEngine) {
+    for (const binding of bindings) {
+      dataEngine.markOrmEntityChange({
+        action: 'updated',
+        entity: binding,
+        identifiers: { id: binding.id, tenantId: binding.tenantId, organizationId: binding.organizationId },
+        events: domainBindingEvents,
+        indexer: domainBindingIndexer,
+      })
+    }
+    await dataEngine.flushOrmEntityChanges()
+  }
+  const container = { resolve: ctx.resolve } as unknown as AwilixContainer
+  const resourceKind = resourceKindFor(STORE_DOMAIN_BINDING_EVENT_ENTITY)
+  for (const binding of bindings) {
+    await invalidateCrudCache(
+      container,
+      resourceKind,
+      { id: binding.id, tenantId: binding.tenantId, organizationId: binding.organizationId },
+      binding.tenantId,
+      'updated',
+    )
+  }
+}
+
+export async function rebindReplacedDomainMapping(
+  ctx: EcommerceSubscriberContext,
+  replacement: DomainMappingReplacement,
+): Promise<DomainBindingRebindResult> {
+  const rootEm = tryResolveService<EntityManager>(ctx, 'em')
+  if (!rootEm) throw new Error('[internal] ecommerce domain re-binding requires the DI entity manager')
+  const em = rootEm.fork()
+  const superseded = await findLiveBindings(em, replacement.replacedDomainMappingId, replacement)
+  if (superseded.length === 0) return { rebound: [], skipped: [] }
+  const existing = await findLiveBindings(em, replacement.domainMappingId, replacement)
+  const takenPrefixes = new Set(existing.map(prefixKey))
+  const rebound: EcommerceStoreDomainBinding[] = []
+  const skipped: EcommerceStoreDomainBinding[] = []
+  for (const binding of superseded) {
+    const key = prefixKey(binding)
+    if (takenPrefixes.has(key)) {
+      skipped.push(binding)
+      continue
+    }
+    takenPrefixes.add(key)
+    binding.domainMappingId = replacement.domainMappingId
+    rebound.push(binding)
+  }
+  if (rebound.length > 0) await em.flush()
+  for (const binding of skipped) {
+    logger.warn('Domain binding not re-pointed: path prefix already bound on the replacement mapping', {
+      bindingId: binding.id,
+      storeId: binding.storeId,
+      pathPrefix: binding.pathPrefix ?? null,
+      domainMappingId: replacement.domainMappingId,
+      replacedDomainMappingId: replacement.replacedDomainMappingId,
+    })
+  }
+  if (rebound.length > 0) await announceRebound(ctx, rebound)
+  return { rebound, skipped }
+}

package/src/modules/ecommerce/lib/domainMappingSummaries.ts

@@ -0,0 +1,71 @@
+export const DOMAIN_MAPPING_STATUSES = ['pending', 'verified', 'active', 'dns_failed', 'tls_failed'] as const
+
+export type DomainMappingStatus = (typeof DOMAIN_MAPPING_STATUSES)[number]
+
+export type DomainMappingSummary = {
+  id: string
+  hostname: string
+  status: string
+  lastDnsCheckAt: string | null
+  dnsFailureReason: string | null
+  tlsFailureReason: string | null
+}
+
+type DomainMappingRecord = {
+  id: string
+  hostname: string
+  organizationId: string
+  tenantId: string
+  status?: string | null
+  lastDnsCheckAt?: Date | string | null
+  dnsFailureReason?: string | null
+  tlsFailureReason?: string | null
+}
+
+type DomainMappingReader = {
+  findByOrganization(organizationId: string, scope?: { tenantId?: string }): Promise<DomainMappingRecord[]>
+}
+
+type ContainerLike = { resolve(name: string): unknown }
+
+export function isDomainMappingStatus(value: unknown): value is DomainMappingStatus {
+  return typeof value === 'string' && (DOMAIN_MAPPING_STATUSES as readonly string[]).includes(value)
+}
+
+function toIsoString(value: Date | string | null | undefined): string | null {
+  if (!value) return null
+  const date = value instanceof Date ? value : new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date.toISOString()
+}
+
+function toSummary(record: DomainMappingRecord): DomainMappingSummary {
+  return {
+    id: record.id,
+    hostname: record.hostname,
+    status: record.status ?? 'pending',
+    lastDnsCheckAt: toIsoString(record.lastDnsCheckAt),
+    dnsFailureReason: record.dnsFailureReason ?? null,
+    tlsFailureReason: record.tlsFailureReason ?? null,
+  }
+}
+
+function resolveDomainMappingReader(container: unknown): DomainMappingReader | null {
+  try {
+    const service = (container as ContainerLike).resolve('domainMappingService') as DomainMappingReader | null | undefined
+    return service && typeof service.findByOrganization === 'function' ? service : null
+  } catch {
+    return null
+  }
+}
+
+export async function loadOrganizationDomainMappings(
+  container: unknown,
+  scope: { organizationId: string; tenantId: string },
+): Promise<DomainMappingSummary[] | null> {
+  const reader = resolveDomainMappingReader(container)
+  if (!reader) return null
+  const records = await reader.findByOrganization(scope.organizationId, { tenantId: scope.tenantId })
+  return records
+    .filter((record) => record.tenantId === scope.tenantId && record.organizationId === scope.organizationId)
+    .map(toSummary)
+}

package/src/modules/ecommerce/lib/exclusiveFlag.ts

@@ -0,0 +1,90 @@
+import type { EntityData, EntityManager, EntityName, FilterQuery } from '@mikro-orm/postgresql'
+import { isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+
+export type ExclusiveFlagRow = { id: string }
+
+export type ExclusiveFlagConfig<T extends ExclusiveFlagRow> = {
+  entity: EntityName<T>
+  flag: 'isPrimary' | 'isDefault'
+  constraint: string
+}
+
+export type ExclusiveFlagScope = Record<string, string>
+
+const PROMOTION_ATTEMPTS = 3
+
+function flaggedRowsWhere<T extends ExclusiveFlagRow>(
+  config: ExclusiveFlagConfig<T>,
+  scope: ExclusiveFlagScope,
+  keepId: string | null,
+): FilterQuery<T> {
+  const where: Record<string, unknown> = { ...scope, [config.flag]: true, deletedAt: null }
+  if (keepId) where.id = { $ne: keepId }
+  return where as FilterQuery<T>
+}
+
+function ownRowWhere<T extends ExclusiveFlagRow>(scope: ExclusiveFlagScope, id: string): FilterQuery<T> {
+  return { ...scope, id, deletedAt: null } as FilterQuery<T>
+}
+
+function flagData<T extends ExclusiveFlagRow>(config: ExclusiveFlagConfig<T>, value: boolean, now?: Date): EntityData<T> {
+  const data: Record<string, unknown> = { [config.flag]: value }
+  if (now) data.updatedAt = now
+  return data as EntityData<T>
+}
+
+export async function clearExclusiveFlag<T extends ExclusiveFlagRow>(
+  em: EntityManager,
+  config: ExclusiveFlagConfig<T>,
+  scope: ExclusiveFlagScope,
+  keepId: string | null,
+): Promise<T[]> {
+  const where = flaggedRowsWhere(config, scope, keepId)
+  const cleared = await findWithDecryption(em, config.entity, where, undefined, {
+    tenantId: scope.tenantId ?? null,
+    organizationId: scope.organizationId ?? null,
+  })
+  if (!cleared.length) return []
+  await em.nativeUpdate(config.entity, where, flagData(config, false, new Date()))
+  return cleared
+}
+
+export async function promoteExclusiveFlag<T extends ExclusiveFlagRow>(
+  em: EntityManager,
+  config: ExclusiveFlagConfig<T>,
+  scope: ExclusiveFlagScope,
+  id: string,
+  now: Date,
+): Promise<{ promoted: boolean; cleared: T[] }> {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      const cleared = await em.transactional(async (tem) => {
+        const rows = await clearExclusiveFlag(tem, config, scope, id)
+        await tem.nativeUpdate(config.entity, ownRowWhere<T>(scope, id), flagData(config, true, now))
+        return rows
+      })
+      return { promoted: true, cleared }
+    } catch (err) {
+      if (!isUniqueViolation(err, config.constraint)) throw err
+      if (attempt >= PROMOTION_ATTEMPTS) return { promoted: false, cleared: [] }
+    }
+  }
+}
+
+export async function assignExclusiveFlag<T extends ExclusiveFlagRow>(
+  em: EntityManager,
+  config: ExclusiveFlagConfig<T>,
+  scope: ExclusiveFlagScope,
+  id: string,
+  toConflict: () => unknown,
+): Promise<T[]> {
+  try {
+    const cleared = await clearExclusiveFlag(em, config, scope, id)
+    await em.nativeUpdate(config.entity, ownRowWhere<T>(scope, id), flagData(config, true))
+    return cleared
+  } catch (err) {
+    if (isUniqueViolation(err, config.constraint)) throw toConflict()
+    throw err
+  }
+}

package/src/modules/ecommerce/lib/references.ts

@@ -0,0 +1,93 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CatalogPriceKind } from '@open-mercato/core/modules/catalog/data/entities'
+import { SalesChannel } from '@open-mercato/core/modules/sales/data/entities'
+import { EcommerceStore } from '../data/entities'
+import { fieldError, type EcommerceWriteScope, type Translate } from './crudSupport'
+
+type DomainMappingReader = {
+  findById(id: string, scope?: { tenantId?: string }): Promise<{ tenantId: string; organizationId: string } | null>
+}
+
+export async function assertStoreInScope(
+  em: EntityManager,
+  storeId: string,
+  scope: EcommerceWriteScope,
+  translate: Translate,
+): Promise<void> {
+  const store = await findOneWithDecryption(
+    em,
+    EcommerceStore,
+    { id: storeId, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    undefined,
+    scope,
+  )
+  if (store) return
+  throw fieldError(400, {
+    storeId: translate('ecommerce.errors.storeNotFound', 'The selected store does not exist in this organization.'),
+  })
+}
+
+export async function assertDomainMappingInScope(
+  container: CrudCtx['container'],
+  domainMappingId: string,
+  scope: EcommerceWriteScope,
+  translate: Translate,
+): Promise<void> {
+  const service = container.resolve<DomainMappingReader>('domainMappingService')
+  const mapping = await service.findById(domainMappingId, { tenantId: scope.tenantId })
+  if (mapping && mapping.tenantId === scope.tenantId && mapping.organizationId === scope.organizationId) return
+  throw fieldError(400, {
+    domainMappingId: translate(
+      'ecommerce.errors.domainMappingNotFound',
+      'The selected domain does not belong to this organization.',
+    ),
+  })
+}
+
+export async function assertSalesChannelInScope(
+  em: EntityManager,
+  salesChannelId: string,
+  scope: EcommerceWriteScope,
+  translate: Translate,
+): Promise<void> {
+  const channel = await findOneWithDecryption(
+    em,
+    SalesChannel,
+    { id: salesChannelId, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    undefined,
+    scope,
+  )
+  if (channel) return
+  throw fieldError(400, {
+    salesChannelId: translate(
+      'ecommerce.errors.salesChannelNotFound',
+      'The selected sales channel does not exist in this organization.',
+    ),
+  })
+}
+
+export async function assertPriceKindInScope(
+  em: EntityManager,
+  priceKindId: string,
+  scope: EcommerceWriteScope,
+  translate: Translate,
+): Promise<void> {
+  const priceKind = await findOneWithDecryption(
+    em,
+    CatalogPriceKind,
+    {
+      id: priceKindId,
+      tenantId: scope.tenantId,
+      deletedAt: null,
+      $or: [{ organizationId: null }, { organizationId: scope.organizationId }],
+    },
+    undefined,
+    scope,
+  )
+  if (priceKind) return
+  throw fieldError(400, {
+    priceKindId: translate('ecommerce.errors.priceKindNotFound', 'The selected price kind does not exist in this organization.'),
+  })
+}