@open-mercato/core 0.9.1-develop.7532.1.8eac7e198f → 0.9.1-develop.7536.1.f9a5776a07

package/src/modules/currencies/commands/currencies.ts

@@ -2,7 +2,7 @@ import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { CommandHandler } from '@open-mercato/shared/lib/commands'
 import { buildChanges, requireId, emitCrudSideEffects } from '@open-mercato/shared/lib/commands/helpers'
 import { extractUndoPayload, type UndoPayload } from '@open-mercato/shared/lib/commands/undo'
-import { makeCreateRedo } from '@open-mercato/shared/lib/commands/redo'
+import { resolveRedoSnapshot, restoreCreatedRow, reviveSnapshotSeed } from '@open-mercato/shared/lib/commands/redo'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { CrudHttpError, conflict, isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
@@ -47,8 +47,6 @@ type CurrencySnapshot = {
   updatedAt: string
 }
 
-type CurrencyUndoPayload = UndoPayload<CurrencySnapshot>
-
 async function loadCurrencySnapshot(
   em: EntityManager,
   id: string,
@@ -77,71 +75,218 @@ async function loadCurrencySnapshot(
   }
 }
 
-async function enforceBaseCurrency(
-  em: EntityManager,
-  currencyId: string,
-  organizationId: string,
+type CurrencyScope = {
   tenantId: string
-): Promise<void> {
-  await em.nativeUpdate(
+  organizationId: string
+}
+
+type BaseCurrencyTransition = {
+  promoted: boolean
+  demotedBaseCurrencyIds: string[]
+}
+
+type CurrencyCommandResult = {
+  currencyId: string
+  base?: BaseCurrencyTransition
+}
+
+type CurrencyUndoPayload = UndoPayload<CurrencySnapshot> & {
+  base?: BaseCurrencyTransition
+}
+
+const NO_BASE_TRANSITION: BaseCurrencyTransition = { promoted: false, demotedBaseCurrencyIds: [] }
+
+const BASE_CURRENCY_LOCK_SQL = 'select pg_advisory_xact_lock(hashtextextended(?, 0))'
+
+const UPDATABLE_CURRENCY_FIELDS = [
+  'code',
+  'name',
+  'symbol',
+  'decimalPlaces',
+  'thousandsSeparator',
+  'decimalSeparator',
+  'isBase',
+  'isActive',
+] as const
+
+function baseCurrencyLockKey(scope: CurrencyScope): string {
+  return `currencies:base:${scope.tenantId}:${scope.organizationId}`
+}
+
+/**
+ * Serialize every currency write inside one tenant and organization so the
+ * "exactly one live base currency" invariant is decided on fresh rows. The
+ * transaction owns the lock, so PostgreSQL releases it on commit/rollback.
+ */
+async function lockBaseCurrencyScope(em: EntityManager, scope: CurrencyScope): Promise<void> {
+  if (!em.isInTransaction()) {
+    throw new Error('[internal] Currency base lock requires an active transaction')
+  }
+  await em.execute(BASE_CURRENCY_LOCK_SQL, [baseCurrencyLockKey(scope)])
+}
+
+async function findLiveBaseCurrencyIds(
+  em: EntityManager,
+  scope: CurrencyScope,
+  excludeId?: string,
+): Promise<string[]> {
+  const rows = await em.find(
     Currency,
     {
-      organizationId,
-      tenantId,
-      id: { $ne: currencyId },
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
       isBase: true,
       deletedAt: null,
+      ...(excludeId ? { id: { $ne: excludeId } } : {}),
     },
-    { isBase: false, updatedAt: new Date() }
+    { orderBy: { createdAt: 'asc', id: 'asc' } },
   )
+  return rows.map((row) => row.id)
+}
+
+async function setBaseFlag(
+  em: EntityManager,
+  scope: CurrencyScope,
+  ids: string[],
+  isBase: boolean,
+): Promise<void> {
+  if (ids.length === 0) return
+  await em.nativeUpdate(
+    Currency,
+    {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      id: { $in: ids },
+    },
+    { isBase, updatedAt: new Date() },
+  )
+}
+
+async function findFirstLivePredecessorId(
+  em: EntityManager,
+  scope: CurrencyScope,
+  candidateIds: string[],
+): Promise<string | null> {
+  if (candidateIds.length === 0) return null
+  const rows = await em.find(Currency, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    id: { $in: candidateIds },
+    deletedAt: null,
+  })
+  const liveIds = new Set(rows.map((row) => row.id))
+  return candidateIds.find((id) => liveIds.has(id)) ?? null
+}
+
+async function translatedHttpError(status: number, key: string, fallback: string): Promise<CrudHttpError> {
+  const { translate } = await resolveTranslations()
+  return new CrudHttpError(status, { error: translate(key, fallback) })
+}
+
+async function resolvePredecessorOrRefuse(
+  em: EntityManager,
+  scope: CurrencyScope,
+  candidateIds: string[],
+): Promise<string> {
+  const predecessorId = await findFirstLivePredecessorId(em, scope, candidateIds)
+  if (!predecessorId) {
+    throw await translatedHttpError(
+      409,
+      'currencies.errors.undoWouldClearBase',
+      "This change can't be undone because it would leave the organization without a base currency.",
+    )
+  }
+  return predecessorId
+}
+
+function countActiveRatesForCode(em: EntityManager, scope: CurrencyScope, code: string): Promise<number> {
+  return em.count(ExchangeRate, {
+    $or: [
+      { fromCurrencyCode: code },
+      { toCurrencyCode: code },
+    ],
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+    deletedAt: null,
+    isActive: true,
+  })
+}
+
+function readScopedSnapshotRecord(em: EntityManager, snapshot: CurrencySnapshot): Promise<Currency | null> {
+  return em.findOne(Currency, {
+    id: snapshot.id,
+    tenantId: snapshot.tenantId,
+    organizationId: snapshot.organizationId,
+  })
 }
 
-const createCurrencyCommand: CommandHandler<CurrencyCreateInput, { currencyId: string }> = {
+function scopeOf(record: CurrencyScope): CurrencyScope {
+  return { tenantId: record.tenantId, organizationId: record.organizationId }
+}
+
+function omitIsBase(input: CurrencyUpdateInput): Partial<CurrencyUpdateInput> {
+  const rest: Partial<CurrencyUpdateInput> = { ...input }
+  delete rest.isBase
+  return rest
+}
+
+function isPromotionByLegacyLog(payload: CurrencyUndoPayload | null): boolean {
+  return payload?.before?.isBase === false && payload?.after?.isBase === true
+}
+
+function isDemotionByLegacyLog(payload: CurrencyUndoPayload | null): boolean {
+  return !payload?.base && payload?.before?.isBase === true && payload?.after?.isBase === false
+}
+
+const createCurrencyCommand: CommandHandler<CurrencyCreateInput, CurrencyCommandResult> = {
   id: 'currencies.currencies.create',
   async execute(input, ctx) {
     const parsed = currencyCreateSchema.parse(input)
     ensureCurrencyCommandScope(ctx, parsed)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const scope = scopeOf(parsed)
+    let demotedBaseCurrencyIds: string[] = []
+    let record!: Currency
 
-    // Check for duplicate code
-    const existing = await em.findOne(Currency, {
-      code: parsed.code,
-      organizationId: parsed.organizationId,
-      tenantId: parsed.tenantId,
-      deletedAt: null,
-    })
-    if (existing) {
-      throw conflict('Currency code already exists for this organization.')
-    }
-
-    const now = new Date()
-    const record = em.create(Currency, {
-      organizationId: parsed.organizationId,
-      tenantId: parsed.tenantId,
-      code: parsed.code,
-      name: parsed.name,
-      symbol: parsed.symbol ?? null,
-      decimalPlaces: parsed.decimalPlaces ?? 2,
-      thousandsSeparator: parsed.thousandsSeparator ?? null,
-      decimalSeparator: parsed.decimalSeparator ?? null,
-      isBase: parsed.isBase ?? false,
-      isActive: parsed.isActive !== false,
-      createdAt: now,
-      updatedAt: now,
-    })
-    em.persist(record)
-
-    // Demote any existing base currency and insert the new record in one
-    // transaction; a partial commit would leave zero or two base currencies.
     try {
       await withAtomicFlush(
         em,
         [
-          () =>
-            record.isBase
-              ? enforceBaseCurrency(em, record.id, record.organizationId, record.tenantId)
-              : undefined,
+          async () => {
+            await lockBaseCurrencyScope(em, scope)
+            const existing = await em.findOne(Currency, {
+              code: parsed.code,
+              organizationId: parsed.organizationId,
+              tenantId: parsed.tenantId,
+              deletedAt: null,
+            })
+            if (existing) {
+              throw conflict('Currency code already exists for this organization.')
+            }
+            if (parsed.isBase) {
+              demotedBaseCurrencyIds = await findLiveBaseCurrencyIds(em, scope)
+              await setBaseFlag(em, scope, demotedBaseCurrencyIds, false)
+            }
+          },
+          () => {
+            const now = new Date()
+            record = em.create(Currency, {
+              organizationId: parsed.organizationId,
+              tenantId: parsed.tenantId,
+              code: parsed.code,
+              name: parsed.name,
+              symbol: parsed.symbol ?? null,
+              decimalPlaces: parsed.decimalPlaces ?? 2,
+              thousandsSeparator: parsed.thousandsSeparator ?? null,
+              decimalSeparator: parsed.decimalSeparator ?? null,
+              isBase: parsed.isBase ?? false,
+              isActive: parsed.isActive !== false,
+              createdAt: now,
+              updatedAt: now,
+            })
+            em.persist(record)
+          },
         ],
         { transaction: true },
       )
@@ -165,13 +310,15 @@ const createCurrencyCommand: CommandHandler<CurrencyCreateInput, { currencyId: s
       events: currencyCrudEvents,
     })
 
-    return { currencyId: record.id }
+    return record.isBase
+      ? { currencyId: record.id, base: { promoted: true, demotedBaseCurrencyIds } }
+      : { currencyId: record.id }
   },
   captureAfter: async (_input, result, ctx) => {
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     return loadCurrencySnapshot(em, result.currencyId, ctx)
   },
-  buildLog: async ({ snapshots }) => {
+  buildLog: async ({ snapshots, result }) => {
     const after = snapshots.after as CurrencySnapshot | undefined
     if (!after) return null
     const { translate } = await resolveTranslations()
@@ -182,34 +329,113 @@ const createCurrencyCommand: CommandHandler<CurrencyCreateInput, { currencyId: s
       tenantId: after.tenantId,
       organizationId: after.organizationId,
       snapshotAfter: after,
-      payload: { undo: { after } },
+      payload: { undo: { after, base: result?.base ?? NO_BASE_TRANSITION } },
     }
   },
   undo: async ({ logEntry, ctx }) => {
     const payload = extractUndoPayload<CurrencyUndoPayload>(logEntry)
     const after = payload?.after ?? null
     if (!after) return
+    const scope = scopeOf(after)
+    const promoted = payload?.base ? payload.base.promoted : after.isBase
+    const predecessorIds = payload?.base?.demotedBaseCurrencyIds ?? []
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const record = await em.findOne(Currency, { id: after.id })
-    if (!record) return
-    record.deletedAt = new Date()
-    record.isActive = false
-    await em.flush()
+    let record: Currency | null = null
+    let restoredBaseId: string | null = null
+
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          await lockBaseCurrencyScope(em, scope)
+          const current = await readScopedSnapshotRecord(em, after)
+          if (!current || current.deletedAt) return
+          const activeRatesCount = await countActiveRatesForCode(em, scope, current.code)
+          if (activeRatesCount > 0) {
+            throw await translatedHttpError(
+              409,
+              'currencies.errors.undoHasRates',
+              "This change can't be undone because exchange rates now use this currency. Delete or deactivate those exchange rates first.",
+            )
+          }
+          if (current.isBase) {
+            restoredBaseId = await resolvePredecessorOrRefuse(em, scope, promoted ? predecessorIds : [])
+          }
+          record = current
+        },
+        () => {
+          if (!record) return
+          record.deletedAt = new Date()
+          record.isActive = false
+          record.isBase = false
+        },
+        () => (restoredBaseId ? setBaseFlag(em, scope, [restoredBaseId], true) : undefined),
+      ],
+      { transaction: true },
+    )
   },
-  redo: makeCreateRedo<Currency, CurrencySnapshot, CurrencyCreateInput, { currencyId: string }>({
-    entityClass: Currency,
-    buildResult: (entity) => ({ currencyId: entity.id }),
-    events: currencyCrudEvents,
-    afterRestore: async ({ em, entity }) => {
-      if (entity.isBase) {
-        await enforceBaseCurrency(em, entity.id, entity.organizationId, entity.tenantId)
-        await em.flush()
+  redo: async ({ ctx, logEntry }) => {
+    const snapshot = resolveRedoSnapshot<CurrencySnapshot>(logEntry)
+    if (!snapshot || !snapshot.id) {
+      throw new CrudHttpError(400, { error: '[internal] redo snapshot unavailable for create command' })
+    }
+    const scope = scopeOf(snapshot)
+    const isBase = snapshot.isBase === true
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let demotedBaseCurrencyIds: string[] = []
+    let record!: Currency
+
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          async () => {
+            await lockBaseCurrencyScope(em, scope)
+            if (isBase) {
+              demotedBaseCurrencyIds = await findLiveBaseCurrencyIds(em, scope, snapshot.id)
+              await setBaseFlag(em, scope, demotedBaseCurrencyIds, false)
+            }
+          },
+          async () => {
+            record = await restoreCreatedRow(
+              em,
+              Currency,
+              snapshot.id,
+              () => reviveSnapshotSeed(snapshot as unknown as Record<string, unknown>),
+              (lookupEm) => readScopedSnapshotRecord(lookupEm, snapshot),
+            )
+            record.isBase = isBase
+          },
+        ],
+        { transaction: true },
+      )
+    } catch (err) {
+      if (isUniqueViolation(err)) {
+        throw conflict('[internal] Cannot redo: a record with the same unique key already exists.')
       }
-    },
-  }),
+      throw err
+    }
+
+    const de = ctx.container.resolve('dataEngine') as DataEngine
+    await emitCrudSideEffects({
+      dataEngine: de,
+      action: 'created',
+      entity: record,
+      identifiers: {
+        id: record.id,
+        organizationId: record.organizationId,
+        tenantId: record.tenantId,
+      },
+      events: currencyCrudEvents,
+    })
+
+    return isBase
+      ? { currencyId: record.id, base: { promoted: true, demotedBaseCurrencyIds } }
+      : { currencyId: record.id }
+  },
 }
 
-const updateCurrencyCommand: CommandHandler<CurrencyUpdateInput, { currencyId: string }> = {
+const updateCurrencyCommand: CommandHandler<CurrencyUpdateInput, CurrencyCommandResult> = {
   id: 'currencies.currencies.update',
   async prepare(input, ctx) {
     requireId(input.id, 'Currency ID is required')
@@ -221,71 +447,91 @@ const updateCurrencyCommand: CommandHandler<CurrencyUpdateInput, { currencyId: s
     const parsed = currencyUpdateSchema.parse(input)
     requireId(parsed.id, 'Currency ID is required')
 
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const record = await em.findOne(
+    const scopeRecord = await (ctx.container.resolve('em') as EntityManager).fork().findOne(
       Currency,
       buildCurrencyCommandWhere<Currency>(ctx, { id: parsed.id }),
     )
-    if (!record) {
+    if (!scopeRecord) {
       throw new CrudHttpError(404, { error: 'Currency not found' })
     }
-    ensureCurrencyCommandScope(ctx, record)
-
-    // Check code uniqueness if changing code
-    if (parsed.code && parsed.code !== record.code) {
-      const existing = await em.findOne(Currency, {
-        code: parsed.code,
-        organizationId: record.organizationId,
-        tenantId: record.tenantId,
-        id: { $ne: record.id },
-        deletedAt: null,
-      })
-      if (existing) {
-        throw conflict('Currency code already exists for this organization.')
-      }
-    }
-
-    const allChanges = buildChanges(record as unknown as Record<string, unknown>, parsed, [
-      'code',
-      'name',
-      'symbol',
-      'decimalPlaces',
-      'thousandsSeparator',
-      'decimalSeparator',
-      'isBase',
-      'isActive',
-    ])
-    const changes = Object.fromEntries(
-      Object.entries(allChanges).filter(([, c]) => c.to !== undefined),
-    ) as Record<string, { from: unknown; to: unknown }>
+    ensureCurrencyCommandScope(ctx, scopeRecord)
+    const scope = scopeOf(scopeRecord)
 
-    if (Object.keys(changes).length === 0) {
-      return { currencyId: record.id }
-    }
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let record!: Currency
+    let changes: Record<string, { from: unknown; to: unknown }> = {}
+    let promoted = false
+    let demotedBaseCurrencyIds: string[] = []
 
-    // Demote any existing base currency and persist the scalar changes in one
-    // transaction; a partial commit would leave zero or two base currencies.
-    // The scalar mutations live in the first phase so the per-phase flush issues
-    // the pending changeset on the managed `record` before `enforceBaseCurrency`
-    // runs its interleaved `nativeUpdate` (which would otherwise drop the pending
-    // UPDATE under v7).
     await withAtomicFlush(
       em,
       [
-        () => {
-          for (const [key, change] of Object.entries(changes)) {
-            ;(record as any)[key] = change.to
+        async () => {
+          await lockBaseCurrencyScope(em, scope)
+          const current = await em.findOne(
+            Currency,
+            buildCurrencyCommandWhere<Currency>(ctx, { id: parsed.id }),
+          )
+          if (!current) {
+            throw new CrudHttpError(404, { error: 'Currency not found' })
           }
-          record.updatedAt = new Date()
+          ensureCurrencyCommandScope(ctx, current)
+          record = current
+
+          if (parsed.code && parsed.code !== record.code) {
+            const existing = await em.findOne(Currency, {
+              code: parsed.code,
+              organizationId: record.organizationId,
+              tenantId: record.tenantId,
+              id: { $ne: record.id },
+              deletedAt: null,
+            })
+            if (existing) {
+              throw conflict('Currency code already exists for this organization.')
+            }
+          }
+
+          if (parsed.isBase === false && record.isBase) {
+            throw await translatedHttpError(
+              400,
+              'currencies.errors.baseCurrencyUnset',
+              'Choose another currency as the base instead of clearing it.',
+            )
+          }
+
+          const allChanges = buildChanges(
+            record as unknown as Record<string, unknown>,
+            parsed,
+            UPDATABLE_CURRENCY_FIELDS,
+          )
+          changes = Object.fromEntries(
+            Object.entries(allChanges).filter(([, change]) => change.to !== undefined),
+          ) as Record<string, { from: unknown; to: unknown }>
+
+          promoted = changes.isBase?.to === true
+          if (promoted) {
+            demotedBaseCurrencyIds = await findLiveBaseCurrencyIds(em, scope, record.id)
+          }
+        },
+        () => {
+          if (Object.keys(changes).length === 0) return
+          const assignments = Object.fromEntries(
+            Object.entries(changes).map(([key, change]) => [key, change.to]),
+          )
+          Object.assign(record, assignments, { updatedAt: new Date() })
         },
-        () =>
-          parsed.isBase === true && record.isBase
-            ? enforceBaseCurrency(em, record.id, record.organizationId, record.tenantId)
-            : undefined,
+        () => setBaseFlag(em, scope, demotedBaseCurrencyIds, false),
       ],
       { transaction: true },
     )
 
+    const result: CurrencyCommandResult = promoted
+      ? { currencyId: record.id, base: { promoted: true, demotedBaseCurrencyIds } }
+      : { currencyId: record.id }
+    if (Object.keys(changes).length === 0) {
+      return result
+    }
+
     const de = ctx.container.resolve('dataEngine') as DataEngine
     await emitCrudSideEffects({
       dataEngine: de,
@@ -299,17 +545,18 @@ const updateCurrencyCommand: CommandHandler<CurrencyUpdateInput, { currencyId: s
       events: currencyCrudEvents,
     })
 
-    return { currencyId: record.id }
+    return result
   },
   captureAfter: async (_input, result, ctx) => {
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     return loadCurrencySnapshot(em, result.currencyId, ctx)
   },
-  buildLog: async ({ snapshots, result }) => {
+  buildLog: async ({ input, snapshots, result }) => {
     const before = snapshots.before as CurrencySnapshot | undefined
     const after = snapshots.after as CurrencySnapshot | undefined
     if (!after) return null
     const { translate } = await resolveTranslations()
+    const base = result?.base ?? NO_BASE_TRANSITION
     return {
       actionLabel: translate('currencies.audit.update', 'Update currency'),
       resourceKind: 'currencies.currency',
@@ -318,28 +565,57 @@ const updateCurrencyCommand: CommandHandler<CurrencyUpdateInput, { currencyId: s
       organizationId: after.organizationId,
       snapshotBefore: before ?? undefined,
       snapshotAfter: after,
-      payload: { undo: { before, after } },
+      payload: { undo: { before, after, base } },
+      redoInput: base.promoted ? input : omitIsBase(input),
     }
   },
   undo: async ({ logEntry, ctx }) => {
     const payload = extractUndoPayload<CurrencyUndoPayload>(logEntry)
     const before = payload?.before ?? null
     if (!before) return
+    const scope = scopeOf(before)
+    const promoted = payload?.base ? payload.base.promoted : isPromotionByLegacyLog(payload)
+    const predecessorIds = payload?.base?.demotedBaseCurrencyIds ?? []
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const record = await em.findOne(Currency, { id: before.id })
-    if (!record) return
-    Object.assign(record, {
-      code: before.code,
-      name: before.name,
-      symbol: before.symbol,
-      decimalPlaces: before.decimalPlaces,
-      thousandsSeparator: before.thousandsSeparator,
-      decimalSeparator: before.decimalSeparator,
-      isBase: before.isBase,
-      isActive: before.isActive,
-      updatedAt: new Date(),
-    })
-    await em.flush()
+    const demotedByLegacyLog = isDemotionByLegacyLog(payload)
+    let record: Currency | null = null
+    let restoredBaseId: string | null = null
+    let repromote = false
+
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          await lockBaseCurrencyScope(em, scope)
+          const current = await readScopedSnapshotRecord(em, before)
+          if (!current) return
+          if (promoted && current.isBase && !current.deletedAt) {
+            restoredBaseId = await resolvePredecessorOrRefuse(em, scope, predecessorIds)
+          }
+          if (demotedByLegacyLog && !current.isBase && !current.deletedAt) {
+            repromote = (await findLiveBaseCurrencyIds(em, scope)).length === 0
+          }
+          record = current
+        },
+        () => {
+          if (!record) return
+          Object.assign(record, {
+            code: before.code,
+            name: before.name,
+            symbol: before.symbol,
+            decimalPlaces: before.decimalPlaces,
+            thousandsSeparator: before.thousandsSeparator,
+            decimalSeparator: before.decimalSeparator,
+            isActive: before.isActive,
+            updatedAt: new Date(),
+          })
+          if (restoredBaseId) record.isBase = false
+          if (repromote) record.isBase = true
+        },
+        () => (restoredBaseId ? setBaseFlag(em, scope, [restoredBaseId], true) : undefined),
+      ],
+      { transaction: true },
+    )
   },
 }
 
@@ -355,42 +631,52 @@ const deleteCurrencyCommand: CommandHandler<CurrencyDeleteInput, { currencyId: s
     const parsed = currencyDeleteSchema.parse(input)
     requireId(parsed.id, 'Currency ID is required')
 
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const record = await em.findOne(
+    const scopeRecord = await (ctx.container.resolve('em') as EntityManager).fork().findOne(
       Currency,
       buildCurrencyCommandWhere<Currency>(ctx, { id: parsed.id }),
     )
-    if (!record) {
+    if (!scopeRecord) {
       throw new CrudHttpError(404, { error: 'Currency not found' })
     }
-    ensureCurrencyCommandScope(ctx, record)
+    ensureCurrencyCommandScope(ctx, scopeRecord)
+    const scope = scopeOf(scopeRecord)
 
-    // Prevent deleting base currency
-    if (record.isBase) {
-      throw new CrudHttpError(400, { error: 'Cannot delete the base currency' })
-    }
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let record!: Currency
 
-    // Prevent deleting currency with active exchange rates
-    const activeRatesCount = await em.count(ExchangeRate, {
-      $or: [
-        { fromCurrencyCode: record.code },
-        { toCurrencyCode: record.code },
-      ],
-      organizationId: record.organizationId,
-      tenantId: record.tenantId,
-      deletedAt: null,
-      isActive: true,
-    })
-    
-    if (activeRatesCount > 0) {
-      throw new CrudHttpError(400, { 
-        error: `Cannot delete currency ${record.code} because it has ${activeRatesCount} active exchange rate(s). Please delete or deactivate the exchange rates first.` 
-      })
-    }
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          await lockBaseCurrencyScope(em, scope)
+          const current = await em.findOne(
+            Currency,
+            buildCurrencyCommandWhere<Currency>(ctx, { id: parsed.id }),
+          )
+          if (!current) {
+            throw new CrudHttpError(404, { error: 'Currency not found' })
+          }
+          ensureCurrencyCommandScope(ctx, current)
+
+          if (current.isBase) {
+            throw new CrudHttpError(400, { error: 'Cannot delete the base currency' })
+          }
 
-    record.deletedAt = new Date()
-    record.isActive = false
-    await em.flush()
+          const activeRatesCount = await countActiveRatesForCode(em, scope, current.code)
+          if (activeRatesCount > 0) {
+            throw new CrudHttpError(400, {
+              error: `Cannot delete currency ${current.code} because it has ${activeRatesCount} active exchange rate(s). Please delete or deactivate the exchange rates first.`,
+            })
+          }
+          record = current
+        },
+        () => {
+          record.deletedAt = new Date()
+          record.isActive = false
+        },
+      ],
+      { transaction: true },
+    )
 
     const de = ctx.container.resolve('dataEngine') as DataEngine
     await emitCrudSideEffects({
@@ -407,7 +693,7 @@ const deleteCurrencyCommand: CommandHandler<CurrencyDeleteInput, { currencyId: s
 
     return { currencyId: record.id }
   },
-  buildLog: async ({ snapshots, result }) => {
+  buildLog: async ({ snapshots }) => {
     const before = snapshots.before as CurrencySnapshot | undefined
     if (!before) return null
     const { translate } = await resolveTranslations()
@@ -425,13 +711,34 @@ const deleteCurrencyCommand: CommandHandler<CurrencyDeleteInput, { currencyId: s
     const payload = extractUndoPayload<CurrencyUndoPayload>(logEntry)
     const before = payload?.before ?? null
     if (!before) return
+    const scope = scopeOf(before)
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const record = await em.findOne(Currency, { id: before.id })
-    if (!record) return
-    record.deletedAt = null
-    record.isActive = before.isActive
-    record.updatedAt = new Date()
-    await em.flush()
+    let record: Currency | null = null
+    let reviveAsNonBase = false
+
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          await lockBaseCurrencyScope(em, scope)
+          const current = await readScopedSnapshotRecord(em, before)
+          if (!current) return
+          if (current.isBase) {
+            const otherBaseIds = await findLiveBaseCurrencyIds(em, scope, current.id)
+            reviveAsNonBase = otherBaseIds.length > 0
+          }
+          record = current
+        },
+        () => {
+          if (!record) return
+          record.deletedAt = null
+          record.isActive = before.isActive
+          if (reviveAsNonBase) record.isBase = false
+          record.updatedAt = new Date()
+        },
+      ],
+      { transaction: true },
+    )
   },
 }