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

package/dist/modules/currencies/commands/currencies.js

@@ -1,7 +1,7 @@
 import { registerCommand } from "@open-mercato/shared/lib/commands";
 import { buildChanges, requireId, emitCrudSideEffects } from "@open-mercato/shared/lib/commands/helpers";
 import { extractUndoPayload } 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 { CrudHttpError, conflict, isUniqueViolation } from "@open-mercato/shared/lib/crud/errors";
 import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
@@ -45,55 +45,159 @@ async function loadCurrencySnapshot(em, id, ctx) {
     updatedAt: record.updatedAt.toISOString()
   };
 }
-async function enforceBaseCurrency(em, currencyId, organizationId, tenantId) {
-  await em.nativeUpdate(
+const NO_BASE_TRANSITION = { 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"
+];
+function baseCurrencyLockKey(scope) {
+  return `currencies:base:${scope.tenantId}:${scope.organizationId}`;
+}
+async function lockBaseCurrencyScope(em, scope) {
+  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, scope, excludeId) {
+  const rows = await em.find(
     Currency,
     {
-      organizationId,
-      tenantId,
-      id: { $ne: currencyId },
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
       isBase: true,
-      deletedAt: null
+      deletedAt: null,
+      ...excludeId ? { id: { $ne: excludeId } } : {}
+    },
+    { orderBy: { createdAt: "asc", id: "asc" } }
+  );
+  return rows.map((row) => row.id);
+}
+async function setBaseFlag(em, scope, ids, isBase) {
+  if (ids.length === 0) return;
+  await em.nativeUpdate(
+    Currency,
+    {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      id: { $in: ids }
     },
-    { isBase: false, updatedAt: /* @__PURE__ */ new Date() }
+    { isBase, updatedAt: /* @__PURE__ */ new Date() }
   );
 }
+async function findFirstLivePredecessorId(em, scope, candidateIds) {
+  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, key, fallback) {
+  const { translate } = await resolveTranslations();
+  return new CrudHttpError(status, { error: translate(key, fallback) });
+}
+async function resolvePredecessorOrRefuse(em, scope, candidateIds) {
+  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, scope, code) {
+  return em.count(ExchangeRate, {
+    $or: [
+      { fromCurrencyCode: code },
+      { toCurrencyCode: code }
+    ],
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+    deletedAt: null,
+    isActive: true
+  });
+}
+function readScopedSnapshotRecord(em, snapshot) {
+  return em.findOne(Currency, {
+    id: snapshot.id,
+    tenantId: snapshot.tenantId,
+    organizationId: snapshot.organizationId
+  });
+}
+function scopeOf(record) {
+  return { tenantId: record.tenantId, organizationId: record.organizationId };
+}
+function omitIsBase(input) {
+  const rest = { ...input };
+  delete rest.isBase;
+  return rest;
+}
+function isPromotionByLegacyLog(payload) {
+  return payload?.before?.isBase === false && payload?.after?.isBase === true;
+}
+function isDemotionByLegacyLog(payload) {
+  return !payload?.base && payload?.before?.isBase === true && payload?.after?.isBase === false;
+}
 const createCurrencyCommand = {
   id: "currencies.currencies.create",
   async execute(input, ctx) {
     const parsed = currencyCreateSchema.parse(input);
     ensureCurrencyCommandScope(ctx, parsed);
     const em = ctx.container.resolve("em").fork();
-    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 = /* @__PURE__ */ 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);
+    const scope = scopeOf(parsed);
+    let demotedBaseCurrencyIds = [];
+    let record;
     try {
       await withAtomicFlush(
         em,
         [
-          () => record.isBase ? enforceBaseCurrency(em, record.id, record.organizationId, record.tenantId) : void 0
+          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 = /* @__PURE__ */ 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 }
       );
@@ -115,13 +219,13 @@ const createCurrencyCommand = {
       },
       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").fork();
     return loadCurrencySnapshot(em, result.currencyId, ctx);
   },
-  buildLog: async ({ snapshots }) => {
+  buildLog: async ({ snapshots, result }) => {
     const after = snapshots.after;
     if (!after) return null;
     const { translate } = await resolveTranslations();
@@ -132,31 +236,104 @@ const createCurrencyCommand = {
       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(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").fork();
-    const record = await em.findOne(Currency, { id: after.id });
-    if (!record) return;
-    record.deletedAt = /* @__PURE__ */ new Date();
-    record.isActive = false;
-    await em.flush();
+    let record = null;
+    let restoredBaseId = 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 = /* @__PURE__ */ new Date();
+          record.isActive = false;
+          record.isBase = false;
+        },
+        () => restoredBaseId ? setBaseFlag(em, scope, [restoredBaseId], true) : void 0
+      ],
+      { transaction: true }
+    );
   },
-  redo: makeCreateRedo({
-    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(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").fork();
+    let demotedBaseCurrencyIds = [];
+    let record;
+    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),
+              (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");
+    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 = {
   id: "currencies.currencies.update",
@@ -169,57 +346,81 @@ const updateCurrencyCommand = {
   async execute(input, ctx) {
     const parsed = currencyUpdateSchema.parse(input);
     requireId(parsed.id, "Currency ID is required");
-    const em = ctx.container.resolve("em").fork();
-    const record = await em.findOne(
+    const scopeRecord = await ctx.container.resolve("em").fork().findOne(
       Currency,
       buildCurrencyCommandWhere(ctx, { id: parsed.id })
     );
-    if (!record) {
+    if (!scopeRecord) {
       throw new CrudHttpError(404, { error: "Currency not found" });
     }
-    ensureCurrencyCommandScope(ctx, record);
-    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, parsed, [
-      "code",
-      "name",
-      "symbol",
-      "decimalPlaces",
-      "thousandsSeparator",
-      "decimalSeparator",
-      "isBase",
-      "isActive"
-    ]);
-    const changes = Object.fromEntries(
-      Object.entries(allChanges).filter(([, c]) => c.to !== void 0)
-    );
-    if (Object.keys(changes).length === 0) {
-      return { currencyId: record.id };
-    }
+    ensureCurrencyCommandScope(ctx, scopeRecord);
+    const scope = scopeOf(scopeRecord);
+    const em = ctx.container.resolve("em").fork();
+    let record;
+    let changes = {};
+    let promoted = false;
+    let demotedBaseCurrencyIds = [];
     await withAtomicFlush(
       em,
       [
-        () => {
-          for (const [key, change] of Object.entries(changes)) {
-            ;
-            record[key] = change.to;
+        async () => {
+          await lockBaseCurrencyScope(em, scope);
+          const current = await em.findOne(
+            Currency,
+            buildCurrencyCommandWhere(ctx, { id: parsed.id })
+          );
+          if (!current) {
+            throw new CrudHttpError(404, { error: "Currency not found" });
           }
-          record.updatedAt = /* @__PURE__ */ 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,
+            parsed,
+            UPDATABLE_CURRENCY_FIELDS
+          );
+          changes = Object.fromEntries(
+            Object.entries(allChanges).filter(([, change]) => change.to !== void 0)
+          );
+          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: /* @__PURE__ */ new Date() });
         },
-        () => parsed.isBase === true && record.isBase ? enforceBaseCurrency(em, record.id, record.organizationId, record.tenantId) : void 0
+        () => setBaseFlag(em, scope, demotedBaseCurrencyIds, false)
       ],
       { transaction: true }
     );
+    const result = 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");
     await emitCrudSideEffects({
       dataEngine: de,
@@ -232,17 +433,18 @@ const updateCurrencyCommand = {
       },
       events: currencyCrudEvents
     });
-    return { currencyId: record.id };
+    return result;
   },
   captureAfter: async (_input, result, ctx) => {
     const em = ctx.container.resolve("em").fork();
     return loadCurrencySnapshot(em, result.currencyId, ctx);
   },
-  buildLog: async ({ snapshots, result }) => {
+  buildLog: async ({ input, snapshots, result }) => {
     const before = snapshots.before;
     const after = snapshots.after;
     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",
@@ -251,28 +453,56 @@ const updateCurrencyCommand = {
       organizationId: after.organizationId,
       snapshotBefore: before ?? void 0,
       snapshotAfter: after,
-      payload: { undo: { before, after } }
+      payload: { undo: { before, after, base } },
+      redoInput: base.promoted ? input : omitIsBase(input)
     };
   },
   undo: async ({ logEntry, ctx }) => {
     const payload = extractUndoPayload(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").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: /* @__PURE__ */ new Date()
-    });
-    await em.flush();
+    const demotedByLegacyLog = isDemotionByLegacyLog(payload);
+    let record = null;
+    let restoredBaseId = 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: /* @__PURE__ */ new Date()
+          });
+          if (restoredBaseId) record.isBase = false;
+          if (repromote) record.isBase = true;
+        },
+        () => restoredBaseId ? setBaseFlag(em, scope, [restoredBaseId], true) : void 0
+      ],
+      { transaction: true }
+    );
   }
 };
 const deleteCurrencyCommand = {
@@ -286,36 +516,48 @@ const deleteCurrencyCommand = {
   async execute(input, ctx) {
     const parsed = currencyDeleteSchema.parse(input);
     requireId(parsed.id, "Currency ID is required");
-    const em = ctx.container.resolve("em").fork();
-    const record = await em.findOne(
+    const scopeRecord = await ctx.container.resolve("em").fork().findOne(
       Currency,
       buildCurrencyCommandWhere(ctx, { id: parsed.id })
     );
-    if (!record) {
+    if (!scopeRecord) {
       throw new CrudHttpError(404, { error: "Currency not found" });
     }
-    ensureCurrencyCommandScope(ctx, record);
-    if (record.isBase) {
-      throw new CrudHttpError(400, { error: "Cannot delete the base currency" });
-    }
-    const activeRatesCount = await em.count(ExchangeRate, {
-      $or: [
-        { fromCurrencyCode: record.code },
-        { toCurrencyCode: record.code }
+    ensureCurrencyCommandScope(ctx, scopeRecord);
+    const scope = scopeOf(scopeRecord);
+    const em = ctx.container.resolve("em").fork();
+    let record;
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          await lockBaseCurrencyScope(em, scope);
+          const current = await em.findOne(
+            Currency,
+            buildCurrencyCommandWhere(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" });
+          }
+          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 = /* @__PURE__ */ new Date();
+          record.isActive = false;
+        }
       ],
-      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.`
-      });
-    }
-    record.deletedAt = /* @__PURE__ */ new Date();
-    record.isActive = false;
-    await em.flush();
+      { transaction: true }
+    );
     const de = ctx.container.resolve("dataEngine");
     await emitCrudSideEffects({
       dataEngine: de,
@@ -330,7 +572,7 @@ const deleteCurrencyCommand = {
     });
     return { currencyId: record.id };
   },
-  buildLog: async ({ snapshots, result }) => {
+  buildLog: async ({ snapshots }) => {
     const before = snapshots.before;
     if (!before) return null;
     const { translate } = await resolveTranslations();
@@ -348,13 +590,33 @@ const deleteCurrencyCommand = {
     const payload = extractUndoPayload(logEntry);
     const before = payload?.before ?? null;
     if (!before) return;
+    const scope = scopeOf(before);
     const em = ctx.container.resolve("em").fork();
-    const record = await em.findOne(Currency, { id: before.id });
-    if (!record) return;
-    record.deletedAt = null;
-    record.isActive = before.isActive;
-    record.updatedAt = /* @__PURE__ */ new Date();
-    await em.flush();
+    let record = 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 = /* @__PURE__ */ new Date();
+        }
+      ],
+      { transaction: true }
+    );
   }
 };
 registerCommand(createCurrencyCommand);