@open-mercato/core 0.6.4-develop.4371.1.8f3030407e → 0.6.4

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

@@ -45,6 +45,7 @@ import {
   type QueryIndexEventEntry,
 } from './shared'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
+import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import {
@@ -524,6 +525,86 @@ async function setCustomFieldsForPerson(
   }
 }
 
+type PersonGraphValues = {
+  entityId?: string
+  profileId?: string
+  organizationId: string
+  tenantId: string
+  displayName: string
+  description: string | null
+  ownerUserId: string | null
+  primaryEmail: string | null
+  primaryPhone: string | null
+  status: string | null
+  lifecycleStage: string | null
+  source: string | null
+  nextInteractionAt: Date | null
+  nextInteractionName: string | null
+  nextInteractionRefId: string | null
+  nextInteractionIcon: string | null
+  nextInteractionColor: string | null
+  isActive: boolean
+  firstName: string | null
+  lastName: string | null
+  preferredName: string | null
+  jobTitle: string | null
+  department: string | null
+  seniority: string | null
+  timezone: string | null
+  linkedInUrl: string | null
+  twitterUrl: string | null
+}
+
+// Single source of truth for the person entity+profile row mapping, shared by
+// `execute` (values from validated input) and `redo` (values from the after-
+// snapshot, carrying the original ids). Keeps create and id-preserving redo from
+// drifting field-by-field. Caller owns the surrounding flush, dictionary upserts,
+// tag/company-link sync, and custom-field restore.
+function buildPersonGraph(
+  em: EntityManager,
+  values: PersonGraphValues,
+): { entity: CustomerEntity; profile: CustomerPersonProfile } {
+  const entity = em.create(CustomerEntity, {
+    ...(values.entityId ? { id: values.entityId } : {}),
+    organizationId: values.organizationId,
+    tenantId: values.tenantId,
+    kind: 'person',
+    displayName: values.displayName,
+    description: values.description,
+    ownerUserId: values.ownerUserId,
+    primaryEmail: values.primaryEmail,
+    primaryPhone: values.primaryPhone,
+    status: values.status,
+    lifecycleStage: values.lifecycleStage,
+    source: values.source,
+    nextInteractionAt: values.nextInteractionAt,
+    nextInteractionName: values.nextInteractionName,
+    nextInteractionRefId: values.nextInteractionRefId,
+    nextInteractionIcon: values.nextInteractionIcon,
+    nextInteractionColor: values.nextInteractionColor,
+    isActive: values.isActive,
+  })
+  const profile = em.create(CustomerPersonProfile, {
+    ...(values.profileId ? { id: values.profileId } : {}),
+    organizationId: values.organizationId,
+    tenantId: values.tenantId,
+    entity,
+    firstName: values.firstName,
+    lastName: values.lastName,
+    preferredName: values.preferredName,
+    jobTitle: values.jobTitle,
+    department: values.department,
+    seniority: values.seniority,
+    timezone: values.timezone,
+    linkedInUrl: values.linkedInUrl,
+    twitterUrl: values.twitterUrl,
+    company: null,
+  })
+  em.persist(entity)
+  em.persist(profile)
+  return { entity, profile }
+}
+
 const createPersonCommand: CommandHandler<PersonCreateInput, { entityId: string; personId: string }> = {
   id: 'customers.people.create',
   async execute(rawInput, ctx) {
@@ -566,10 +647,9 @@ const createPersonCommand: CommandHandler<PersonCreateInput, { entityId: string;
     let profile!: CustomerPersonProfile
     await withAtomicFlush(em, [
       () => {
-        entity = em.create(CustomerEntity, {
+        const graph = buildPersonGraph(em, {
           organizationId: parsed.organizationId,
           tenantId: parsed.tenantId,
-          kind: 'person',
           displayName,
           description,
           ownerUserId: parsed.ownerUserId ?? null,
@@ -584,12 +664,6 @@ const createPersonCommand: CommandHandler<PersonCreateInput, { entityId: string;
           nextInteractionIcon,
           nextInteractionColor,
           isActive: parsed.isActive ?? true,
-        })
-
-        profile = em.create(CustomerPersonProfile, {
-          organizationId: parsed.organizationId,
-          tenantId: parsed.tenantId,
-          entity,
           firstName,
           lastName,
           preferredName,
@@ -599,11 +673,9 @@ const createPersonCommand: CommandHandler<PersonCreateInput, { entityId: string;
           timezone,
           linkedInUrl,
           twitterUrl,
-          company: null,
         })
-
-        em.persist(entity)
-        em.persist(profile)
+        entity = graph.entity
+        profile = graph.profile
       },
       async () => {
         if (status) {
@@ -715,6 +787,128 @@ const createPersonCommand: CommandHandler<PersonCreateInput, { entityId: string;
     })
     await emitQueryIndexDeleteEvents(ctx, [personEntityIndexEntry(entity)])
   },
+  redo: async ({ logEntry, ctx }) => {
+    const after = resolveRedoSnapshot<PersonSnapshot>(logEntry)
+    if (!after) {
+      throw new CrudHttpError(400, { error: '[internal] redo snapshot unavailable for person create' })
+    }
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let entity = await findOneWithDecryption(
+      em,
+      CustomerEntity,
+      { id: after.entity.id },
+      undefined,
+      { tenantId: after.entity.tenantId, organizationId: after.entity.organizationId },
+    )
+    let profile!: CustomerPersonProfile
+    if (!entity) {
+      let newEntity!: CustomerEntity
+      let newProfile!: CustomerPersonProfile
+      await withAtomicFlush(em, [
+        () => {
+          const graph = buildPersonGraph(em, {
+            entityId: after.entity.id,
+            profileId: after.profile.id,
+            organizationId: after.entity.organizationId,
+            tenantId: after.entity.tenantId,
+            displayName: after.entity.displayName,
+            description: after.entity.description,
+            ownerUserId: after.entity.ownerUserId,
+            primaryEmail: after.entity.primaryEmail,
+            primaryPhone: after.entity.primaryPhone,
+            status: after.entity.status,
+            lifecycleStage: after.entity.lifecycleStage,
+            source: after.entity.source,
+            nextInteractionAt: after.entity.nextInteractionAt,
+            nextInteractionName: after.entity.nextInteractionName,
+            nextInteractionRefId: after.entity.nextInteractionRefId,
+            nextInteractionIcon: after.entity.nextInteractionIcon,
+            nextInteractionColor: after.entity.nextInteractionColor,
+            isActive: after.entity.isActive,
+            firstName: after.profile.firstName,
+            lastName: after.profile.lastName,
+            preferredName: after.profile.preferredName,
+            jobTitle: after.profile.jobTitle,
+            department: after.profile.department,
+            seniority: after.profile.seniority,
+            timezone: after.profile.timezone,
+            linkedInUrl: after.profile.linkedInUrl,
+            twitterUrl: after.profile.twitterUrl,
+          })
+          newEntity = graph.entity
+          newProfile = graph.profile
+        },
+        () => syncLegacyPrimaryCompanyLink(em, newEntity, newProfile, after.profile.companyEntityId),
+        () => syncEntityTags(em, newEntity, after.tagIds),
+      ], { transaction: true })
+      entity = newEntity
+      profile = newProfile
+    } else {
+      const existingProfile = await findOneWithDecryption(
+        em,
+        CustomerPersonProfile,
+        { entity },
+        undefined,
+        { tenantId: after.entity.tenantId, organizationId: after.entity.organizationId },
+      )
+      if (!existingProfile) throw new CrudHttpError(404, { error: 'Person profile not found' })
+      profile = existingProfile
+      const survivingEntity = entity
+      await withAtomicFlush(em, [
+        () => {
+          survivingEntity.deletedAt = null
+          survivingEntity.displayName = after.entity.displayName
+          survivingEntity.description = after.entity.description
+          survivingEntity.ownerUserId = after.entity.ownerUserId
+          survivingEntity.primaryEmail = after.entity.primaryEmail
+          survivingEntity.primaryPhone = after.entity.primaryPhone
+          survivingEntity.status = after.entity.status
+          survivingEntity.lifecycleStage = after.entity.lifecycleStage
+          survivingEntity.source = after.entity.source
+          survivingEntity.nextInteractionAt = after.entity.nextInteractionAt
+          survivingEntity.nextInteractionName = after.entity.nextInteractionName
+          survivingEntity.nextInteractionRefId = after.entity.nextInteractionRefId
+          survivingEntity.nextInteractionIcon = after.entity.nextInteractionIcon
+          survivingEntity.nextInteractionColor = after.entity.nextInteractionColor
+          survivingEntity.isActive = after.entity.isActive
+          profile.firstName = after.profile.firstName
+          profile.lastName = after.profile.lastName
+          profile.preferredName = after.profile.preferredName
+          profile.jobTitle = after.profile.jobTitle
+          profile.department = after.profile.department
+          profile.seniority = after.profile.seniority
+          profile.timezone = after.profile.timezone
+          profile.linkedInUrl = after.profile.linkedInUrl
+          profile.twitterUrl = after.profile.twitterUrl
+        },
+        () => syncLegacyPrimaryCompanyLink(em, survivingEntity, profile, after.profile.companyEntityId),
+        () => syncEntityTags(em, survivingEntity, after.tagIds),
+      ], { transaction: true })
+    }
+
+    const restoredEntity = entity
+    const restoreValues = buildCustomFieldResetMap(after.custom, undefined)
+    if (Object.keys(restoreValues).length) {
+      await setCustomFieldsForPerson(ctx, restoredEntity.id, profile.id, restoredEntity.organizationId, restoredEntity.tenantId, restoreValues)
+    }
+
+    const de = (ctx.container.resolve('dataEngine') as DataEngine)
+    await emitCrudSideEffects({
+      dataEngine: de,
+      action: 'created',
+      entity: restoredEntity,
+      identifiers: {
+        id: profile.id ?? restoredEntity.id,
+        tenantId: restoredEntity.tenantId,
+        organizationId: restoredEntity.organizationId,
+      },
+      indexer: personCrudIndexer,
+      events: personCrudEvents,
+    })
+    await emitQueryIndexUpsertEvents(ctx, [personEntityIndexEntry(restoredEntity)])
+
+    return { entityId: restoredEntity.id, personId: profile.id }
+  },
 }
 
 const updatePersonCommand: CommandHandler<PersonUpdateInput, { entityId: string }> = {
@@ -866,7 +1060,8 @@ const updatePersonCommand: CommandHandler<PersonUpdateInput, { entityId: string
     })
     await emitQueryIndexUpsertEvents(ctx, [personEntityIndexEntry(record)])
 
-    return { entityId: record.id }
+    // Expose the freshly-bumped updatedAt for inline-edit sequential-save lock refresh (#2055).
+    return { entityId: record.id, updatedAt: record.updatedAt }
   },
   captureAfter: async (_input, result, ctx) => {
     const em = (ctx.container.resolve('em') as EntityManager).fork()

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

@@ -31,6 +31,7 @@ import {
   extractUndoPayload,
 } from './shared'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
+import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
 
 type PersonCompanyLinkSnapshot = {
   id: string
@@ -294,33 +295,38 @@ const createPersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkCreateInpu
     )
     if (!link) return
 
+    let person: CustomerEntity | null = null
+    let profile: CustomerPersonProfile | null = null
+    let remainingLinks: CustomerPersonCompanyLink[] = []
+
     await withAtomicFlush(em, [
       async () => {
-        link.isPrimary = false
-        link.deletedAt = new Date()
-        const person = await findOneWithDecryption(
+        person = await findOneWithDecryption(
           em,
           CustomerEntity,
           { id: after.personEntityId, kind: 'person', tenantId: after.tenantId, organizationId: after.organizationId, deletedAt: null },
           undefined,
           { tenantId: after.tenantId, organizationId: after.organizationId },
         )
-        if (person) {
-          const profile = await findOneWithDecryption(
-            em,
-            CustomerPersonProfile,
-            { entity: person },
-            { populate: ['company'] },
-            { tenantId: person.tenantId, organizationId: person.organizationId },
-          )
-          if (profile) {
-            const remainingLinks = await loadPersonCompanyLinks(em, person)
-            if (after.isPrimary) {
-              await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, after.companyEntityId)
-            } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === after.companyEntityId) {
-              profile.company = null
-            }
-          }
+        if (!person) return
+        profile = await findOneWithDecryption(
+          em,
+          CustomerPersonProfile,
+          { entity: person },
+          { populate: ['company'] },
+          { tenantId: person.tenantId, organizationId: person.organizationId },
+        )
+        if (!profile) return
+        remainingLinks = (await loadPersonCompanyLinks(em, person)).filter((entry) => entry.id !== link.id)
+      },
+      async () => {
+        link.isPrimary = false
+        link.deletedAt = new Date()
+        if (!person || !profile) return
+        if (after.isPrimary) {
+          await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, after.companyEntityId)
+        } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === after.companyEntityId) {
+          profile.company = null
         }
       },
     ], { transaction: true })
@@ -336,6 +342,65 @@ const createPersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkCreateInpu
       indexer: { entityType: 'customers:customer_person_company_link' },
     })
   },
+  redo: async ({ logEntry, ctx }) => {
+    const after = resolveRedoSnapshot<PersonCompanyLinkSnapshot>(logEntry)
+    if (!after) {
+      throw new CrudHttpError(400, { error: '[internal] redo snapshot unavailable for person-company link create' })
+    }
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const person = await requirePersonEntity(em, after.personEntityId, after.tenantId, after.organizationId)
+    const company = await requireCompanyEntity(em, after.companyEntityId, after.tenantId, after.organizationId)
+    const profile = await requirePersonProfile(em, person)
+
+    let link = await findOneWithDecryption(
+      em,
+      CustomerPersonCompanyLink,
+      { id: after.id },
+      undefined,
+      { tenantId: after.tenantId, organizationId: after.organizationId },
+    )
+
+    await withAtomicFlush(em, [
+      async () => {
+        if (after.isPrimary) {
+          await clearPrimaryFlagsForPerson(em, person)
+        }
+        if (!link) {
+          link = em.create(CustomerPersonCompanyLink, {
+            id: after.id,
+            organizationId: after.organizationId,
+            tenantId: after.tenantId,
+            person,
+            company,
+            isPrimary: after.isPrimary,
+          })
+          em.persist(link)
+        } else {
+          link.deletedAt = null
+          link.isPrimary = after.isPrimary
+          em.persist(link)
+        }
+      },
+      () => {
+        if (after.isPrimary) {
+          profile.company = company
+        }
+      },
+    ], { transaction: true })
+
+    const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
+    await emitCrudSideEffects({
+      dataEngine,
+      action: 'created',
+      entity: link!,
+      identifiers: getLinkIdentifiers(link!),
+      syncOrigin: ctx.syncOrigin,
+      events: personCompanyLinkCrudEvents,
+      indexer: { entityType: 'customers:customer_person_company_link' },
+    })
+
+    return { linkId: link!.id, created: true, undeleted: false }
+  },
 }
 
 const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInput, { linkId: string }> = {
@@ -377,6 +442,7 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
     const profile = await requirePersonProfile(em, person)
     const linkedCompany = await requireCompanyEntity(em, companyId, parsed.tenantId, parsed.organizationId)
 
+    const linkWasPrimary = link.isPrimary
     await withAtomicFlush(em, [
       async () => {
         if (parsed.isPrimary) {
@@ -384,16 +450,18 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
           link.isPrimary = true
           profile.company = linkedCompany
         } else if (!parsed.isPrimary) {
-          const linkWasPrimary = link.isPrimary
           link.isPrimary = false
-          if (linkWasPrimary) {
-            const remainingLinks = (await loadPersonCompanyLinks(em, person)).filter((entry) => entry.id !== link.id)
-            await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, companyId)
-          } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === companyId) {
+          if (!linkWasPrimary && profile.company && typeof profile.company !== 'string' && profile.company.id === companyId) {
             profile.company = null
           }
         }
       },
+      async () => {
+        if (!parsed.isPrimary && linkWasPrimary) {
+          const remainingLinks = (await loadPersonCompanyLinks(em, person)).filter((entry) => entry.id !== link.id)
+          await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, companyId)
+        }
+      },
     ], { transaction: true })
 
     const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
@@ -453,39 +521,44 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
     )
     if (!link) return
 
+    let person: CustomerEntity | null = null
+    let profile: CustomerPersonProfile | null = null
+    let company: CustomerEntity | null = null
+
     await withAtomicFlush(em, [
       async () => {
-        const person = await findOneWithDecryption(
+        person = await findOneWithDecryption(
           em,
           CustomerEntity,
           { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
           undefined,
           { tenantId: before.tenantId, organizationId: before.organizationId },
         )
-        if (person) {
-          const profile = await findOneWithDecryption(
-            em,
-            CustomerPersonProfile,
-            { entity: person },
-            { populate: ['company'] },
-            { tenantId: person.tenantId, organizationId: person.organizationId },
-          )
-          if (profile) {
-            if (before.isPrimary) {
-              await clearPrimaryFlagsForPerson(em, person)
-              link.isPrimary = true
-              const company = await findOneWithDecryption(
-                em,
-                CustomerEntity,
-                { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
-                undefined,
-                { tenantId: before.tenantId, organizationId: before.organizationId },
-              )
-              if (company) profile.company = company
-            } else {
-              link.isPrimary = false
-            }
-          }
+        if (!person) return
+        profile = await findOneWithDecryption(
+          em,
+          CustomerPersonProfile,
+          { entity: person },
+          { populate: ['company'] },
+          { tenantId: person.tenantId, organizationId: person.organizationId },
+        )
+        if (!profile || !before.isPrimary) return
+        company = await findOneWithDecryption(
+          em,
+          CustomerEntity,
+          { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+          undefined,
+          { tenantId: before.tenantId, organizationId: before.organizationId },
+        )
+      },
+      async () => {
+        if (!person || !profile) return
+        if (before.isPrimary) {
+          await clearPrimaryFlagsForPerson(em, person)
+          link.isPrimary = true
+          if (company) profile.company = company
+        } else {
+          link.isPrimary = false
         }
       },
     ], { transaction: true })
@@ -610,38 +683,43 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
     )
     if (!link) return
 
+    let person: CustomerEntity | null = null
+    let profile: CustomerPersonProfile | null = null
+    let company: CustomerEntity | null = null
+
     await withAtomicFlush(em, [
       async () => {
-        link.deletedAt = null
-        link.isPrimary = before.isPrimary
-
-        const person = await findOneWithDecryption(
+        person = await findOneWithDecryption(
           em,
           CustomerEntity,
           { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
           undefined,
           { tenantId: before.tenantId, organizationId: before.organizationId },
         )
+        if (!person || !before.isPrimary) return
+        profile = await findOneWithDecryption(
+          em,
+          CustomerPersonProfile,
+          { entity: person },
+          { populate: ['company'] },
+          { tenantId: person.tenantId, organizationId: person.organizationId },
+        )
+        if (!profile) return
+        company = await findOneWithDecryption(
+          em,
+          CustomerEntity,
+          { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+          undefined,
+          { tenantId: before.tenantId, organizationId: before.organizationId },
+        )
+      },
+      async () => {
+        link.deletedAt = null
+        link.isPrimary = before.isPrimary
         if (person && before.isPrimary) {
           await clearPrimaryFlagsForPerson(em, person)
           link.isPrimary = true
-          const profile = await findOneWithDecryption(
-            em,
-            CustomerPersonProfile,
-            { entity: person },
-            { populate: ['company'] },
-            { tenantId: person.tenantId, organizationId: person.organizationId },
-          )
-          if (profile) {
-            const company = await findOneWithDecryption(
-              em,
-              CustomerEntity,
-              { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
-              undefined,
-              { tenantId: before.tenantId, organizationId: before.organizationId },
-            )
-            if (company) profile.company = company
-          }
+          if (profile && company) profile.company = company
         }
       },
     ], { transaction: true })

package/src/modules/customers/commands/pipeline-stages.ts

@@ -49,18 +49,6 @@ const createPipelineStageCommand: CommandHandler<PipelineStageCreateInput, { sta
         ? existingStages.length
         : Math.max(0, Math.min(requestedOrder, existingStages.length))
 
-    // Shift the order of every stage at or after the insert position. Skipping
-    // this step would either duplicate `order` values (silently corrupting kanban
-    // ordering) or push the new stage to the wrong spot when re-sorting.
-    if (requestedOrder !== undefined) {
-      for (const stage of existingStages) {
-        if (stage.order >= insertOrder) {
-          stage.order += 1
-          stage.updatedAt = new Date()
-        }
-      }
-    }
-
     const stage = em.create(CustomerPipelineStage, {
       organizationId: parsed.organizationId,
       tenantId: parsed.tenantId,
@@ -73,6 +61,17 @@ const createPipelineStageCommand: CommandHandler<PipelineStageCreateInput, { sta
 
     await withAtomicFlush(em, [
       () => {
+        // Shift the order of every stage at or after the insert position. Skipping
+        // this step would either duplicate `order` values (silently corrupting kanban
+        // ordering) or push the new stage to the wrong spot when re-sorting.
+        if (requestedOrder !== undefined) {
+          for (const existing of existingStages) {
+            if (existing.order >= insertOrder) {
+              existing.order += 1
+              existing.updatedAt = new Date()
+            }
+          }
+        }
         em.persist(stage)
       },
       async () => {
@@ -112,11 +111,12 @@ const updatePipelineStageCommand: CommandHandler<PipelineStageUpdateInput, void>
     ensureTenantScope(ctx, stage.tenantId)
     ensureOrganizationScope(ctx, stage.organizationId)
 
-    if (parsed.label !== undefined) stage.label = parsed.label
-    if (parsed.order !== undefined) stage.order = parsed.order
-    stage.updatedAt = new Date()
-
     await withAtomicFlush(em, [
+      () => {
+        if (parsed.label !== undefined) stage.label = parsed.label
+        if (parsed.order !== undefined) stage.order = parsed.order
+        stage.updatedAt = new Date()
+      },
       async () => {
         if (parsed.label !== undefined || parsed.color !== undefined || parsed.icon !== undefined) {
           await ensureDictionaryEntry(em, {

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

@@ -4,8 +4,10 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { CustomerSettings, type CustomerAddressFormat } from '../data/entities'
 import {
+  customerDictionarySortModesUpsertSchema,
   customerSettingsUpsertSchema,
   customerStuckThresholdUpsertSchema,
+  type CustomerDictionarySortModesUpsertInput,
   type CustomerSettingsUpsertInput,
   type CustomerStuckThresholdUpsertInput,
 } from '../data/validators'
@@ -112,3 +114,42 @@ const saveStuckThresholdCommand: CommandHandler<
 }
 
 registerCommand(saveStuckThresholdCommand)
+
+const saveDictionarySortModesCommand: CommandHandler<
+  CustomerDictionarySortModesUpsertInput,
+  { settingsId: string; dictionarySortModes: CustomerDictionarySortModesUpsertInput['dictionarySortModes'] }
+> = {
+  id: 'customers.settings.save_dictionary_sort_modes',
+  async execute(rawInput, ctx) {
+    const input = customerDictionarySortModesUpsertSchema.parse(rawInput)
+    ensureTenantScope(ctx, input.tenantId)
+    ensureOrganizationScope(ctx, input.organizationId)
+
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let settings = await loadCustomerSettings(em, {
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+    })
+
+    if (!settings) {
+      settings = em.create(CustomerSettings, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+        dictionarySortModes: input.dictionarySortModes,
+      })
+      em.persist(settings)
+    } else {
+      settings.dictionarySortModes = input.dictionarySortModes
+      settings.updatedAt = new Date()
+    }
+
+    await em.flush()
+
+    return {
+      settingsId: settings.id,
+      dictionarySortModes: settings.dictionarySortModes ?? {},
+    }
+  },
+}
+
+registerCommand(saveDictionarySortModesCommand)