@open-mercato/core 0.6.7-develop.6661.1.0043ed1d03 → 0.6.7-develop.6670.1.4efa7961c6

package/dist/modules/wms/commands/configuration.js

@@ -0,0 +1,1519 @@
+import { registerCommand } from "@open-mercato/shared/lib/commands";
+import { withAtomicFlush } from "@open-mercato/shared/lib/commands/flush";
+import { CrudHttpError, isUniqueViolation } from "@open-mercato/shared/lib/crud/errors";
+import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
+import { findOneWithDecryption, findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { extractUndoPayload } from "@open-mercato/shared/lib/commands/undo";
+import {
+  InventoryLot,
+  ProductInventoryProfile,
+  Warehouse,
+  WarehouseLocation,
+  WarehouseZone
+} from "../data/entities.js";
+import {
+  inventoryLotCreateSchema,
+  inventoryLotUpdateSchema,
+  productInventoryProfileCreateSchema,
+  productInventoryProfileUpdateSchema,
+  warehouseCreateSchema,
+  warehouseLocationCreateSchema,
+  warehouseLocationUpdateSchema,
+  warehouseUpdateSchema,
+  warehouseZoneCreateSchema,
+  warehouseZoneUpdateSchema
+} from "../data/validators.js";
+import {
+  ensureOrganizationScope,
+  ensureTenantScope,
+  normalizeOptionalString,
+  requireId,
+  toNumericString
+} from "./shared.js";
+import { emitWmsEvent } from "../events.js";
+function resolveScope(ctx, fallback) {
+  return {
+    tenantId: fallback?.tenantId ?? ctx.auth?.tenantId ?? null,
+    organizationId: fallback?.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+  };
+}
+function resolveEm(ctx) {
+  return ctx.container.resolve("em").fork();
+}
+function toJsonValue(value) {
+  if (value === void 0) return void 0;
+  return value ?? null;
+}
+async function buildCrudLog(ctx, input, resultId, actionKey, fallbackLabel, resourceKind) {
+  const { translate } = await resolveTranslations();
+  return {
+    actionLabel: translate(actionKey, fallbackLabel),
+    resourceKind,
+    resourceId: resultId ?? input?.id ?? null,
+    tenantId: input?.tenantId ?? ctx.auth?.tenantId ?? null,
+    organizationId: input?.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+  };
+}
+async function loadWarehouse(em, ctx, id) {
+  const warehouse = await findOneWithDecryption(em, Warehouse, { id, deletedAt: null }, void 0, resolveScope(ctx));
+  if (!warehouse) throw new CrudHttpError(404, { error: "Warehouse not found." });
+  ensureTenantScope(ctx, warehouse.tenantId);
+  ensureOrganizationScope(ctx, warehouse.organizationId);
+  return warehouse;
+}
+async function loadZone(em, ctx, id) {
+  const zone = await findOneWithDecryption(em, WarehouseZone, { id, deletedAt: null }, void 0, resolveScope(ctx));
+  if (!zone) throw new CrudHttpError(404, { error: "Warehouse zone not found." });
+  ensureTenantScope(ctx, zone.tenantId);
+  ensureOrganizationScope(ctx, zone.organizationId);
+  return zone;
+}
+async function loadLocation(em, ctx, id) {
+  const location = await findOneWithDecryption(em, WarehouseLocation, { id, deletedAt: null }, void 0, resolveScope(ctx));
+  if (!location) throw new CrudHttpError(404, { error: "Warehouse location not found." });
+  ensureTenantScope(ctx, location.tenantId);
+  ensureOrganizationScope(ctx, location.organizationId);
+  return location;
+}
+async function loadProfile(em, ctx, id) {
+  const profile = await findOneWithDecryption(em, ProductInventoryProfile, { id, deletedAt: null }, void 0, resolveScope(ctx));
+  if (!profile) throw new CrudHttpError(404, { error: "Inventory profile not found." });
+  ensureTenantScope(ctx, profile.tenantId);
+  ensureOrganizationScope(ctx, profile.organizationId);
+  return profile;
+}
+async function loadLot(em, ctx, id) {
+  const lot = await findOneWithDecryption(em, InventoryLot, { id, deletedAt: null }, void 0, resolveScope(ctx));
+  if (!lot) throw new CrudHttpError(404, { error: "Inventory lot not found." });
+  ensureTenantScope(ctx, lot.tenantId);
+  ensureOrganizationScope(ctx, lot.organizationId);
+  return lot;
+}
+function isoOrNull(value) {
+  if (!value) return null;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  return null;
+}
+function dateOrNull(value) {
+  if (!value) return null;
+  if (value instanceof Date) return value;
+  if (typeof value === "string") return new Date(value);
+  return null;
+}
+function snapshotWarehouse(record) {
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    name: record.name,
+    code: record.code,
+    isActive: !!record.isActive,
+    isPrimary: !!record.isPrimary,
+    addressLine1: record.addressLine1 ?? null,
+    city: record.city ?? null,
+    postalCode: record.postalCode ?? null,
+    country: record.country ?? null,
+    timezone: record.timezone ?? null,
+    metadata: record.metadata ?? null,
+    createdAt: record.createdAt.toISOString(),
+    updatedAt: record.updatedAt.toISOString()
+  };
+}
+async function loadWarehouseSnapshot(em, ctx, id) {
+  const record = await findOneWithDecryption(em, Warehouse, { id }, void 0, resolveScope(ctx));
+  return record ? snapshotWarehouse(record) : null;
+}
+function snapshotWarehouseZone(record) {
+  const warehouseId = typeof record.warehouse === "string" ? record.warehouse : record.warehouse.id;
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    warehouseId,
+    code: record.code,
+    name: record.name,
+    priority: record.priority ?? 0,
+    metadata: record.metadata ?? null,
+    createdAt: record.createdAt.toISOString(),
+    updatedAt: record.updatedAt.toISOString()
+  };
+}
+async function loadWarehouseZoneSnapshot(em, ctx, id) {
+  const record = await findOneWithDecryption(em, WarehouseZone, { id }, void 0, resolveScope(ctx));
+  return record ? snapshotWarehouseZone(record) : null;
+}
+function snapshotWarehouseLocation(record) {
+  const warehouseId = typeof record.warehouse === "string" ? record.warehouse : record.warehouse.id;
+  let parentId = null;
+  if (record.parent) {
+    parentId = typeof record.parent === "string" ? record.parent : record.parent.id;
+  }
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    warehouseId,
+    parentId,
+    code: record.code,
+    type: record.type,
+    isActive: !!record.isActive,
+    capacityUnits: record.capacityUnits ?? null,
+    capacityWeight: record.capacityWeight ?? null,
+    constraints: record.constraints ?? null,
+    metadata: record.metadata ?? null,
+    createdAt: record.createdAt.toISOString(),
+    updatedAt: record.updatedAt.toISOString()
+  };
+}
+async function loadWarehouseLocationSnapshot(em, ctx, id) {
+  const record = await findOneWithDecryption(em, WarehouseLocation, { id }, void 0, resolveScope(ctx));
+  return record ? snapshotWarehouseLocation(record) : null;
+}
+function snapshotInventoryProfile(record) {
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    catalogProductId: record.catalogProductId,
+    catalogVariantId: record.catalogVariantId ?? null,
+    defaultUom: record.defaultUom,
+    trackLot: !!record.trackLot,
+    trackSerial: !!record.trackSerial,
+    trackExpiration: !!record.trackExpiration,
+    defaultStrategy: record.defaultStrategy,
+    reorderPoint: record.reorderPoint,
+    safetyStock: record.safetyStock,
+    metadata: record.metadata ?? null,
+    createdAt: record.createdAt.toISOString(),
+    updatedAt: record.updatedAt.toISOString()
+  };
+}
+async function loadInventoryProfileSnapshot(em, ctx, id) {
+  const record = await findOneWithDecryption(em, ProductInventoryProfile, { id }, void 0, resolveScope(ctx));
+  return record ? snapshotInventoryProfile(record) : null;
+}
+function snapshotInventoryLot(record) {
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    catalogVariantId: record.catalogVariantId,
+    sku: record.sku,
+    lotNumber: record.lotNumber,
+    batchNumber: record.batchNumber ?? null,
+    manufacturedAt: isoOrNull(record.manufacturedAt ?? null),
+    bestBeforeAt: isoOrNull(record.bestBeforeAt ?? null),
+    expiresAt: isoOrNull(record.expiresAt ?? null),
+    status: record.status,
+    metadata: record.metadata ?? null,
+    createdAt: record.createdAt.toISOString(),
+    updatedAt: record.updatedAt.toISOString()
+  };
+}
+async function loadInventoryLotSnapshot(em, ctx, id) {
+  const record = await findOneWithDecryption(em, InventoryLot, { id }, void 0, resolveScope(ctx));
+  return record ? snapshotInventoryLot(record) : null;
+}
+async function ensureWarehouseCodeUnique(em, tenantId, organizationId, code, excludeId) {
+  const existing = await findOneWithDecryption(
+    em,
+    Warehouse,
+    { tenantId, organizationId, code, deletedAt: null },
+    void 0,
+    { tenantId, organizationId }
+  );
+  if (existing && existing.id !== excludeId) {
+    throw new CrudHttpError(409, { error: "Warehouse code already exists in this organization." });
+  }
+}
+async function loadDemotedPrimarySnapshots(em, organizationId, tenantId, warehouseId) {
+  const siblings = await findWithDecryption(
+    em,
+    Warehouse,
+    {
+      organizationId,
+      id: { $ne: warehouseId },
+      isPrimary: true,
+      deletedAt: null
+    },
+    void 0,
+    { tenantId, organizationId }
+  );
+  return siblings.map((record) => ({ id: record.id, isPrimary: true }));
+}
+async function enforcePrimaryWarehouse(em, organizationId, tenantId, warehouseId) {
+  const demotedPrimariesBefore = await loadDemotedPrimarySnapshots(em, organizationId, tenantId, warehouseId);
+  if (demotedPrimariesBefore.length === 0) return [];
+  await em.nativeUpdate(
+    Warehouse,
+    {
+      organizationId,
+      id: { $ne: warehouseId },
+      isPrimary: true,
+      deletedAt: null
+    },
+    { isPrimary: false }
+  );
+  return demotedPrimariesBefore;
+}
+async function rejectInactivePrimaryWarehouse(ctx) {
+  const { translate } = await resolveTranslations();
+  const message = translate(
+    "wms.validation.warehouse.inactivePrimary",
+    "Inactive warehouses cannot be marked as primary."
+  );
+  throw new CrudHttpError(422, { error: message, fieldErrors: { isPrimary: message } });
+}
+const WMS_WAREHOUSE_PRIMARY_UNIQUE_CONSTRAINT = "wms_warehouses_org_primary_unique_idx";
+async function rejectPrimaryWarehouseConflict() {
+  const { translate } = await resolveTranslations();
+  const message = translate(
+    "wms.validation.warehouse.primaryConflict",
+    "Another warehouse was just set as primary for this organization. Please retry."
+  );
+  throw new CrudHttpError(409, { error: message, fieldErrors: { isPrimary: message } });
+}
+async function restoreDemotedPrimaryWarehouses(em, ctx, demotedPrimariesBefore) {
+  if (!demotedPrimariesBefore?.length) return;
+  for (const snapshot of demotedPrimariesBefore) {
+    const record = await findOneWithDecryption(em, Warehouse, { id: snapshot.id }, void 0, resolveScope(ctx));
+    if (!record) continue;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.isPrimary = snapshot.isPrimary;
+  }
+}
+async function ensureZoneCodeUnique(em, warehouseId, tenantId, organizationId, code, excludeId) {
+  const existing = await findOneWithDecryption(
+    em,
+    WarehouseZone,
+    { warehouse: warehouseId, tenantId, organizationId, code, deletedAt: null },
+    void 0,
+    { tenantId, organizationId }
+  );
+  if (existing && existing.id !== excludeId) {
+    throw new CrudHttpError(409, { error: "Zone code already exists in this warehouse." });
+  }
+}
+async function ensureLocationCodeUnique(em, warehouseId, tenantId, organizationId, code, excludeId) {
+  const existing = await findOneWithDecryption(
+    em,
+    WarehouseLocation,
+    { warehouse: warehouseId, tenantId, organizationId, code, deletedAt: null },
+    void 0,
+    { tenantId, organizationId }
+  );
+  if (existing && existing.id !== excludeId) {
+    throw new CrudHttpError(409, { error: "Location code already exists in this warehouse." });
+  }
+}
+async function ensureProfileUniqueness(em, input, excludeId) {
+  const where = input.catalogVariantId ? {
+    tenantId: input.tenantId,
+    organizationId: input.organizationId,
+    catalogVariantId: input.catalogVariantId,
+    deletedAt: null
+  } : {
+    tenantId: input.tenantId,
+    organizationId: input.organizationId,
+    catalogProductId: input.catalogProductId,
+    catalogVariantId: null,
+    deletedAt: null
+  };
+  const existing = await findOneWithDecryption(
+    em,
+    ProductInventoryProfile,
+    where,
+    void 0,
+    { tenantId: input.tenantId, organizationId: input.organizationId }
+  );
+  if (existing && existing.id !== excludeId) {
+    throw new CrudHttpError(409, { error: "Inventory profile already exists for this product scope." });
+  }
+}
+async function ensureLotUniqueness(em, input, excludeId) {
+  const existing = await findOneWithDecryption(
+    em,
+    InventoryLot,
+    {
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+      catalogVariantId: input.catalogVariantId,
+      lotNumber: input.lotNumber,
+      deletedAt: null
+    },
+    void 0,
+    { tenantId: input.tenantId, organizationId: input.organizationId }
+  );
+  if (existing && existing.id !== excludeId) {
+    throw new CrudHttpError(409, { error: "Lot number already exists for this variant." });
+  }
+}
+async function resolveParentLocation(em, ctx, warehouseId, parentId) {
+  if (!parentId) return null;
+  const parent = await loadLocation(em, ctx, parentId);
+  const parentWarehouseId = typeof parent.warehouse === "string" ? parent.warehouse : parent.warehouse.id;
+  if (parentWarehouseId !== warehouseId) {
+    throw new CrudHttpError(422, { error: "Parent location must belong to the same warehouse." });
+  }
+  return parent;
+}
+const createWarehouseCommand = {
+  id: "wms.warehouses.create",
+  async execute(rawInput, ctx) {
+    const parsed = warehouseCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const em = resolveEm(ctx);
+    await ensureWarehouseCodeUnique(em, parsed.tenantId, parsed.organizationId, parsed.code);
+    const isActive = parsed.isActive ?? true;
+    const isPrimary = parsed.isPrimary ?? false;
+    if (isPrimary && !isActive) {
+      await rejectInactivePrimaryWarehouse(ctx);
+    }
+    const warehouse = em.create(Warehouse, {
+      organizationId: parsed.organizationId,
+      tenantId: parsed.tenantId,
+      name: parsed.name,
+      code: parsed.code,
+      isActive,
+      // Always insert as non-primary first: inserting with isPrimary=true would
+      // race the `wms_warehouses_org_primary_unique_idx` partial unique index
+      // against an existing sibling primary before that sibling gets demoted
+      // below (Postgres checks partial unique indexes per-statement, not at
+      // commit time).
+      isPrimary: false,
+      addressLine1: normalizeOptionalString(parsed.addressLine1),
+      city: normalizeOptionalString(parsed.city),
+      postalCode: normalizeOptionalString(parsed.postalCode),
+      country: normalizeOptionalString(parsed.country),
+      timezone: normalizeOptionalString(parsed.timezone),
+      metadata: toJsonValue(parsed.metadata)
+    });
+    let demotedPrimariesBefore = [];
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          () => {
+            em.persist(warehouse);
+          },
+          async () => {
+            if (!isPrimary) return;
+            demotedPrimariesBefore = await enforcePrimaryWarehouse(
+              em,
+              warehouse.organizationId,
+              warehouse.tenantId,
+              warehouse.id
+            );
+          },
+          () => {
+            if (isPrimary) warehouse.isPrimary = true;
+          }
+        ],
+        { transaction: true, label: "wms.warehouses.create" }
+      );
+    } catch (err) {
+      if (isUniqueViolation(err, WMS_WAREHOUSE_PRIMARY_UNIQUE_CONSTRAINT)) {
+        await rejectPrimaryWarehouseConflict();
+      }
+      throw err;
+    }
+    void emitWmsEvent("wms.warehouse.created", {
+      id: warehouse.id,
+      warehouseId: warehouse.id,
+      tenantId: warehouse.tenantId,
+      organizationId: warehouse.organizationId
+    }).catch(() => void 0);
+    return {
+      warehouseId: warehouse.id,
+      ...demotedPrimariesBefore.length > 0 ? { demotedPrimariesBefore } : {}
+    };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadWarehouseSnapshot(em, ctx, result.warehouseId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.warehouseId ?? null, "wms.audit.warehouse.create", "Create warehouse", "wms.warehouse");
+    const after = snapshots?.after;
+    const demotedPrimariesBefore = result?.demotedPrimariesBefore;
+    return {
+      ...base,
+      snapshotAfter: after,
+      payload: {
+        undo: {
+          after,
+          ...demotedPrimariesBefore?.length ? { demotedPrimariesBefore } : {}
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const em = resolveEm(ctx);
+    const record = await findOneWithDecryption(
+      em,
+      Warehouse,
+      { id: after.id },
+      void 0,
+      resolveScope(ctx, { tenantId: after.tenantId, organizationId: after.organizationId })
+    );
+    if (!record) return;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    if (payload.demotedPrimariesBefore?.length) {
+      await restoreDemotedPrimaryWarehouses(em, ctx, payload.demotedPrimariesBefore);
+      await em.flush();
+    }
+  }
+};
+const updateWarehouseCommand = {
+  id: "wms.warehouses.update",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Warehouse");
+    const em = resolveEm(ctx);
+    const before = await loadWarehouseSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(rawInput, ctx) {
+    const parsed = warehouseUpdateSchema.parse(rawInput ?? {});
+    const em = resolveEm(ctx);
+    const warehouse = await loadWarehouse(em, ctx, parsed.id);
+    if (parsed.code !== void 0 && parsed.code !== warehouse.code) {
+      await ensureWarehouseCodeUnique(em, warehouse.tenantId, warehouse.organizationId, parsed.code, warehouse.id);
+    }
+    let nextIsActive = warehouse.isActive;
+    let nextIsPrimary = warehouse.isPrimary;
+    if (parsed.isActive !== void 0) nextIsActive = parsed.isActive;
+    if (parsed.isPrimary !== void 0) nextIsPrimary = parsed.isPrimary;
+    if (parsed.isActive === false && nextIsPrimary) {
+      nextIsPrimary = false;
+    } else if (nextIsPrimary && !nextIsActive) {
+      await rejectInactivePrimaryWarehouse(ctx);
+    }
+    let demotedPrimariesBefore = [];
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          () => {
+            if (parsed.code !== void 0) warehouse.code = parsed.code;
+            if (parsed.name !== void 0) warehouse.name = parsed.name;
+            if (parsed.addressLine1 !== void 0) warehouse.addressLine1 = normalizeOptionalString(parsed.addressLine1);
+            if (parsed.city !== void 0) warehouse.city = normalizeOptionalString(parsed.city);
+            if (parsed.postalCode !== void 0) warehouse.postalCode = normalizeOptionalString(parsed.postalCode);
+            if (parsed.country !== void 0) warehouse.country = normalizeOptionalString(parsed.country);
+            if (parsed.timezone !== void 0) warehouse.timezone = normalizeOptionalString(parsed.timezone);
+            if (parsed.metadata !== void 0) warehouse.metadata = toJsonValue(parsed.metadata);
+            warehouse.isActive = nextIsActive;
+            warehouse.isPrimary = false;
+          },
+          async () => {
+            if (!nextIsPrimary) return;
+            demotedPrimariesBefore = await enforcePrimaryWarehouse(
+              em,
+              warehouse.organizationId,
+              warehouse.tenantId,
+              warehouse.id
+            );
+          },
+          () => {
+            warehouse.isPrimary = nextIsPrimary;
+          }
+        ],
+        { transaction: true, label: "wms.warehouses.update" }
+      );
+    } catch (err) {
+      if (isUniqueViolation(err, WMS_WAREHOUSE_PRIMARY_UNIQUE_CONSTRAINT)) {
+        await rejectPrimaryWarehouseConflict();
+      }
+      throw err;
+    }
+    void emitWmsEvent("wms.warehouse.updated", {
+      id: warehouse.id,
+      warehouseId: warehouse.id,
+      tenantId: warehouse.tenantId,
+      organizationId: warehouse.organizationId
+    }).catch(() => void 0);
+    return {
+      warehouseId: warehouse.id,
+      ...demotedPrimariesBefore.length > 0 ? { demotedPrimariesBefore } : {}
+    };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadWarehouseSnapshot(em, ctx, result.warehouseId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.warehouseId ?? null, "wms.audit.warehouse.update", "Update warehouse", "wms.warehouse");
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    const demotedPrimariesBefore = result?.demotedPrimariesBefore;
+    return {
+      ...base,
+      snapshotBefore: before,
+      snapshotAfter: after,
+      payload: {
+        undo: {
+          before,
+          after,
+          ...demotedPrimariesBefore?.length ? { demotedPrimariesBefore } : {}
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    let record = await findOneWithDecryption(
+      em,
+      Warehouse,
+      { id: before.id },
+      void 0,
+      resolveScope(ctx, { tenantId: before.tenantId, organizationId: before.organizationId })
+    );
+    if (!record) {
+      record = em.create(Warehouse, {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId,
+        name: before.name,
+        code: before.code,
+        isActive: before.isActive,
+        isPrimary: before.isPrimary,
+        addressLine1: before.addressLine1,
+        city: before.city,
+        postalCode: before.postalCode,
+        country: before.country,
+        timezone: before.timezone,
+        metadata: before.metadata,
+        createdAt: new Date(before.createdAt),
+        updatedAt: new Date(before.updatedAt)
+      });
+      em.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      record.name = before.name;
+      record.code = before.code;
+      record.isActive = before.isActive;
+      record.isPrimary = before.isPrimary;
+      record.addressLine1 = before.addressLine1;
+      record.city = before.city;
+      record.postalCode = before.postalCode;
+      record.country = before.country;
+      record.timezone = before.timezone;
+      record.metadata = before.metadata;
+      record.deletedAt = null;
+    }
+    await em.flush();
+    if (payload.demotedPrimariesBefore?.length) {
+      await restoreDemotedPrimaryWarehouses(em, ctx, payload.demotedPrimariesBefore);
+      await em.flush();
+    }
+  }
+};
+const deleteWarehouseCommand = {
+  id: "wms.warehouses.delete",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Warehouse");
+    const em = resolveEm(ctx);
+    const before = await loadWarehouseSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(input, ctx) {
+    const warehouseId = requireId(input?.id, "Warehouse");
+    const em = resolveEm(ctx);
+    const warehouse = await loadWarehouse(em, ctx, warehouseId);
+    warehouse.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    return { warehouseId: warehouse.id };
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.warehouseId ?? null, "wms.audit.warehouse.delete", "Delete warehouse", "wms.warehouse");
+    const before = snapshots?.before;
+    return { ...base, snapshotBefore: before, payload: { undo: { before } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    let record = await findOneWithDecryption(
+      em,
+      Warehouse,
+      { id: before.id },
+      void 0,
+      resolveScope(ctx, { tenantId: before.tenantId, organizationId: before.organizationId })
+    );
+    if (!record) {
+      record = em.create(Warehouse, {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId,
+        name: before.name,
+        code: before.code,
+        isActive: before.isActive,
+        isPrimary: before.isPrimary,
+        addressLine1: before.addressLine1,
+        city: before.city,
+        postalCode: before.postalCode,
+        country: before.country,
+        timezone: before.timezone,
+        metadata: before.metadata,
+        createdAt: new Date(before.createdAt),
+        updatedAt: new Date(before.updatedAt)
+      });
+      em.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      record.deletedAt = null;
+      record.name = before.name;
+      record.code = before.code;
+      record.isActive = before.isActive;
+      record.isPrimary = before.isPrimary;
+      record.addressLine1 = before.addressLine1;
+      record.city = before.city;
+      record.postalCode = before.postalCode;
+      record.country = before.country;
+      record.timezone = before.timezone;
+      record.metadata = before.metadata;
+    }
+    await em.flush();
+  }
+};
+async function restoreZoneFromSnapshot(em, before) {
+  const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+  const warehouseRef = await findOneWithDecryption(em, Warehouse, { id: before.warehouseId }, void 0, scope);
+  if (!warehouseRef) {
+    throw new CrudHttpError(409, { error: "Cannot undo zone: parent warehouse no longer exists." });
+  }
+  let record = await findOneWithDecryption(em, WarehouseZone, { id: before.id }, void 0, scope);
+  if (!record) {
+    record = em.create(WarehouseZone, {
+      id: before.id,
+      organizationId: before.organizationId,
+      tenantId: before.tenantId,
+      warehouse: warehouseRef,
+      code: before.code,
+      name: before.name,
+      priority: before.priority,
+      metadata: before.metadata,
+      createdAt: new Date(before.createdAt),
+      updatedAt: new Date(before.updatedAt)
+    });
+    em.persist(record);
+  } else {
+    record.warehouse = warehouseRef;
+    record.code = before.code;
+    record.name = before.name;
+    record.priority = before.priority;
+    record.metadata = before.metadata;
+    record.deletedAt = null;
+  }
+}
+const createWarehouseZoneCommand = {
+  id: "wms.zones.create",
+  async execute(rawInput, ctx) {
+    const parsed = warehouseZoneCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const em = resolveEm(ctx);
+    const warehouse = await loadWarehouse(em, ctx, parsed.warehouseId);
+    await ensureZoneCodeUnique(em, warehouse.id, warehouse.tenantId, warehouse.organizationId, parsed.code);
+    const zone = em.create(WarehouseZone, {
+      organizationId: parsed.organizationId,
+      tenantId: parsed.tenantId,
+      warehouse,
+      code: parsed.code,
+      name: parsed.name,
+      priority: parsed.priority ?? 0,
+      metadata: toJsonValue(parsed.metadata)
+    });
+    await em.persist(zone).flush();
+    void emitWmsEvent("wms.zone.created", {
+      id: zone.id,
+      zoneId: zone.id,
+      warehouseId: typeof zone.warehouse === "string" ? zone.warehouse : zone.warehouse.id,
+      tenantId: zone.tenantId,
+      organizationId: zone.organizationId
+    }).catch(() => void 0);
+    return { zoneId: zone.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadWarehouseZoneSnapshot(em, ctx, result.zoneId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.zoneId ?? null, "wms.audit.zone.create", "Create warehouse zone", "wms.zone");
+    const after = snapshots?.after;
+    return { ...base, snapshotAfter: after, payload: { undo: { after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const em = resolveEm(ctx);
+    const record = await findOneWithDecryption(
+      em,
+      WarehouseZone,
+      { id: after.id },
+      void 0,
+      resolveScope(ctx, { tenantId: after.tenantId, organizationId: after.organizationId })
+    );
+    if (!record) return;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+  }
+};
+const updateWarehouseZoneCommand = {
+  id: "wms.zones.update",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Zone");
+    const em = resolveEm(ctx);
+    const before = await loadWarehouseZoneSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(rawInput, ctx) {
+    const parsed = warehouseZoneUpdateSchema.parse(rawInput ?? {});
+    const em = resolveEm(ctx);
+    const zone = await loadZone(em, ctx, parsed.id);
+    if (parsed.warehouseId !== void 0) {
+      const warehouse = await loadWarehouse(em, ctx, parsed.warehouseId);
+      zone.warehouse = warehouse;
+    }
+    const warehouseId = typeof zone.warehouse === "string" ? zone.warehouse : zone.warehouse.id;
+    if (parsed.code !== void 0 && parsed.code !== zone.code) {
+      await ensureZoneCodeUnique(em, warehouseId, zone.tenantId, zone.organizationId, parsed.code, zone.id);
+      zone.code = parsed.code;
+    }
+    if (parsed.name !== void 0) zone.name = parsed.name;
+    if (parsed.priority !== void 0) zone.priority = parsed.priority;
+    if (parsed.metadata !== void 0) zone.metadata = toJsonValue(parsed.metadata);
+    await em.flush();
+    void emitWmsEvent("wms.zone.updated", {
+      id: zone.id,
+      zoneId: zone.id,
+      warehouseId: typeof zone.warehouse === "string" ? zone.warehouse : zone.warehouse.id,
+      tenantId: zone.tenantId,
+      organizationId: zone.organizationId
+    }).catch(() => void 0);
+    return { zoneId: zone.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadWarehouseZoneSnapshot(em, ctx, result.zoneId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.zoneId ?? null, "wms.audit.zone.update", "Update warehouse zone", "wms.zone");
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    return { ...base, snapshotBefore: before, snapshotAfter: after, payload: { undo: { before, after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    ensureTenantScope(ctx, before.tenantId);
+    ensureOrganizationScope(ctx, before.organizationId);
+    await restoreZoneFromSnapshot(em, before);
+    await em.flush();
+  }
+};
+const deleteWarehouseZoneCommand = {
+  id: "wms.zones.delete",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Zone");
+    const em = resolveEm(ctx);
+    const before = await loadWarehouseZoneSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(input, ctx) {
+    const zoneId = requireId(input?.id, "Zone");
+    const em = resolveEm(ctx);
+    const zone = await loadZone(em, ctx, zoneId);
+    zone.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    return { zoneId: zone.id };
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.zoneId ?? null, "wms.audit.zone.delete", "Delete warehouse zone", "wms.zone");
+    const before = snapshots?.before;
+    return { ...base, snapshotBefore: before, payload: { undo: { before } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    ensureTenantScope(ctx, before.tenantId);
+    ensureOrganizationScope(ctx, before.organizationId);
+    await restoreZoneFromSnapshot(em, before);
+    await em.flush();
+  }
+};
+async function restoreLocationFromSnapshot(em, before) {
+  const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+  const warehouseRef = await findOneWithDecryption(em, Warehouse, { id: before.warehouseId }, void 0, scope);
+  if (!warehouseRef) {
+    throw new CrudHttpError(409, { error: "Cannot undo location: parent warehouse no longer exists." });
+  }
+  let parentRef = null;
+  if (before.parentId) {
+    parentRef = await findOneWithDecryption(em, WarehouseLocation, { id: before.parentId }, void 0, scope);
+  }
+  let record = await findOneWithDecryption(em, WarehouseLocation, { id: before.id }, void 0, scope);
+  if (!record) {
+    record = em.create(WarehouseLocation, {
+      id: before.id,
+      organizationId: before.organizationId,
+      tenantId: before.tenantId,
+      warehouse: warehouseRef,
+      parent: parentRef,
+      code: before.code,
+      type: before.type,
+      isActive: before.isActive,
+      capacityUnits: before.capacityUnits,
+      capacityWeight: before.capacityWeight,
+      constraints: before.constraints,
+      metadata: before.metadata,
+      createdAt: new Date(before.createdAt),
+      updatedAt: new Date(before.updatedAt)
+    });
+    em.persist(record);
+  } else {
+    record.warehouse = warehouseRef;
+    record.parent = parentRef;
+    record.code = before.code;
+    record.type = before.type;
+    record.isActive = before.isActive;
+    record.capacityUnits = before.capacityUnits;
+    record.capacityWeight = before.capacityWeight;
+    record.constraints = before.constraints;
+    record.metadata = before.metadata;
+    record.deletedAt = null;
+  }
+}
+const createWarehouseLocationCommand = {
+  id: "wms.locations.create",
+  async execute(rawInput, ctx) {
+    const parsed = warehouseLocationCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const em = resolveEm(ctx);
+    const warehouse = await loadWarehouse(em, ctx, parsed.warehouseId);
+    await ensureLocationCodeUnique(em, warehouse.id, warehouse.tenantId, warehouse.organizationId, parsed.code);
+    const parent = await resolveParentLocation(em, ctx, warehouse.id, parsed.parentId ?? null);
+    const location = em.create(WarehouseLocation, {
+      organizationId: parsed.organizationId,
+      tenantId: parsed.tenantId,
+      warehouse,
+      code: parsed.code,
+      type: parsed.type,
+      parent,
+      isActive: parsed.isActive ?? true,
+      capacityUnits: parsed.capacityUnits !== void 0 ? toNumericString(parsed.capacityUnits) : null,
+      capacityWeight: parsed.capacityWeight !== void 0 ? toNumericString(parsed.capacityWeight) : null,
+      constraints: toJsonValue(parsed.constraints),
+      metadata: toJsonValue(parsed.metadata)
+    });
+    await em.persist(location).flush();
+    void emitWmsEvent("wms.location.created", {
+      id: location.id,
+      locationId: location.id,
+      warehouseId: typeof location.warehouse === "string" ? location.warehouse : location.warehouse.id,
+      tenantId: location.tenantId,
+      organizationId: location.organizationId
+    }).catch(() => void 0);
+    return { locationId: location.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadWarehouseLocationSnapshot(em, ctx, result.locationId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.locationId ?? null, "wms.audit.location.create", "Create warehouse location", "wms.location");
+    const after = snapshots?.after;
+    return { ...base, snapshotAfter: after, payload: { undo: { after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const em = resolveEm(ctx);
+    const record = await findOneWithDecryption(
+      em,
+      WarehouseLocation,
+      { id: after.id },
+      void 0,
+      resolveScope(ctx, { tenantId: after.tenantId, organizationId: after.organizationId })
+    );
+    if (!record) return;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+  }
+};
+const updateWarehouseLocationCommand = {
+  id: "wms.locations.update",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Location");
+    const em = resolveEm(ctx);
+    const before = await loadWarehouseLocationSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(rawInput, ctx) {
+    const parsed = warehouseLocationUpdateSchema.parse(rawInput ?? {});
+    const em = resolveEm(ctx);
+    const location = await loadLocation(em, ctx, parsed.id);
+    if (parsed.warehouseId !== void 0) {
+      const warehouse = await loadWarehouse(em, ctx, parsed.warehouseId);
+      location.warehouse = warehouse;
+    }
+    const warehouseId = typeof location.warehouse === "string" ? location.warehouse : location.warehouse.id;
+    if (parsed.parentId !== void 0) {
+      location.parent = await resolveParentLocation(em, ctx, warehouseId, parsed.parentId);
+    }
+    if (parsed.code !== void 0 && parsed.code !== location.code) {
+      await ensureLocationCodeUnique(em, warehouseId, location.tenantId, location.organizationId, parsed.code, location.id);
+      location.code = parsed.code;
+    }
+    if (parsed.type !== void 0) location.type = parsed.type;
+    if (parsed.isActive !== void 0) location.isActive = parsed.isActive;
+    if (parsed.capacityUnits !== void 0) location.capacityUnits = toNumericString(parsed.capacityUnits);
+    if (parsed.capacityWeight !== void 0) location.capacityWeight = toNumericString(parsed.capacityWeight);
+    if (parsed.constraints !== void 0) location.constraints = toJsonValue(parsed.constraints);
+    if (parsed.metadata !== void 0) location.metadata = toJsonValue(parsed.metadata);
+    await em.flush();
+    void emitWmsEvent("wms.location.updated", {
+      id: location.id,
+      locationId: location.id,
+      warehouseId: typeof location.warehouse === "string" ? location.warehouse : location.warehouse.id,
+      tenantId: location.tenantId,
+      organizationId: location.organizationId
+    }).catch(() => void 0);
+    return { locationId: location.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadWarehouseLocationSnapshot(em, ctx, result.locationId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.locationId ?? null, "wms.audit.location.update", "Update warehouse location", "wms.location");
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    return { ...base, snapshotBefore: before, snapshotAfter: after, payload: { undo: { before, after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    ensureTenantScope(ctx, before.tenantId);
+    ensureOrganizationScope(ctx, before.organizationId);
+    await restoreLocationFromSnapshot(em, before);
+    await em.flush();
+  }
+};
+const deleteWarehouseLocationCommand = {
+  id: "wms.locations.delete",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Location");
+    const em = resolveEm(ctx);
+    const before = await loadWarehouseLocationSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(input, ctx) {
+    const locationId = requireId(input?.id, "Location");
+    const em = resolveEm(ctx);
+    const location = await loadLocation(em, ctx, locationId);
+    location.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    return { locationId: location.id };
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.locationId ?? null, "wms.audit.location.delete", "Delete warehouse location", "wms.location");
+    const before = snapshots?.before;
+    return { ...base, snapshotBefore: before, payload: { undo: { before } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    ensureTenantScope(ctx, before.tenantId);
+    ensureOrganizationScope(ctx, before.organizationId);
+    await restoreLocationFromSnapshot(em, before);
+    await em.flush();
+  }
+};
+function restoreInventoryProfileFromSnapshot(em, before, record) {
+  record.catalogProductId = before.catalogProductId;
+  record.catalogVariantId = before.catalogVariantId;
+  record.defaultUom = before.defaultUom;
+  record.trackLot = before.trackLot;
+  record.trackSerial = before.trackSerial;
+  record.trackExpiration = before.trackExpiration;
+  record.defaultStrategy = before.defaultStrategy;
+  record.reorderPoint = before.reorderPoint;
+  record.safetyStock = before.safetyStock;
+  record.metadata = before.metadata;
+  record.deletedAt = null;
+}
+const createProductInventoryProfileCommand = {
+  id: "wms.inventoryProfiles.create",
+  async execute(rawInput, ctx) {
+    const parsed = productInventoryProfileCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const em = resolveEm(ctx);
+    await ensureProfileUniqueness(em, parsed);
+    const profile = em.create(ProductInventoryProfile, {
+      organizationId: parsed.organizationId,
+      tenantId: parsed.tenantId,
+      catalogProductId: parsed.catalogProductId,
+      catalogVariantId: parsed.catalogVariantId ?? null,
+      defaultUom: parsed.defaultUom,
+      trackLot: parsed.trackLot ?? false,
+      trackSerial: parsed.trackSerial ?? false,
+      trackExpiration: parsed.trackExpiration ?? false,
+      defaultStrategy: parsed.defaultStrategy,
+      reorderPoint: toNumericString(parsed.reorderPoint),
+      safetyStock: toNumericString(parsed.safetyStock),
+      metadata: toJsonValue(parsed.metadata)
+    });
+    await em.persist(profile).flush();
+    void emitWmsEvent("wms.inventory_profile.created", {
+      id: profile.id,
+      profileId: profile.id,
+      catalogProductId: profile.catalogProductId,
+      catalogVariantId: profile.catalogVariantId ?? null,
+      tenantId: profile.tenantId,
+      organizationId: profile.organizationId
+    }).catch(() => void 0);
+    return { profileId: profile.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadInventoryProfileSnapshot(em, ctx, result.profileId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.profileId ?? null, "wms.audit.inventoryProfile.create", "Create inventory profile", "wms.inventoryProfile");
+    const after = snapshots?.after;
+    return { ...base, snapshotAfter: after, payload: { undo: { after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const em = resolveEm(ctx);
+    const record = await findOneWithDecryption(
+      em,
+      ProductInventoryProfile,
+      { id: after.id },
+      void 0,
+      resolveScope(ctx, { tenantId: after.tenantId, organizationId: after.organizationId })
+    );
+    if (!record) return;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+  }
+};
+const updateProductInventoryProfileCommand = {
+  id: "wms.inventoryProfiles.update",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Inventory profile");
+    const em = resolveEm(ctx);
+    const before = await loadInventoryProfileSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(rawInput, ctx) {
+    const parsed = productInventoryProfileUpdateSchema.parse(rawInput ?? {});
+    const em = resolveEm(ctx);
+    const profile = await loadProfile(em, ctx, parsed.id);
+    const next = {
+      tenantId: profile.tenantId,
+      organizationId: profile.organizationId,
+      catalogProductId: parsed.catalogProductId ?? profile.catalogProductId,
+      catalogVariantId: parsed.catalogVariantId !== void 0 ? parsed.catalogVariantId ?? null : profile.catalogVariantId ?? null
+    };
+    if (parsed.catalogProductId !== void 0 || parsed.catalogVariantId !== void 0) {
+      await ensureProfileUniqueness(em, next, profile.id);
+    }
+    if (parsed.catalogProductId !== void 0) profile.catalogProductId = parsed.catalogProductId;
+    if (parsed.catalogVariantId !== void 0) profile.catalogVariantId = parsed.catalogVariantId ?? null;
+    if (parsed.defaultUom !== void 0) profile.defaultUom = parsed.defaultUom;
+    if (parsed.trackLot !== void 0) profile.trackLot = parsed.trackLot;
+    if (parsed.trackSerial !== void 0) profile.trackSerial = parsed.trackSerial;
+    if (parsed.trackExpiration !== void 0) profile.trackExpiration = parsed.trackExpiration;
+    if (parsed.defaultStrategy !== void 0) profile.defaultStrategy = parsed.defaultStrategy;
+    if (parsed.reorderPoint !== void 0) profile.reorderPoint = toNumericString(parsed.reorderPoint);
+    if (parsed.safetyStock !== void 0) profile.safetyStock = toNumericString(parsed.safetyStock);
+    if (parsed.metadata !== void 0) profile.metadata = toJsonValue(parsed.metadata);
+    await em.flush();
+    void emitWmsEvent("wms.inventory_profile.updated", {
+      id: profile.id,
+      profileId: profile.id,
+      catalogProductId: profile.catalogProductId,
+      catalogVariantId: profile.catalogVariantId ?? null,
+      tenantId: profile.tenantId,
+      organizationId: profile.organizationId
+    }).catch(() => void 0);
+    return { profileId: profile.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadInventoryProfileSnapshot(em, ctx, result.profileId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.profileId ?? null, "wms.audit.inventoryProfile.update", "Update inventory profile", "wms.inventoryProfile");
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    return { ...base, snapshotBefore: before, snapshotAfter: after, payload: { undo: { before, after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    let record = await findOneWithDecryption(
+      em,
+      ProductInventoryProfile,
+      { id: before.id },
+      void 0,
+      resolveScope(ctx, { tenantId: before.tenantId, organizationId: before.organizationId })
+    );
+    if (!record) {
+      record = em.create(ProductInventoryProfile, {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId,
+        catalogProductId: before.catalogProductId,
+        catalogVariantId: before.catalogVariantId,
+        defaultUom: before.defaultUom,
+        trackLot: before.trackLot,
+        trackSerial: before.trackSerial,
+        trackExpiration: before.trackExpiration,
+        defaultStrategy: before.defaultStrategy,
+        reorderPoint: before.reorderPoint,
+        safetyStock: before.safetyStock,
+        metadata: before.metadata,
+        createdAt: new Date(before.createdAt),
+        updatedAt: new Date(before.updatedAt)
+      });
+      em.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreInventoryProfileFromSnapshot(em, before, record);
+    }
+    await em.flush();
+  }
+};
+const deleteProductInventoryProfileCommand = {
+  id: "wms.inventoryProfiles.delete",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Inventory profile");
+    const em = resolveEm(ctx);
+    const before = await loadInventoryProfileSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(input, ctx) {
+    const profileId = requireId(input?.id, "Inventory profile");
+    const em = resolveEm(ctx);
+    const profile = await loadProfile(em, ctx, profileId);
+    profile.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    return { profileId: profile.id };
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.profileId ?? null, "wms.audit.inventoryProfile.delete", "Delete inventory profile", "wms.inventoryProfile");
+    const before = snapshots?.before;
+    return { ...base, snapshotBefore: before, payload: { undo: { before } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    let record = await findOneWithDecryption(
+      em,
+      ProductInventoryProfile,
+      { id: before.id },
+      void 0,
+      resolveScope(ctx, { tenantId: before.tenantId, organizationId: before.organizationId })
+    );
+    if (!record) {
+      record = em.create(ProductInventoryProfile, {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId,
+        catalogProductId: before.catalogProductId,
+        catalogVariantId: before.catalogVariantId,
+        defaultUom: before.defaultUom,
+        trackLot: before.trackLot,
+        trackSerial: before.trackSerial,
+        trackExpiration: before.trackExpiration,
+        defaultStrategy: before.defaultStrategy,
+        reorderPoint: before.reorderPoint,
+        safetyStock: before.safetyStock,
+        metadata: before.metadata,
+        createdAt: new Date(before.createdAt),
+        updatedAt: new Date(before.updatedAt)
+      });
+      em.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreInventoryProfileFromSnapshot(em, before, record);
+    }
+    await em.flush();
+  }
+};
+function restoreInventoryLotFromSnapshot(_em, before, record) {
+  record.catalogVariantId = before.catalogVariantId;
+  record.sku = before.sku;
+  record.lotNumber = before.lotNumber;
+  record.batchNumber = before.batchNumber;
+  record.manufacturedAt = dateOrNull(before.manufacturedAt);
+  record.bestBeforeAt = dateOrNull(before.bestBeforeAt);
+  record.expiresAt = dateOrNull(before.expiresAt);
+  record.status = before.status;
+  record.metadata = before.metadata;
+  record.deletedAt = null;
+}
+const createInventoryLotCommand = {
+  id: "wms.lots.create",
+  async execute(rawInput, ctx) {
+    const parsed = inventoryLotCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const em = resolveEm(ctx);
+    await ensureLotUniqueness(em, parsed);
+    const lot = em.create(InventoryLot, {
+      organizationId: parsed.organizationId,
+      tenantId: parsed.tenantId,
+      catalogVariantId: parsed.catalogVariantId,
+      sku: parsed.sku,
+      lotNumber: parsed.lotNumber,
+      batchNumber: normalizeOptionalString(parsed.batchNumber),
+      manufacturedAt: parsed.manufacturedAt ?? null,
+      bestBeforeAt: parsed.bestBeforeAt ?? null,
+      expiresAt: parsed.expiresAt ?? null,
+      status: parsed.status ?? "available",
+      metadata: toJsonValue(parsed.metadata)
+    });
+    await em.persist(lot).flush();
+    return { lotId: lot.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadInventoryLotSnapshot(em, ctx, result.lotId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.lotId ?? null, "wms.audit.lot.create", "Create inventory lot", "wms.inventoryLot");
+    const after = snapshots?.after;
+    return { ...base, snapshotAfter: after, payload: { undo: { after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const em = resolveEm(ctx);
+    const record = await findOneWithDecryption(
+      em,
+      InventoryLot,
+      { id: after.id },
+      void 0,
+      resolveScope(ctx, { tenantId: after.tenantId, organizationId: after.organizationId })
+    );
+    if (!record) return;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+  }
+};
+const updateInventoryLotCommand = {
+  id: "wms.lots.update",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Inventory lot");
+    const em = resolveEm(ctx);
+    const before = await loadInventoryLotSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(rawInput, ctx) {
+    const parsed = inventoryLotUpdateSchema.parse(rawInput ?? {});
+    const em = resolveEm(ctx);
+    const lot = await loadLot(em, ctx, parsed.id);
+    const nextVariantId = parsed.catalogVariantId ?? lot.catalogVariantId;
+    const nextLotNumber = parsed.lotNumber ?? lot.lotNumber;
+    if (parsed.catalogVariantId !== void 0 || parsed.lotNumber !== void 0) {
+      await ensureLotUniqueness(
+        em,
+        {
+          tenantId: lot.tenantId,
+          organizationId: lot.organizationId,
+          catalogVariantId: nextVariantId,
+          lotNumber: nextLotNumber
+        },
+        lot.id
+      );
+    }
+    if (parsed.catalogVariantId !== void 0) lot.catalogVariantId = parsed.catalogVariantId;
+    if (parsed.sku !== void 0) lot.sku = parsed.sku;
+    if (parsed.lotNumber !== void 0) lot.lotNumber = parsed.lotNumber;
+    if (parsed.batchNumber !== void 0) lot.batchNumber = normalizeOptionalString(parsed.batchNumber);
+    if (parsed.manufacturedAt !== void 0) lot.manufacturedAt = parsed.manufacturedAt ?? null;
+    if (parsed.bestBeforeAt !== void 0) lot.bestBeforeAt = parsed.bestBeforeAt ?? null;
+    if (parsed.expiresAt !== void 0) lot.expiresAt = parsed.expiresAt ?? null;
+    if (parsed.status !== void 0) lot.status = parsed.status;
+    if (parsed.metadata !== void 0) lot.metadata = toJsonValue(parsed.metadata);
+    if (parsed.notes !== void 0) {
+      const existing = lot.metadata && typeof lot.metadata === "object" && !Array.isArray(lot.metadata) ? { ...lot.metadata } : {};
+      const trimmedNotes = parsed.notes.trim();
+      if (trimmedNotes) existing.notes = trimmedNotes;
+      else delete existing.notes;
+      lot.metadata = toJsonValue(existing);
+    }
+    await em.flush();
+    return { lotId: lot.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = resolveEm(ctx);
+    return loadInventoryLotSnapshot(em, ctx, result.lotId);
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.lotId ?? null, "wms.audit.lot.update", "Update inventory lot", "wms.inventoryLot");
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    return { ...base, snapshotBefore: before, snapshotAfter: after, payload: { undo: { before, after } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    let record = await findOneWithDecryption(
+      em,
+      InventoryLot,
+      { id: before.id },
+      void 0,
+      resolveScope(ctx, { tenantId: before.tenantId, organizationId: before.organizationId })
+    );
+    if (!record) {
+      record = em.create(InventoryLot, {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId,
+        catalogVariantId: before.catalogVariantId,
+        sku: before.sku,
+        lotNumber: before.lotNumber,
+        batchNumber: before.batchNumber,
+        manufacturedAt: dateOrNull(before.manufacturedAt),
+        bestBeforeAt: dateOrNull(before.bestBeforeAt),
+        expiresAt: dateOrNull(before.expiresAt),
+        status: before.status,
+        metadata: before.metadata,
+        createdAt: new Date(before.createdAt),
+        updatedAt: new Date(before.updatedAt)
+      });
+      em.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreInventoryLotFromSnapshot(em, before, record);
+    }
+    await em.flush();
+  }
+};
+const deleteInventoryLotCommand = {
+  id: "wms.lots.delete",
+  prepare: async (input, ctx) => {
+    const id = requireId(input?.id, "Inventory lot");
+    const em = resolveEm(ctx);
+    const before = await loadInventoryLotSnapshot(em, ctx, id);
+    return before ? { before } : {};
+  },
+  async execute(input, ctx) {
+    const lotId = requireId(input?.id, "Inventory lot");
+    const em = resolveEm(ctx);
+    const lot = await loadLot(em, ctx, lotId);
+    lot.deletedAt = /* @__PURE__ */ new Date();
+    await em.flush();
+    return { lotId: lot.id };
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(ctx, input, result?.lotId ?? null, "wms.audit.lot.delete", "Delete inventory lot", "wms.inventoryLot");
+    const before = snapshots?.before;
+    return { ...base, snapshotBefore: before, payload: { undo: { before } } };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const em = resolveEm(ctx);
+    let record = await findOneWithDecryption(
+      em,
+      InventoryLot,
+      { id: before.id },
+      void 0,
+      resolveScope(ctx, { tenantId: before.tenantId, organizationId: before.organizationId })
+    );
+    if (!record) {
+      record = em.create(InventoryLot, {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId,
+        catalogVariantId: before.catalogVariantId,
+        sku: before.sku,
+        lotNumber: before.lotNumber,
+        batchNumber: before.batchNumber,
+        manufacturedAt: dateOrNull(before.manufacturedAt),
+        bestBeforeAt: dateOrNull(before.bestBeforeAt),
+        expiresAt: dateOrNull(before.expiresAt),
+        status: before.status,
+        metadata: before.metadata,
+        createdAt: new Date(before.createdAt),
+        updatedAt: new Date(before.updatedAt)
+      });
+      em.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreInventoryLotFromSnapshot(em, before, record);
+    }
+    await em.flush();
+  }
+};
+registerCommand(createWarehouseCommand);
+registerCommand(updateWarehouseCommand);
+registerCommand(deleteWarehouseCommand);
+registerCommand(createWarehouseZoneCommand);
+registerCommand(updateWarehouseZoneCommand);
+registerCommand(deleteWarehouseZoneCommand);
+registerCommand(createWarehouseLocationCommand);
+registerCommand(updateWarehouseLocationCommand);
+registerCommand(deleteWarehouseLocationCommand);
+registerCommand(createProductInventoryProfileCommand);
+registerCommand(updateProductInventoryProfileCommand);
+registerCommand(deleteProductInventoryProfileCommand);
+registerCommand(createInventoryLotCommand);
+registerCommand(updateInventoryLotCommand);
+registerCommand(deleteInventoryLotCommand);
+//# sourceMappingURL=configuration.js.map