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

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

@@ -0,0 +1,125 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { defaultLocale } from '@open-mercato/shared/lib/i18n/config'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { slugify } from '@open-mercato/shared/lib/slugify'
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
+import { Organization } from '@open-mercato/core/modules/directory/data/entities'
+import { EcommerceStore } from '../data/entities'
+import { ecommerceStoreCreateSchema } from '../data/validators'
+import { buildStoreEventPayload } from './crudEvents'
+import { emitEcommerceEvent } from '../events'
+
+const logger = createLogger('ecommerce').child({ component: 'seed-draft-store' })
+
+export const DEFAULT_DRAFT_STORE_NAME = 'Default store'
+export const DEFAULT_DRAFT_STORE_CODE = 'default'
+export const DEFAULT_DRAFT_STORE_CURRENCY = 'USD'
+
+const CODE_MAX_LENGTH = 80
+
+export type SeedDraftStoreScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type SeedDraftStoreOptions = {
+  resolveCurrencyCode?: () => Promise<string | null>
+}
+
+export type SeedDraftStoreResult =
+  | { status: 'created'; storeId: string }
+  | { status: 'exists' }
+
+export type DraftStoreIdentity = {
+  name: string
+  code: string
+  slug: string
+}
+
+export function deriveDraftStoreIdentity(organizationName: string | null | undefined): DraftStoreIdentity {
+  const name = (organizationName ?? '').trim().slice(0, 200) || DEFAULT_DRAFT_STORE_NAME
+  const slug = slugify(name).replace(/-{2,}/g, '-').slice(0, CODE_MAX_LENGTH).replace(/-+$/, '') || DEFAULT_DRAFT_STORE_CODE
+  return { name, code: slug, slug }
+}
+
+async function tenantHasStore(em: EntityManager, tenantId: string): Promise<boolean> {
+  return (await em.count(EcommerceStore, { tenantId })) > 0
+}
+
+async function loadOrganizationName(em: EntityManager, scope: SeedDraftStoreScope): Promise<string | null> {
+  const organization = await findOneWithDecryption(
+    em,
+    Organization,
+    { id: scope.organizationId, tenant: scope.tenantId },
+    undefined,
+    scope,
+  )
+  return organization?.name ?? null
+}
+
+async function announceCreated(store: EcommerceStore): Promise<void> {
+  try {
+    await emitEcommerceEvent('ecommerce.store.created', buildStoreEventPayload(store), {
+      persistent: true,
+      tenantId: store.tenantId,
+      organizationId: store.organizationId,
+    })
+  } catch (err) {
+    logger.warn('draft store created but the created event could not be emitted', { storeId: store.id, err })
+    getTelemetryRuntime()?.reportError(err, { module: 'ecommerce', code: 'ecommerce.seed_draft_store_event_failed' })
+  }
+}
+
+export async function seedDraftStore(
+  em: EntityManager,
+  scope: SeedDraftStoreScope,
+  options: SeedDraftStoreOptions = {},
+): Promise<SeedDraftStoreResult> {
+  if (await tenantHasStore(em, scope.tenantId)) return { status: 'exists' }
+
+  const identity = deriveDraftStoreIdentity(await loadOrganizationName(em, scope))
+  const resolvedCurrency = options.resolveCurrencyCode ? await options.resolveCurrencyCode() : null
+  const input = ecommerceStoreCreateSchema.parse({
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+    code: identity.code,
+    name: identity.name,
+    slug: identity.slug,
+    status: 'draft',
+    defaultLocale,
+    supportedLocales: [defaultLocale],
+    defaultCurrencyCode: resolvedCurrency ?? DEFAULT_DRAFT_STORE_CURRENCY,
+    isPrimary: false,
+  })
+
+  let store: EcommerceStore
+  try {
+    store = await em.transactional(async (tem) => {
+      const created = tem.create(EcommerceStore, {
+        organizationId: input.organizationId,
+        tenantId: input.tenantId,
+        code: input.code,
+        name: input.name,
+        slug: input.slug,
+        status: input.status,
+        defaultLocale: input.defaultLocale,
+        supportedLocales: input.supportedLocales,
+        defaultCurrencyCode: input.defaultCurrencyCode,
+        isPrimary: false,
+        settings: input.settings,
+      })
+      tem.persist(created)
+      await tem.flush()
+      return created
+    })
+  } catch (err) {
+    if (!isUniqueViolation(err)) throw err
+    logger.info('draft store already seeded concurrently', { tenantId: scope.tenantId, organizationId: scope.organizationId })
+    return { status: 'exists' }
+  }
+  await announceCreated(store)
+  logger.info('draft store seeded', { tenantId: scope.tenantId, organizationId: scope.organizationId, storeId: store.id })
+  return { status: 'created', storeId: store.id }
+}

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

@@ -0,0 +1,138 @@
+import type { EntityName } from '@mikro-orm/core'
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import type { CrudEventsConfig, CrudIndexerConfig } from '@open-mercato/shared/lib/crud/types'
+import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
+import { buildScopedWhere } from '@open-mercato/shared/lib/api/crud'
+import { invalidateCrudCache } from '@open-mercato/shared/lib/crud/cache'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { E } from '#generated/entities.ids.generated'
+import { EcommerceStore, EcommerceStoreChannelBinding, EcommerceStoreDomainBinding } from '../data/entities'
+import {
+  buildStoreChannelBindingEventPayload,
+  buildStoreDomainBindingEventPayload,
+  ECOMMERCE_EVENTS_MODULE,
+  resourceKindFor,
+  STORE_CHANNEL_BINDING_EVENT_ENTITY,
+  STORE_DOMAIN_BINDING_EVENT_ENTITY,
+} from './crudEvents'
+
+export type StoreBindingCascade = {
+  domainBindings: EcommerceStoreDomainBinding[]
+  channelBindings: EcommerceStoreChannelBinding[]
+}
+
+export const domainBindingEvents: CrudEventsConfig<EcommerceStoreDomainBinding> = {
+  module: ECOMMERCE_EVENTS_MODULE,
+  entity: STORE_DOMAIN_BINDING_EVENT_ENTITY,
+  persistent: true,
+  buildPayload: (emitCtx) => buildStoreDomainBindingEventPayload(emitCtx.entity),
+}
+
+const channelBindingEvents: CrudEventsConfig<EcommerceStoreChannelBinding> = {
+  module: ECOMMERCE_EVENTS_MODULE,
+  entity: STORE_CHANNEL_BINDING_EVENT_ENTITY,
+  persistent: true,
+  buildPayload: (emitCtx) => buildStoreChannelBindingEventPayload(emitCtx.entity),
+}
+
+export const domainBindingIndexer: CrudIndexerConfig<EcommerceStoreDomainBinding> = {
+  entityType: E.ecommerce.ecommerce_store_domain_binding,
+}
+
+const channelBindingIndexer: CrudIndexerConfig<EcommerceStoreChannelBinding> = {
+  entityType: E.ecommerce.ecommerce_store_channel_binding,
+}
+
+type StoreBinding = EcommerceStoreDomainBinding | EcommerceStoreChannelBinding
+
+async function softDeleteLiveBindings<TBinding extends StoreBinding>(
+  em: EntityManager,
+  entity: EntityName<TBinding>,
+  where: Record<string, unknown>,
+  decryptionScope: { tenantId: string; organizationId: string },
+  now: Date,
+): Promise<TBinding[]> {
+  const rows = await findWithDecryption(em, entity, where as FilterQuery<TBinding>, undefined, decryptionScope)
+  if (!rows.length) return rows
+  await em.nativeUpdate(
+    entity,
+    { id: { $in: rows.map((row) => row.id) }, deletedAt: null } as FilterQuery<TBinding>,
+    { deletedAt: now } as Partial<TBinding>,
+  )
+  for (const row of rows) row.deletedAt = now
+  return rows
+}
+
+export async function cascadeStoreBindingDelete(
+  em: EntityManager,
+  storeId: string,
+  ctx: CrudCtx,
+  now: Date = new Date(),
+): Promise<StoreBindingCascade> {
+  const tenantId = ctx.auth?.tenantId ?? null
+  const organizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+  if (!tenantId || !organizationId) return { domainBindings: [], channelBindings: [] }
+  const where = buildScopedWhere(
+    { storeId },
+    {
+      organizationId,
+      organizationIds: ctx.organizationIds ?? undefined,
+      tenantId,
+      orgField: 'organizationId',
+      tenantField: 'tenantId',
+      softDeleteField: 'deletedAt',
+    },
+  )
+  const decryptionScope = { tenantId, organizationId }
+  try {
+    return await em.transactional(async (tem) => ({
+      domainBindings: await softDeleteLiveBindings(tem, EcommerceStoreDomainBinding, where, decryptionScope, now),
+      channelBindings: await softDeleteLiveBindings(tem, EcommerceStoreChannelBinding, where, decryptionScope, now),
+    }))
+  } catch (err) {
+    await em.nativeUpdate(EcommerceStore, { id: storeId, tenantId, deletedAt: { $ne: null } }, { deletedAt: null })
+    throw err
+  }
+}
+
+type ScopedRow = { id: string; tenantId: string; organizationId: string }
+
+function identifiersOf(row: ScopedRow) {
+  return { id: row.id, tenantId: row.tenantId, organizationId: row.organizationId }
+}
+
+export async function announceStoreBindingCascade(
+  container: CrudCtx['container'],
+  cascade: StoreBindingCascade,
+): Promise<void> {
+  if (!cascade.domainBindings.length && !cascade.channelBindings.length) return
+  const dataEngine = container.resolve('dataEngine') as DataEngine
+  for (const binding of cascade.domainBindings) {
+    dataEngine.markOrmEntityChange({
+      action: 'deleted',
+      entity: binding,
+      identifiers: identifiersOf(binding),
+      events: domainBindingEvents,
+      indexer: domainBindingIndexer,
+    })
+  }
+  for (const binding of cascade.channelBindings) {
+    dataEngine.markOrmEntityChange({
+      action: 'deleted',
+      entity: binding,
+      identifiers: identifiersOf(binding),
+      events: channelBindingEvents,
+      indexer: channelBindingIndexer,
+    })
+  }
+  await dataEngine.flushOrmEntityChanges()
+  const domainResourceKind = resourceKindFor(STORE_DOMAIN_BINDING_EVENT_ENTITY)
+  for (const binding of cascade.domainBindings) {
+    await invalidateCrudCache(container, domainResourceKind, identifiersOf(binding), binding.tenantId, 'deleted')
+  }
+  const channelResourceKind = resourceKindFor(STORE_CHANNEL_BINDING_EVENT_ENTITY)
+  for (const binding of cascade.channelBindings) {
+    await invalidateCrudCache(container, channelResourceKind, identifiersOf(binding), binding.tenantId, 'deleted')
+  }
+}

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

@@ -0,0 +1,48 @@
+import { ecommerceStoreBrandingSchema, type EcommerceStoreBranding } from '../data/validators'
+import type { Translate } from './crudSupport'
+
+export const STORE_BRANDING_UPDATE_COMMAND_ID = 'ecommerce.stores.branding.update'
+export const STORE_BRANDING_RESOURCE_KIND = 'ecommerce.store'
+
+export type BrandingFieldErrors = Record<string, string>
+
+const I18N_KEY_PATTERN = /^ecommerce\.[A-Za-z0-9_.]+$/
+
+export function compactBranding(branding: EcommerceStoreBranding): EcommerceStoreBranding {
+  const entries = Object.entries(branding).filter(([, value]) => value !== undefined && value !== null && value !== '')
+  return Object.fromEntries(entries) as EcommerceStoreBranding
+}
+
+export function mergeBrandingIntoSettings<TSettings extends object>(
+  settings: TSettings | null | undefined,
+  branding: EcommerceStoreBranding,
+): TSettings & { branding: EcommerceStoreBranding } {
+  return { ...(settings ?? ({} as TSettings)), branding: compactBranding(branding) }
+}
+
+function readIssueMessage(message: string, translate: Translate): string {
+  return I18N_KEY_PATTERN.test(message) ? translate(message, message) : message
+}
+
+export type BrandingParseResult =
+  | { ok: true; branding: EcommerceStoreBranding }
+  | { ok: false; fieldErrors: BrandingFieldErrors }
+
+export function parseBrandingInput(input: unknown, translate: Translate): BrandingParseResult {
+  const result = ecommerceStoreBrandingSchema.safeParse(input)
+  if (result.success) return { ok: true, branding: compactBranding(result.data) }
+  const fieldErrors: BrandingFieldErrors = {}
+  for (const issue of result.error.issues) {
+    if (issue.code === 'unrecognized_keys') {
+      for (const key of issue.keys) {
+        fieldErrors[key] = translate('ecommerce.validation.brandingFieldUnknown', 'This branding setting does not exist.')
+      }
+      continue
+    }
+    const field = issue.path.length ? issue.path.map(String).join('.') : 'branding'
+    if (fieldErrors[field] === undefined) {
+      fieldErrors[field] = readIssueMessage(issue.message, translate)
+    }
+  }
+  return { ok: false, fieldErrors }
+}

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

@@ -0,0 +1,91 @@
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { AwilixContainer } from 'awilix'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest, type AuthContext } from '@open-mercato/shared/lib/auth/server'
+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'
+import type { CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { EcommerceStore } from '../data/entities'
+import { fieldError, translateEcommerceError } from './crudSupport'
+
+export const BRANDING_MANAGE_FEATURE = 'ecommerce.branding.manage'
+
+export const storeIdParamSchema = z.string().uuid()
+
+export type BrandingRouteContext = {
+  container: AwilixContainer
+  auth: AuthContext & { tenantId: string }
+  tenantId: string
+  organizationId: string
+  commandCtx: CommandRuntimeContext
+}
+
+export async function resolveBrandingRouteContext(request: Request): Promise<BrandingRouteContext> {
+  const container = await createRequestContainer()
+  const auth = await getAuthFromRequest(request)
+  if (!auth || !auth.tenantId) {
+    throw new CrudHttpError(401, { error: await translateEcommerceError('ecommerce.errors.unauthorized', 'Sign in to continue.') })
+  }
+  const scope = await resolveOrganizationScopeForRequest({ container, auth, request })
+  const tenantId = scope?.tenantId ?? auth.tenantId
+  const organizationId = scope?.selectedId ?? auth.orgId ?? null
+  if (!organizationId) {
+    const { translate } = await resolveTranslations()
+    throw fieldError(400, {
+      organizationId: translate('ecommerce.errors.organizationRequired', 'Select an organization first.'),
+    })
+  }
+  const scopedAuth = { ...auth, tenantId, orgId: organizationId }
+  const commandCtx: CommandRuntimeContext = {
+    container,
+    auth: scopedAuth,
+    organizationScope: scope,
+    selectedOrganizationId: organizationId,
+    organizationIds: scope?.filterIds ?? [organizationId],
+    request,
+  }
+  return { container, auth: scopedAuth, tenantId, organizationId, commandCtx }
+}
+
+export async function resolveGrantedFeatures(context: BrandingRouteContext): Promise<string[]> {
+  const declared = context.auth.features
+  const fallback = Array.isArray(declared) ? declared.filter((value): value is string => typeof value === 'string') : []
+  try {
+    const rbac = context.container.resolve('rbacService') as
+      | {
+          getGrantedFeatures?: (
+            userId: string,
+            scope: { tenantId: string | null; organizationId: string | null },
+          ) => Promise<string[]>
+        }
+      | undefined
+    if (rbac?.getGrantedFeatures && context.auth.sub) {
+      return await rbac.getGrantedFeatures(context.auth.sub, {
+        tenantId: context.tenantId,
+        organizationId: context.organizationId,
+      })
+    }
+  } catch {
+    return fallback
+  }
+  return fallback
+}
+
+export async function requireScopedStore(context: BrandingRouteContext, storeId: string): Promise<EcommerceStore> {
+  const em = (context.container.resolve('em') as EntityManager).fork()
+  const store = await findOneWithDecryption(
+    em,
+    EcommerceStore,
+    { id: storeId, tenantId: context.tenantId, organizationId: context.organizationId, deletedAt: null },
+    undefined,
+    { tenantId: context.tenantId, organizationId: context.organizationId },
+  )
+  if (store) return store
+  const { translate } = await resolveTranslations()
+  throw new CrudHttpError(404, {
+    error: translate('ecommerce.errors.storeNotFound', 'The selected store does not exist in this organization.'),
+  })
+}