@open-mercato/core 0.5.1-develop.2663.2c29774b5b → 0.5.1-develop.2681.c559bb2bc3

package/src/modules/customers/commands/dictionaries.ts

@@ -6,6 +6,8 @@ import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { invalidateDictionaryCache } from '../api/dictionaries/cache'
 import type { CacheStrategy } from '@open-mercato/cache'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { loadRoleTypeUsage } from '../lib/roleTypeUsage'
 import {
   customerDictionaryEntryCreateSchema,
   customerDictionaryEntryDeleteSchema,
@@ -40,6 +42,16 @@ type CustomerDictionaryEntryUndoPayload = {
   after?: CustomerDictionaryEntrySnapshot | null
 }
 
+function buildRoleTypeInUseError(usageCount: number, ownerAssignments: number, relationshipAssignments: number) {
+  return new CrudHttpError(409, {
+    code: 'role_type_in_use',
+    error: 'Role type is in use',
+    usageCount,
+    ownerAssignments,
+    relationshipAssignments,
+  })
+}
+
 function normalizeValue(input: string): { value: string; normalized: string } {
   const trimmed = input.trim()
   if (!trimmed) {
@@ -74,8 +86,12 @@ function toSnapshot(entry: CustomerDictionaryEntry): CustomerDictionaryEntrySnap
   }
 }
 
-async function loadSnapshot(em: EntityManager, id: string): Promise<CustomerDictionaryEntrySnapshot | null> {
-  const entry = await em.findOne(CustomerDictionaryEntry, { id })
+async function loadSnapshot(
+  em: EntityManager,
+  id: string,
+  scope: { tenantId: string | null; organizationId: string | null },
+): Promise<CustomerDictionaryEntrySnapshot | null> {
+  const entry = await findOneWithDecryption(em, CustomerDictionaryEntry, { id }, {}, scope)
   return entry ? toSnapshot(entry) : null
 }
 
@@ -98,7 +114,8 @@ async function invalidateCache(
   let cache: CacheStrategy | undefined
   try {
     cache = (ctx.container.resolve('cache') as CacheStrategy)
-  } catch {
+  } catch (err) {
+    console.warn('[customers.commands.dictionaries] cache resolve failed; skipping invalidation', err)
     cache = undefined
   }
   if (!cache) return
@@ -111,6 +128,8 @@ async function invalidateCache(
 
 type CreateResult = {
   entryId: string
+  tenantId: string
+  organizationId: string
   mode: 'created' | 'updated' | 'unchanged'
   before?: CustomerDictionaryEntrySnapshot | null
 }
@@ -128,12 +147,21 @@ const createDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryCreate
     const color = sanitizeColor(parsed.color)
     const icon = sanitizeIcon(parsed.icon)
 
-    const existing = await em.findOne(CustomerDictionaryEntry, {
-      tenantId: parsed.tenantId,
-      organizationId: parsed.organizationId,
-      kind: parsed.kind,
-      normalizedValue: value.normalized,
-    })
+    const existing = await findOneWithDecryption(
+      em,
+      CustomerDictionaryEntry,
+      {
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+        kind: parsed.kind,
+        normalizedValue: value.normalized,
+      },
+      {},
+      {
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+      },
+    )
 
     if (existing) {
       const before = toSnapshot(existing)
@@ -155,10 +183,22 @@ const createDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryCreate
       if (changed) {
         existing.updatedAt = new Date()
         await em.flush()
-        return { entryId: existing.id, mode: 'updated', before }
+        return {
+          entryId: existing.id,
+          tenantId: parsed.tenantId,
+          organizationId: parsed.organizationId,
+          mode: 'updated',
+          before,
+        }
       }
 
-      return { entryId: existing.id, mode: 'unchanged', before }
+      return {
+        entryId: existing.id,
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+        mode: 'unchanged',
+        before,
+      }
     }
 
     const entry = em.create(CustomerDictionaryEntry, {
@@ -174,11 +214,19 @@ const createDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryCreate
     em.persist(entry)
     await em.flush()
 
-    return { entryId: entry.id, mode: 'created' }
+    return {
+      entryId: entry.id,
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+      mode: 'created',
+    }
   },
   captureAfter: async (_input, result, ctx) => {
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    return loadSnapshot(em, result.entryId)
+    return loadSnapshot(em, result.entryId, {
+      tenantId: result.tenantId,
+      organizationId: result.organizationId,
+    })
   },
   buildLog: async ({ result, snapshots }) => {
     const after = snapshots.after as CustomerDictionaryEntrySnapshot | undefined
@@ -238,7 +286,13 @@ const createDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryCreate
     if (after && !undo.before) {
       ensureTenantScope(ctx, after.tenantId)
       ensureOrganizationScope(ctx, after.organizationId)
-      const entry = await em.findOne(CustomerDictionaryEntry, { id: after.id })
+      const entry = await findOneWithDecryption(
+        em,
+        CustomerDictionaryEntry,
+        { id: after.id },
+        {},
+        { tenantId: after.tenantId, organizationId: after.organizationId },
+      )
       if (entry) {
         await em.removeAndFlush(entry)
         await invalidateCache(ctx, after)
@@ -257,7 +311,13 @@ const createDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryCreate
     if (before) {
       ensureTenantScope(ctx, before.tenantId)
       ensureOrganizationScope(ctx, before.organizationId)
-      let entry = await em.findOne(CustomerDictionaryEntry, { id: before.id })
+      let entry = await findOneWithDecryption(
+        em,
+        CustomerDictionaryEntry,
+        { id: before.id },
+        {},
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
       if (!entry) {
         entry = em.create(CustomerDictionaryEntry, {
           id: before.id,
@@ -282,6 +342,8 @@ const createDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryCreate
 
 type UpdateResult = {
   entryId: string
+  tenantId: string
+  organizationId: string
   changed: boolean
 }
 
@@ -291,8 +353,11 @@ const updateDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryUpdate
     const parsed = customerDictionaryEntryUpdateSchema.parse(rawInput)
     ensureTenantScope(ctx, parsed.tenantId)
     ensureOrganizationScope(ctx, parsed.organizationId)
-    const em = (ctx.container.resolve('em') as EntityManager)
-    const snapshot = await loadSnapshot(em, parsed.id)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const snapshot = await loadSnapshot(em, parsed.id, {
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+    })
     return snapshot ? { before: snapshot } : {}
   },
   async execute(rawInput, ctx) {
@@ -301,7 +366,16 @@ const updateDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryUpdate
     ensureOrganizationScope(ctx, parsed.organizationId)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const entry = await em.findOne(CustomerDictionaryEntry, { id: parsed.id })
+    const entry = await findOneWithDecryption(
+      em,
+      CustomerDictionaryEntry,
+      { id: parsed.id },
+      {},
+      {
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+      },
+    )
     if (!entry || entry.organizationId !== parsed.organizationId || entry.tenantId !== parsed.tenantId || entry.kind !== parsed.kind) {
       throw new CrudHttpError(404, { error: 'Dictionary entry not found' })
     }
@@ -311,13 +385,36 @@ const updateDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryUpdate
     if (parsed.value !== undefined) {
       const value = normalizeValue(parsed.value)
       if (value.normalized !== entry.normalizedValue) {
-        const duplicate = await em.findOne(CustomerDictionaryEntry, {
-          id: { $ne: entry.id },
-          tenantId: parsed.tenantId,
-          organizationId: parsed.organizationId,
-          kind: parsed.kind,
-          normalizedValue: value.normalized,
-        })
+        if (entry.kind === 'person_company_role') {
+          const usage = await loadRoleTypeUsage(em, {
+            tenantId: parsed.tenantId,
+            organizationId: entry.organizationId,
+            value: entry.value,
+          })
+          if (usage.total > 0) {
+            throw buildRoleTypeInUseError(
+              usage.total,
+              usage.ownerAssignments,
+              usage.relationshipAssignments,
+            )
+          }
+        }
+        const duplicate = await findOneWithDecryption(
+          em,
+          CustomerDictionaryEntry,
+          {
+            id: { $ne: entry.id },
+            tenantId: parsed.tenantId,
+            organizationId: parsed.organizationId,
+            kind: parsed.kind,
+            normalizedValue: value.normalized,
+          },
+          {},
+          {
+            tenantId: parsed.tenantId,
+            organizationId: parsed.organizationId,
+          },
+        )
         if (duplicate) {
           throw new CrudHttpError(409, { error: 'An entry with this value already exists' })
         }
@@ -359,11 +456,19 @@ const updateDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryUpdate
       await em.flush()
     }
 
-    return { entryId: entry.id, changed }
+    return {
+      entryId: entry.id,
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+      changed,
+    }
   },
   captureAfter: async (_input, result, ctx) => {
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    return loadSnapshot(em, result.entryId)
+    return loadSnapshot(em, result.entryId, {
+      tenantId: result.tenantId,
+      organizationId: result.organizationId,
+    })
   },
   buildLog: async ({ snapshots, result }) => {
     const before = snapshots.before as CustomerDictionaryEntrySnapshot | undefined
@@ -400,7 +505,13 @@ const updateDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryUpdate
     ensureTenantScope(ctx, before.tenantId)
     ensureOrganizationScope(ctx, before.organizationId)
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    let entry = await em.findOne(CustomerDictionaryEntry, { id: before.id })
+    let entry = await findOneWithDecryption(
+      em,
+      CustomerDictionaryEntry,
+      { id: before.id },
+      {},
+      { tenantId: before.tenantId, organizationId: before.organizationId },
+    )
     if (!entry) {
       entry = em.create(CustomerDictionaryEntry, {
         id: before.id,
@@ -428,8 +539,11 @@ const deleteDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryDelete
     const parsed = customerDictionaryEntryDeleteSchema.parse(rawInput)
     ensureTenantScope(ctx, parsed.tenantId)
     ensureOrganizationScope(ctx, parsed.organizationId)
-    const em = (ctx.container.resolve('em') as EntityManager)
-    const snapshot = await loadSnapshot(em, parsed.id)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const snapshot = await loadSnapshot(em, parsed.id, {
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+    })
     return snapshot ? { before: snapshot } : {}
   },
   async execute(rawInput, ctx) {
@@ -438,10 +552,33 @@ const deleteDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryDelete
     ensureOrganizationScope(ctx, parsed.organizationId)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const entry = await em.findOne(CustomerDictionaryEntry, { id: parsed.id })
+    const entry = await findOneWithDecryption(
+      em,
+      CustomerDictionaryEntry,
+      { id: parsed.id },
+      {},
+      {
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+      },
+    )
     if (!entry || entry.organizationId !== parsed.organizationId || entry.tenantId !== parsed.tenantId || entry.kind !== parsed.kind) {
       throw new CrudHttpError(404, { error: 'Dictionary entry not found' })
     }
+    if (entry.kind === 'person_company_role') {
+      const usage = await loadRoleTypeUsage(em, {
+        tenantId: entry.tenantId,
+        organizationId: entry.organizationId,
+        value: entry.value,
+      })
+      if (usage.total > 0) {
+        throw buildRoleTypeInUseError(
+          usage.total,
+          usage.ownerAssignments,
+          usage.relationshipAssignments,
+        )
+      }
+    }
     em.remove(entry)
     await em.flush()
     return { entryId: entry.id }
@@ -472,7 +609,13 @@ const deleteDictionaryEntryCommand: CommandHandler<CustomerDictionaryEntryDelete
     ensureTenantScope(ctx, before.tenantId)
     ensureOrganizationScope(ctx, before.organizationId)
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    let entry = await em.findOne(CustomerDictionaryEntry, { id: before.id })
+    let entry = await findOneWithDecryption(
+      em,
+      CustomerDictionaryEntry,
+      { id: before.id },
+      {},
+      { tenantId: before.tenantId, organizationId: before.organizationId },
+    )
     if (!entry) {
       entry = em.create(CustomerDictionaryEntry, {
         id: before.id,

package/src/modules/customers/commands/dictionaryKindSettings.ts

@@ -0,0 +1,268 @@
+import { registerCommand } from '@open-mercato/shared/lib/commands'
+import type { CommandHandler } from '@open-mercato/shared/lib/commands'
+import type { CrudEventsConfig } from '@open-mercato/shared/lib/crud/types'
+import { emitCrudSideEffects, emitCrudUndoSideEffects } from '@open-mercato/shared/lib/commands/helpers'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { CustomerDictionaryKindSetting } from '../data/entities'
+import {
+  customerKindSettingsUpsertSchema,
+  type CustomerKindSettingsUpsertInput,
+} from '../data/validators'
+import {
+  ensureOrganizationScope,
+  ensureTenantScope,
+  extractUndoPayload,
+} from './shared'
+
+const KIND_SETTING_ENTITY_TYPE = 'customers:customer_dictionary_kind_setting'
+
+type KindSettingSnapshot = {
+  id: string
+  tenantId: string
+  organizationId: string
+  kind: string
+  selectionMode: string
+  visibleInTags: boolean
+  sortOrder: number
+}
+
+type KindSettingUndoPayload = {
+  before?: KindSettingSnapshot | null
+  after?: KindSettingSnapshot | null
+}
+
+type KindSettingUpsertResult = {
+  settingId: string
+  created: boolean
+  kind: string
+  selectionMode: string
+  visibleInTags: boolean
+  sortOrder: number
+}
+
+const kindSettingCrudEvents: CrudEventsConfig = {
+  module: 'customers',
+  entity: 'dictionary_kind_setting',
+  persistent: true,
+  buildPayload: (ctx) => ({
+    id: ctx.identifiers.id,
+    organizationId: ctx.identifiers.organizationId,
+    tenantId: ctx.identifiers.tenantId,
+    kind:
+      ctx.entity && typeof ctx.entity === 'object' && 'kind' in (ctx.entity as Record<string, unknown>)
+        ? (ctx.entity as CustomerDictionaryKindSetting).kind
+        : null,
+    ...(ctx.syncOrigin ? { syncOrigin: ctx.syncOrigin } : {}),
+  }),
+}
+
+function getKindSettingIdentifiers(setting: CustomerDictionaryKindSetting) {
+  return {
+    id: setting.id,
+    organizationId: setting.organizationId,
+    tenantId: setting.tenantId,
+  }
+}
+
+function toSnapshot(setting: CustomerDictionaryKindSetting): KindSettingSnapshot {
+  return {
+    id: setting.id,
+    tenantId: setting.tenantId,
+    organizationId: setting.organizationId,
+    kind: setting.kind,
+    selectionMode: setting.selectionMode,
+    visibleInTags: setting.visibleInTags,
+    sortOrder: setting.sortOrder,
+  }
+}
+
+async function loadSnapshotByKind(
+  em: EntityManager,
+  params: { tenantId: string; organizationId: string; kind: string },
+): Promise<KindSettingSnapshot | null> {
+  const existing = await findOneWithDecryption(
+    em,
+    CustomerDictionaryKindSetting,
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId,
+      kind: params.kind,
+    },
+    undefined,
+    { tenantId: params.tenantId, organizationId: params.organizationId },
+  )
+  return existing ? toSnapshot(existing) : null
+}
+
+async function loadSnapshotById(
+  em: EntityManager,
+  id: string,
+  scope: { tenantId: string; organizationId: string },
+): Promise<KindSettingSnapshot | null> {
+  const existing = await findOneWithDecryption(
+    em,
+    CustomerDictionaryKindSetting,
+    { id },
+    undefined,
+    { tenantId: scope.tenantId, organizationId: scope.organizationId },
+  )
+  return existing ? toSnapshot(existing) : null
+}
+
+const upsertKindSettingCommand: CommandHandler<CustomerKindSettingsUpsertInput, KindSettingUpsertResult> = {
+  id: 'customers.dictionaryKindSettings.upsert',
+  async prepare(rawInput, ctx) {
+    const parsed = customerKindSettingsUpsertSchema.parse(rawInput)
+    const em = ctx.container.resolve('em') as EntityManager
+    const snapshot = await loadSnapshotByKind(em, {
+      tenantId: parsed.tenantId,
+      organizationId: parsed.organizationId,
+      kind: parsed.kind,
+    })
+    return snapshot ? { before: snapshot } : {}
+  },
+  async execute(rawInput, ctx) {
+    const parsed = customerKindSettingsUpsertSchema.parse(rawInput)
+    ensureTenantScope(ctx, parsed.tenantId)
+    ensureOrganizationScope(ctx, parsed.organizationId)
+
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let setting = await findOneWithDecryption(
+      em,
+      CustomerDictionaryKindSetting,
+      {
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+        kind: parsed.kind,
+      },
+      undefined,
+      { tenantId: parsed.tenantId, organizationId: parsed.organizationId },
+    )
+
+    const created = !setting
+    if (!setting) {
+      setting = em.create(CustomerDictionaryKindSetting, {
+        tenantId: parsed.tenantId,
+        organizationId: parsed.organizationId,
+        kind: parsed.kind,
+        selectionMode: parsed.selectionMode ?? 'single',
+        visibleInTags: parsed.visibleInTags ?? true,
+        sortOrder: parsed.sortOrder ?? 0,
+      })
+      em.persist(setting)
+    } else {
+      if (parsed.selectionMode !== undefined) setting.selectionMode = parsed.selectionMode
+      if (parsed.visibleInTags !== undefined) setting.visibleInTags = parsed.visibleInTags
+      if (parsed.sortOrder !== undefined) setting.sortOrder = parsed.sortOrder
+    }
+
+    await em.flush()
+
+    const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
+    await emitCrudSideEffects({
+      dataEngine,
+      action: created ? 'created' : 'updated',
+      entity: setting,
+      identifiers: getKindSettingIdentifiers(setting),
+      syncOrigin: ctx.syncOrigin,
+      events: kindSettingCrudEvents,
+      indexer: { entityType: KIND_SETTING_ENTITY_TYPE },
+    })
+
+    return {
+      settingId: setting.id,
+      created,
+      kind: setting.kind,
+      selectionMode: setting.selectionMode,
+      visibleInTags: setting.visibleInTags,
+      sortOrder: setting.sortOrder,
+    }
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = ctx.container.resolve('em') as EntityManager
+    const tenantId = ctx.auth?.tenantId ?? null
+    const organizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+    if (!tenantId || !organizationId) return null
+    return loadSnapshotById(em, result.settingId, { tenantId, organizationId })
+  },
+  buildLog: async ({ result, snapshots }) => {
+    const { translate } = await resolveTranslations()
+    const before = snapshots.before as KindSettingSnapshot | undefined
+    const after = snapshots.after as KindSettingSnapshot | undefined
+    const actionKey = result.created
+      ? 'customers.audit.dictionaryKindSettings.create'
+      : 'customers.audit.dictionaryKindSettings.update'
+    const actionFallback = result.created
+      ? 'Create dictionary kind setting'
+      : 'Update dictionary kind setting'
+    return {
+      actionLabel: translate(actionKey, actionFallback),
+      resourceKind: 'customers.dictionaryKindSetting',
+      resourceId: result.settingId,
+      tenantId: after?.tenantId ?? before?.tenantId ?? null,
+      organizationId: after?.organizationId ?? before?.organizationId ?? null,
+      snapshotBefore: before ?? null,
+      snapshotAfter: after ?? null,
+      payload: {
+        undo: {
+          before: before ?? null,
+          after: after ?? null,
+        } satisfies KindSettingUndoPayload,
+      },
+    }
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload<KindSettingUndoPayload>(logEntry)
+    const before = payload?.before ?? null
+    const after = payload?.after ?? null
+    if (!after) return
+
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const setting = await findOneWithDecryption(
+      em,
+      CustomerDictionaryKindSetting,
+      { id: after.id },
+      undefined,
+      { tenantId: after.tenantId, organizationId: after.organizationId },
+    )
+    if (!setting) return
+
+    if (!before) {
+      em.remove(setting)
+      await em.flush()
+
+      const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
+      await emitCrudUndoSideEffects({
+        dataEngine,
+        action: 'deleted',
+        entity: setting,
+        identifiers: getKindSettingIdentifiers(setting),
+        syncOrigin: ctx.syncOrigin,
+        events: kindSettingCrudEvents,
+        indexer: { entityType: KIND_SETTING_ENTITY_TYPE },
+      })
+      return
+    }
+
+    setting.selectionMode = before.selectionMode
+    setting.visibleInTags = before.visibleInTags
+    setting.sortOrder = before.sortOrder
+    await em.flush()
+
+    const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
+    await emitCrudUndoSideEffects({
+      dataEngine,
+      action: 'updated',
+      entity: setting,
+      identifiers: getKindSettingIdentifiers(setting),
+      syncOrigin: ctx.syncOrigin,
+      events: kindSettingCrudEvents,
+      indexer: { entityType: KIND_SETTING_ENTITY_TYPE },
+    })
+  },
+}
+
+registerCommand(upsertKindSettingCommand)