@open-mercato/core 0.6.8-develop.6998.1.d2bc46c56c → 0.6.8-develop.7001.1.03608ab252

package/dist/modules/warranty_claims/commands/claim-lines.js

@@ -0,0 +1,911 @@
+import { randomUUID } from "crypto";
+import { LockMode } from "@mikro-orm/core";
+import { z } from "zod";
+import { registerCommand } from "@open-mercato/shared/lib/commands";
+import { withAtomicFlush } from "@open-mercato/shared/lib/commands/flush";
+import { emitCrudSideEffects, emitCrudUndoSideEffects } from "@open-mercato/shared/lib/commands/helpers";
+import { CrudHttpError } from "@open-mercato/shared/lib/crud/errors";
+import { invalidateCrudCache } from "@open-mercato/shared/lib/crud/cache";
+import { findOneWithDecryption, findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { E } from "../../../generated/entities.ids.generated.js";
+import { WarrantyClaimLine } from "../data/entities.js";
+import {
+  claimLineCreateSchema,
+  claimLineReceiveSchema,
+  claimLineReleaseQuarantineSchema,
+  claimLineUpdateSchema
+} from "../data/validators.js";
+import { emitWarrantyClaimsEvent } from "../events.js";
+import {
+  assertDispositionAllowedForGrade,
+  suggestedDispositionForGrade
+} from "../lib/grading.js";
+import { assertDispositionAllowedForType } from "../lib/claimTypeConfig.js";
+import { resolveEffectiveWarrantyClaimSettings } from "../lib/settings.js";
+import { computeHeaderRollups, lineStatusGuards } from "../lib/stateMachine.js";
+import {
+  WARRANTY_CLAIM_LINE_RESOURCE_KIND,
+  WARRANTY_CLAIM_RESOURCE_KIND,
+  appendClaimEvent,
+  enforceWarrantyClaimOptimisticLock,
+  ensureOrganizationScope,
+  ensureTenantScope,
+  extractUndoPayload,
+  requireScopedClaim
+} from "./shared.js";
+import { assertPendingClaimQuantitiesWithinSold, validateClaimReferences } from "./claims.js";
+const claimCrudEvents = {
+  module: "warranty_claims",
+  entity: "claim",
+  persistent: true
+};
+const lineDeleteSchema = z.object({
+  id: z.string().uuid(),
+  claimId: z.string().uuid().optional(),
+  organizationId: z.string().uuid().optional(),
+  tenantId: z.string().uuid().optional()
+}).strict();
+const lineSetAssessmentSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid().optional(),
+  tenantId: z.string().uuid().optional(),
+  assessmentPayload: z.record(z.string(), z.unknown()),
+  updatedAt: z.union([z.string().datetime(), z.date()]).nullable().optional()
+}).strict();
+const mutableParentStatuses = /* @__PURE__ */ new Set([
+  "draft",
+  "submitted",
+  "in_review",
+  "info_requested",
+  "approved",
+  "received",
+  "inspecting"
+]);
+function parseCommandInput(schema, rawInput) {
+  const result = schema.safeParse(rawInput ?? {});
+  if (!result.success) {
+    throw new CrudHttpError(400, { error: "[internal] invalid warranty claim line command input" });
+  }
+  return result.data;
+}
+function hasOwn(input, key) {
+  return Object.prototype.hasOwnProperty.call(input, key);
+}
+function resolveScope(ctx, input) {
+  const tenantId = input.tenantId ?? ctx.auth?.tenantId ?? null;
+  const organizationId = input.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null;
+  if (!tenantId) throw new CrudHttpError(400, { error: "[internal] tenant scope required for warranty claim line command" });
+  if (!organizationId) throw new CrudHttpError(400, { error: "[internal] organization scope required for warranty claim line command" });
+  ensureTenantScope(ctx, tenantId);
+  ensureOrganizationScope(ctx, organizationId);
+  return { tenantId, organizationId };
+}
+function toIso(value) {
+  if (!value) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function toDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function toDateOnlyIso(value) {
+  const iso = toIso(value);
+  return iso ? iso.slice(0, 10) : null;
+}
+function toDateOnly(value) {
+  if (!value) return null;
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function amountString(value, fallback = "0") {
+  if (value === null) return null;
+  if (value === void 0) return fallback;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return String(parsed);
+}
+function nullableAmountString(value) {
+  if (value === void 0 || value === null) return null;
+  return amountString(value, "0");
+}
+function numberValue(value) {
+  if (value === null || value === void 0) return 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function addMonths(date, months) {
+  const target = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + months, 1));
+  const lastDay = new Date(Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0)).getUTCDate();
+  const copy = new Date(date.getTime());
+  copy.setUTCDate(1);
+  copy.setUTCFullYear(target.getUTCFullYear(), target.getUTCMonth(), Math.min(date.getUTCDate(), lastDay));
+  return copy;
+}
+function computeWarrantyDates(purchaseDate, warrantyMonths) {
+  if (!purchaseDate || warrantyMonths === null || warrantyMonths === void 0) {
+    return { warrantyExpiresAt: null, warrantyStatus: "unknown" };
+  }
+  const warrantyExpiresAt = addMonths(purchaseDate, warrantyMonths);
+  const warrantyStatus = warrantyExpiresAt.getTime() >= Date.now() ? "in_warranty" : "out_of_warranty";
+  return { warrantyExpiresAt, warrantyStatus };
+}
+function claimIdOf(line) {
+  const claim = line.claim;
+  if (typeof claim === "object" && claim && "id" in claim && typeof claim.id === "string") return claim.id;
+  return String(claim);
+}
+function claimOf(line) {
+  const claim = line.claim;
+  if (typeof claim === "object" && claim && "id" in claim && typeof claim.id === "string") return claim;
+  return null;
+}
+function sameDateValue(left, right) {
+  const leftTime = left instanceof Date ? left.getTime() : null;
+  const rightTime = right instanceof Date ? right.getTime() : null;
+  return leftTime === rightTime;
+}
+function assertParentMutable(claim) {
+  if (!mutableParentStatuses.has(claim.status)) {
+    throw new CrudHttpError(400, { error: "warranty_claims.errors.lineLocked" });
+  }
+}
+function assertReceivingStatus(claim) {
+  if (claim.status !== "received" && claim.status !== "inspecting") {
+    throw new CrudHttpError(400, { error: "warranty_claims.errors.receivingStatusInvalid" });
+  }
+}
+function toConditionGrade(value) {
+  if (value === "A" || value === "B" || value === "C" || value === "D") return value;
+  return null;
+}
+function assertLineQuantities(line) {
+  const qtyClaimed = numberValue(line.qtyClaimed);
+  const qtyApproved = line.qtyApproved === null || line.qtyApproved === void 0 ? null : numberValue(line.qtyApproved);
+  const qtyReceived = line.qtyReceived === null || line.qtyReceived === void 0 ? null : numberValue(line.qtyReceived);
+  if (qtyClaimed < 0 || qtyApproved !== null && qtyApproved < 0 || qtyReceived !== null && qtyReceived < 0) {
+    throw new CrudHttpError(400, { error: "warranty_claims.errors.lineLocked" });
+  }
+  if (qtyApproved !== null && qtyApproved > qtyClaimed) {
+    throw new CrudHttpError(400, { error: "warranty_claims.errors.lineLocked" });
+  }
+  if (qtyReceived !== null && qtyReceived > qtyClaimed) {
+    throw new CrudHttpError(400, { error: "warranty_claims.errors.lineLocked" });
+  }
+}
+function assertLineStatusMove(from, to) {
+  if (from === to) return;
+  if (lineStatusGuards[from].includes(to)) return;
+  throw new CrudHttpError(400, { error: "warranty_claims.errors.invalidTransition" });
+}
+function buildLineCreateData(claim, input, lineNo) {
+  const purchaseDate = input.purchaseDate ?? null;
+  const warrantyMonths = input.warrantyMonths ?? null;
+  const computedWarranty = computeWarrantyDates(purchaseDate, warrantyMonths);
+  return {
+    id: randomUUID(),
+    claim,
+    organizationId: claim.organizationId,
+    tenantId: claim.tenantId,
+    lineNo,
+    productId: input.productId ?? null,
+    variantId: input.variantId ?? null,
+    sku: input.sku ?? null,
+    productName: input.productName ?? null,
+    orderLineId: input.orderLineId ?? null,
+    serialNumber: input.serialNumber ?? null,
+    lotNumber: input.lotNumber ?? null,
+    purchaseDate,
+    warrantyMonths,
+    warrantyExpiresAt: input.warrantyExpiresAt ?? computedWarranty.warrantyExpiresAt,
+    warrantyStatus: input.warrantyStatus ?? computedWarranty.warrantyStatus,
+    faultCode: input.faultCode ?? null,
+    faultDescription: input.faultDescription ?? null,
+    qtyClaimed: amountString(input.qtyClaimed, "1") ?? "1",
+    qtyApproved: nullableAmountString(input.qtyApproved),
+    qtyReceived: nullableAmountString(input.qtyReceived),
+    conditionOnReceipt: input.conditionOnReceipt ?? null,
+    inspectionNotes: input.inspectionNotes ?? null,
+    disposition: input.disposition ?? null,
+    vendorName: input.vendorName ?? null,
+    lineStatus: "pending",
+    creditAmount: nullableAmountString(input.creditAmount),
+    restockingFee: nullableAmountString(input.restockingFee),
+    coreChargeAmount: nullableAmountString(input.coreChargeAmount),
+    coreCreditAmount: nullableAmountString(input.coreCreditAmount),
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+}
+function applyLineUpdate(line, input) {
+  const purchaseDateChanged = hasOwn(input, "purchaseDate") && !sameDateValue(line.purchaseDate ?? null, input.purchaseDate ?? null);
+  const warrantyMonthsChanged = hasOwn(input, "warrantyMonths") && (line.warrantyMonths ?? null) !== (input.warrantyMonths ?? null);
+  const hasExplicitWarranty = hasOwn(input, "warrantyExpiresAt") || hasOwn(input, "warrantyStatus");
+  if (hasOwn(input, "lineNo") && input.lineNo !== void 0) line.lineNo = input.lineNo;
+  if (hasOwn(input, "productId")) line.productId = input.productId ?? null;
+  if (hasOwn(input, "variantId")) line.variantId = input.variantId ?? null;
+  if (hasOwn(input, "sku")) line.sku = input.sku ?? null;
+  if (hasOwn(input, "productName")) line.productName = input.productName ?? null;
+  if (hasOwn(input, "orderLineId")) line.orderLineId = input.orderLineId ?? null;
+  if (hasOwn(input, "serialNumber")) line.serialNumber = input.serialNumber ?? null;
+  if (hasOwn(input, "lotNumber")) line.lotNumber = input.lotNumber ?? null;
+  if (hasOwn(input, "purchaseDate")) line.purchaseDate = input.purchaseDate ?? null;
+  if (hasOwn(input, "warrantyMonths")) line.warrantyMonths = input.warrantyMonths ?? null;
+  if (hasOwn(input, "warrantyExpiresAt")) line.warrantyExpiresAt = input.warrantyExpiresAt ?? null;
+  if (hasOwn(input, "warrantyStatus") && input.warrantyStatus) line.warrantyStatus = input.warrantyStatus;
+  if (hasOwn(input, "faultCode")) line.faultCode = input.faultCode ?? null;
+  if (hasOwn(input, "faultDescription")) line.faultDescription = input.faultDescription ?? null;
+  if (hasOwn(input, "qtyClaimed") && input.qtyClaimed !== void 0) line.qtyClaimed = amountString(input.qtyClaimed, "1") ?? "1";
+  if (hasOwn(input, "qtyApproved")) line.qtyApproved = nullableAmountString(input.qtyApproved);
+  if (hasOwn(input, "qtyReceived")) line.qtyReceived = nullableAmountString(input.qtyReceived);
+  if (hasOwn(input, "conditionOnReceipt")) line.conditionOnReceipt = input.conditionOnReceipt ?? null;
+  if (hasOwn(input, "inspectionNotes")) line.inspectionNotes = input.inspectionNotes ?? null;
+  if (hasOwn(input, "disposition")) line.disposition = input.disposition ?? null;
+  if (hasOwn(input, "vendorName")) line.vendorName = input.vendorName ?? null;
+  if (hasOwn(input, "lineStatus") && input.lineStatus) {
+    assertLineStatusMove(line.lineStatus, input.lineStatus);
+    line.lineStatus = input.lineStatus;
+  }
+  if (hasOwn(input, "creditAmount")) line.creditAmount = nullableAmountString(input.creditAmount);
+  if (hasOwn(input, "restockingFee")) line.restockingFee = nullableAmountString(input.restockingFee);
+  if (hasOwn(input, "coreChargeAmount")) line.coreChargeAmount = nullableAmountString(input.coreChargeAmount);
+  if (hasOwn(input, "coreCreditAmount")) line.coreCreditAmount = nullableAmountString(input.coreCreditAmount);
+  if ((purchaseDateChanged || warrantyMonthsChanged) && !hasExplicitWarranty) {
+    const computedWarranty = computeWarrantyDates(line.purchaseDate ?? null, line.warrantyMonths ?? null);
+    line.warrantyExpiresAt = computedWarranty.warrantyExpiresAt;
+    line.warrantyStatus = computedWarranty.warrantyStatus;
+  }
+  line.updatedAt = /* @__PURE__ */ new Date();
+}
+function snapshotLine(line) {
+  return {
+    id: line.id,
+    claimId: claimIdOf(line),
+    organizationId: line.organizationId,
+    tenantId: line.tenantId,
+    lineNo: line.lineNo,
+    productId: line.productId ?? null,
+    variantId: line.variantId ?? null,
+    sku: line.sku ?? null,
+    productName: line.productName ?? null,
+    orderLineId: line.orderLineId ?? null,
+    serialNumber: line.serialNumber ?? null,
+    lotNumber: line.lotNumber ?? null,
+    purchaseDate: toDateOnlyIso(line.purchaseDate),
+    warrantyMonths: line.warrantyMonths ?? null,
+    warrantyExpiresAt: toDateOnlyIso(line.warrantyExpiresAt),
+    warrantyStatus: line.warrantyStatus,
+    faultCode: line.faultCode ?? null,
+    faultDescription: line.faultDescription ?? null,
+    qtyClaimed: line.qtyClaimed,
+    qtyApproved: line.qtyApproved ?? null,
+    qtyReceived: line.qtyReceived ?? null,
+    conditionOnReceipt: line.conditionOnReceipt ?? null,
+    conditionGrade: line.conditionGrade ?? null,
+    quarantineStatus: line.quarantineStatus,
+    inspectionNotes: line.inspectionNotes ?? null,
+    assessmentPayload: line.assessmentPayload ?? null,
+    disposition: line.disposition ?? null,
+    lineStatus: line.lineStatus,
+    creditAmount: line.creditAmount ?? null,
+    restockingFee: line.restockingFee ?? null,
+    coreChargeAmount: line.coreChargeAmount ?? null,
+    coreCreditAmount: line.coreCreditAmount ?? null,
+    vendorClaimLineId: line.vendorClaimLineId ?? null,
+    vendorName: line.vendorName ?? null,
+    deletedAt: toIso(line.deletedAt),
+    updatedAt: toIso(line.updatedAt)
+  };
+}
+async function loadLineSnapshot(em, lineId, scope) {
+  const line = await findOneWithDecryption(
+    em,
+    WarrantyClaimLine,
+    { id: lineId, tenantId: scope.tenantId, organizationId: scope.organizationId },
+    { populate: ["claim"] },
+    scope
+  );
+  return line ? snapshotLine(line) : null;
+}
+function restoreLineFromSnapshot(line, snapshot) {
+  line.lineNo = snapshot.lineNo;
+  line.productId = snapshot.productId;
+  line.variantId = snapshot.variantId;
+  line.sku = snapshot.sku;
+  line.productName = snapshot.productName;
+  line.orderLineId = snapshot.orderLineId;
+  line.serialNumber = snapshot.serialNumber;
+  line.lotNumber = snapshot.lotNumber;
+  line.purchaseDate = toDateOnly(snapshot.purchaseDate);
+  line.warrantyMonths = snapshot.warrantyMonths;
+  line.warrantyExpiresAt = toDateOnly(snapshot.warrantyExpiresAt);
+  line.warrantyStatus = snapshot.warrantyStatus;
+  line.faultCode = snapshot.faultCode;
+  line.faultDescription = snapshot.faultDescription;
+  line.qtyClaimed = snapshot.qtyClaimed;
+  line.qtyApproved = snapshot.qtyApproved;
+  line.qtyReceived = snapshot.qtyReceived;
+  line.conditionOnReceipt = snapshot.conditionOnReceipt;
+  line.conditionGrade = snapshot.conditionGrade;
+  line.quarantineStatus = snapshot.quarantineStatus;
+  line.inspectionNotes = snapshot.inspectionNotes;
+  line.assessmentPayload = snapshot.assessmentPayload;
+  line.disposition = snapshot.disposition;
+  line.lineStatus = snapshot.lineStatus;
+  line.creditAmount = snapshot.creditAmount;
+  line.restockingFee = snapshot.restockingFee;
+  line.coreChargeAmount = snapshot.coreChargeAmount;
+  line.coreCreditAmount = snapshot.coreCreditAmount;
+  line.vendorClaimLineId = snapshot.vendorClaimLineId;
+  line.vendorName = snapshot.vendorName;
+  line.deletedAt = toDate(snapshot.deletedAt);
+  line.updatedAt = /* @__PURE__ */ new Date();
+}
+async function recomputeClaimRollups(em, claim) {
+  const lines = await findWithDecryption(
+    em,
+    WarrantyClaimLine,
+    {
+      claim: claim.id,
+      tenantId: claim.tenantId,
+      organizationId: claim.organizationId,
+      deletedAt: null
+    },
+    {},
+    { tenantId: claim.tenantId, organizationId: claim.organizationId }
+  );
+  const totals = computeHeaderRollups(lines, { claimType: claim.claimType });
+  claim.totalClaimedAmount = String(totals.totalClaimedAmount);
+  claim.totalApprovedAmount = String(totals.totalApprovedAmount);
+  claim.updatedAt = /* @__PURE__ */ new Date();
+}
+async function requireScopedLine(em, lineId, scope) {
+  const line = await findOneWithDecryption(
+    em,
+    WarrantyClaimLine,
+    { id: lineId, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    { populate: ["claim"] },
+    scope
+  );
+  if (!line) throw new CrudHttpError(404, { error: "warranty_claims.errors.notFound" });
+  return line;
+}
+async function emitClaimUpdated(ctx, claim) {
+  const dataEngine = ctx.container.resolve("dataEngine");
+  await emitCrudSideEffects({
+    dataEngine,
+    action: "updated",
+    entity: claim,
+    identifiers: { id: claim.id, organizationId: claim.organizationId, tenantId: claim.tenantId },
+    indexer: { entityType: E.warranty_claims.warranty_claim },
+    events: claimCrudEvents
+  });
+  await invalidateCrudCache(
+    ctx.container,
+    "warranty_claims.claim",
+    { id: claim.id, organizationId: claim.organizationId, tenantId: claim.tenantId },
+    ctx.auth?.tenantId ?? null,
+    "warranty_claims.claim_line.rollup"
+  );
+}
+async function emitLineCrud(ctx, action, line) {
+  const dataEngine = ctx.container.resolve("dataEngine");
+  await emitCrudSideEffects({
+    dataEngine,
+    action,
+    entity: line,
+    identifiers: { id: line.id, organizationId: line.organizationId, tenantId: line.tenantId },
+    indexer: { entityType: E.warranty_claims.warranty_claim_line }
+  });
+  await invalidateCrudCache(
+    ctx.container,
+    "warranty_claims.claim_line",
+    { id: line.id, organizationId: line.organizationId, tenantId: line.tenantId },
+    ctx.auth?.tenantId ?? null,
+    `warranty_claims.claim_line.${action}`
+  );
+}
+async function emitLineUndoCrud(ctx, action, line) {
+  const dataEngine = ctx.container.resolve("dataEngine");
+  await emitCrudUndoSideEffects({
+    dataEngine,
+    action,
+    entity: line,
+    identifiers: { id: line.id, organizationId: line.organizationId, tenantId: line.tenantId },
+    indexer: { entityType: E.warranty_claims.warranty_claim_line }
+  });
+  await invalidateCrudCache(
+    ctx.container,
+    "warranty_claims.claim_line",
+    { id: line.id, organizationId: line.organizationId, tenantId: line.tenantId },
+    ctx.auth?.tenantId ?? null,
+    `warranty_claims.claim_line.undo.${action}`
+  );
+}
+function buildLineLog(actionLabel, resourceId, snapshots) {
+  const after = snapshots.after;
+  const before = snapshots.before;
+  return {
+    actionLabel,
+    resourceKind: WARRANTY_CLAIM_LINE_RESOURCE_KIND,
+    resourceId,
+    parentResourceKind: WARRANTY_CLAIM_RESOURCE_KIND,
+    parentResourceId: after?.claimId ?? before?.claimId ?? null,
+    tenantId: after?.tenantId ?? before?.tenantId ?? null,
+    organizationId: after?.organizationId ?? before?.organizationId ?? null,
+    snapshotBefore: before ?? null,
+    snapshotAfter: after ?? null,
+    payload: { undo: { before: before ?? null, after: after ?? null } }
+  };
+}
+const createClaimLineCommand = {
+  id: "warranty_claims.claim_line.create",
+  isUndoable: true,
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(claimLineCreateSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    const claim = await requireScopedClaim(em, input.claimId, scope);
+    assertDispositionAllowedForType(claim.claimType, input.disposition ?? null);
+    await enforceWarrantyClaimOptimisticLock(ctx, claim);
+    assertParentMutable(claim);
+    if (input.orderLineId) {
+      await validateClaimReferences(ctx, scope, {
+        lineOrderRefs: [{ orderLineId: input.orderLineId, orderId: claim.orderId ?? null }]
+      });
+    }
+    let line;
+    let nextLineNo = input.lineNo ?? 1;
+    await withAtomicFlush(em, [
+      async () => {
+        await requireScopedClaim(em, claim.id, scope, { lockMode: LockMode.PESSIMISTIC_WRITE });
+        const existingLines = await findWithDecryption(
+          em,
+          WarrantyClaimLine,
+          {
+            claim: claim.id,
+            tenantId: scope.tenantId,
+            organizationId: scope.organizationId,
+            deletedAt: null
+          },
+          {},
+          scope
+        );
+        if (input.orderLineId) {
+          await assertPendingClaimQuantitiesWithinSold(em, scope, /* @__PURE__ */ new Map([[input.orderLineId, [{
+            orderLineId: input.orderLineId,
+            qtyClaimed: amountString(input.qtyClaimed, "1") ?? "1"
+          }]]]), { currentClaimId: claim.id });
+        }
+        nextLineNo = input.lineNo ?? existingLines.reduce((max, entry) => Math.max(max, entry.lineNo), 0) + 1;
+      },
+      () => {
+        line = em.create(WarrantyClaimLine, buildLineCreateData(claim, input, nextLineNo));
+        assertLineQuantities(line);
+        em.persist(line);
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.create" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineCrud(ctx, "created", line);
+    return { lineId: line.id, claimId: claim.id };
+  },
+  captureAfter: async (rawInput, result, ctx) => {
+    const input = parseCommandInput(claimLineCreateSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return loadLineSnapshot(em, result.lineId, scope);
+  },
+  buildLog: async ({ result, snapshots }) => buildLineLog("warranty_claims.audit.claim_line.create", result.lineId, snapshots),
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const scope = { tenantId: after.tenantId, organizationId: after.organizationId };
+    const em = ctx.container.resolve("em").fork();
+    const line = await findOneWithDecryption(em, WarrantyClaimLine, { id: after.id, tenantId: scope.tenantId, organizationId: scope.organizationId }, { populate: ["claim"] }, scope);
+    const claim = line ? claimOf(line) : null;
+    if (!line || !claim) return;
+    await withAtomicFlush(em, [
+      () => {
+        line.deletedAt = /* @__PURE__ */ new Date();
+        line.updatedAt = /* @__PURE__ */ new Date();
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.create.undo" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineUndoCrud(ctx, "deleted", line);
+  }
+};
+const updateClaimLineCommand = {
+  id: "warranty_claims.claim_line.update",
+  isUndoable: true,
+  prepare: async (rawInput, ctx) => {
+    const input = parseCommandInput(claimLineUpdateSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return { before: await loadLineSnapshot(em, input.id, scope) };
+  },
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(claimLineUpdateSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    const line = await requireScopedLine(em, input.id, scope);
+    const claim = claimOf(line) ?? await requireScopedClaim(em, input.claimId ?? claimIdOf(line), scope);
+    if (input.claimId && input.claimId !== claim.id) {
+      throw new CrudHttpError(400, { error: "warranty_claims.errors.notFound" });
+    }
+    assertParentMutable(claim);
+    await enforceWarrantyClaimOptimisticLock(ctx, line, WARRANTY_CLAIM_LINE_RESOURCE_KIND);
+    if (hasOwn(input, "orderLineId") && input.orderLineId && (input.orderLineId ?? null) !== (line.orderLineId ?? null)) {
+      await validateClaimReferences(ctx, scope, {
+        lineOrderRefs: [{ orderLineId: input.orderLineId, orderId: claim.orderId ?? null }]
+      });
+    }
+    if (hasOwn(input, "disposition")) {
+      assertDispositionAllowedForType(claim.claimType, input.disposition ?? null);
+      assertDispositionAllowedForGrade(toConditionGrade(line.conditionGrade), input.disposition ?? null);
+    }
+    const guardsClaimedQty = hasOwn(input, "qtyClaimed") || hasOwn(input, "orderLineId");
+    await withAtomicFlush(em, [
+      async () => {
+        if (!guardsClaimedQty) return;
+        await requireScopedClaim(em, claim.id, scope, { lockMode: LockMode.PESSIMISTIC_WRITE });
+        const orderLineId = hasOwn(input, "orderLineId") ? input.orderLineId ?? null : line.orderLineId ?? null;
+        if (orderLineId) {
+          await assertPendingClaimQuantitiesWithinSold(
+            em,
+            scope,
+            /* @__PURE__ */ new Map([[orderLineId, [{
+              id: line.id,
+              orderLineId,
+              qtyClaimed: hasOwn(input, "qtyClaimed") ? amountString(input.qtyClaimed, "1") ?? "1" : line.qtyClaimed
+            }]]]),
+            { currentClaimId: claim.id, excludedLineIds: /* @__PURE__ */ new Set([line.id]) }
+          );
+        }
+      },
+      () => {
+        applyLineUpdate(line, input);
+        assertLineQuantities(line);
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.update" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineCrud(ctx, "updated", line);
+    return { lineId: line.id, claimId: claim.id };
+  },
+  captureAfter: async (rawInput, result, ctx) => {
+    const input = parseCommandInput(claimLineUpdateSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return loadLineSnapshot(em, result.lineId, scope);
+  },
+  buildLog: async ({ result, snapshots }) => buildLineLog("warranty_claims.audit.claim_line.update", result.lineId, snapshots),
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const em = ctx.container.resolve("em").fork();
+    const line = await findOneWithDecryption(em, WarrantyClaimLine, { id: before.id, tenantId: scope.tenantId, organizationId: scope.organizationId }, { populate: ["claim"] }, scope);
+    if (!line) return;
+    const claim = claimOf(line) ?? await requireScopedClaim(em, before.claimId, scope);
+    await withAtomicFlush(em, [
+      () => restoreLineFromSnapshot(line, before),
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.update.undo" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineUndoCrud(ctx, "updated", line);
+  }
+};
+const deleteClaimLineCommand = {
+  id: "warranty_claims.claim_line.delete",
+  isUndoable: true,
+  prepare: async (rawInput, ctx) => {
+    const input = parseCommandInput(lineDeleteSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return { before: await loadLineSnapshot(em, input.id, scope) };
+  },
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(lineDeleteSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    const line = await requireScopedLine(em, input.id, scope);
+    const claim = claimOf(line) ?? await requireScopedClaim(em, input.claimId ?? claimIdOf(line), scope);
+    if (input.claimId && input.claimId !== claim.id) {
+      throw new CrudHttpError(400, { error: "warranty_claims.errors.notFound" });
+    }
+    assertParentMutable(claim);
+    await enforceWarrantyClaimOptimisticLock(ctx, line, WARRANTY_CLAIM_LINE_RESOURCE_KIND);
+    await withAtomicFlush(em, [
+      () => {
+        line.deletedAt = /* @__PURE__ */ new Date();
+        line.updatedAt = /* @__PURE__ */ new Date();
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.delete" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineCrud(ctx, "deleted", line);
+    return { lineId: line.id, claimId: claim.id };
+  },
+  captureAfter: async (rawInput, result, ctx) => {
+    const input = parseCommandInput(lineDeleteSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return loadLineSnapshot(em, result.lineId, scope);
+  },
+  buildLog: async ({ result, snapshots }) => buildLineLog("warranty_claims.audit.claim_line.delete", result.lineId, snapshots),
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const em = ctx.container.resolve("em").fork();
+    let line = await findOneWithDecryption(em, WarrantyClaimLine, { id: before.id, tenantId: scope.tenantId, organizationId: scope.organizationId }, { populate: ["claim"] }, scope);
+    const claim = (line ? claimOf(line) : null) ?? await requireScopedClaim(em, before.claimId, scope);
+    await withAtomicFlush(em, [
+      () => {
+        if (!line) {
+          line = em.create(WarrantyClaimLine, {
+            id: before.id,
+            claim,
+            organizationId: before.organizationId,
+            tenantId: before.tenantId,
+            lineNo: before.lineNo,
+            qtyClaimed: before.qtyClaimed,
+            lineStatus: before.lineStatus,
+            warrantyStatus: before.warrantyStatus,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+          em.persist(line);
+        }
+        restoreLineFromSnapshot(line, before);
+        line.deletedAt = null;
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.delete.undo" });
+    if (!line) return;
+    await emitClaimUpdated(ctx, claim);
+    await emitLineUndoCrud(ctx, "created", line);
+  }
+};
+const receiveClaimLineCommand = {
+  id: "warranty_claims.claim_line.receive",
+  isUndoable: true,
+  prepare: async (rawInput, ctx) => {
+    const input = parseCommandInput(claimLineReceiveSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return { before: await loadLineSnapshot(em, input.id, scope) };
+  },
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(claimLineReceiveSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    const line = await requireScopedLine(em, input.id, scope);
+    const claim = await requireScopedClaim(em, claimIdOf(line), scope);
+    assertReceivingStatus(claim);
+    await enforceWarrantyClaimOptimisticLock(ctx, line, WARRANTY_CLAIM_LINE_RESOURCE_KIND, input.updatedAt ?? void 0);
+    const grade = input.conditionGrade;
+    const effectiveSettings = await resolveEffectiveWarrantyClaimSettings(em, scope);
+    const shouldQuarantine = Boolean(effectiveSettings.quarantineGrades?.includes(grade));
+    await withAtomicFlush(em, [
+      () => {
+        line.conditionGrade = grade;
+        if (input.inspectionNotes !== void 0) line.inspectionNotes = input.inspectionNotes ?? null;
+        const suggestedDisposition = suggestedDispositionForGrade(grade);
+        if (!line.disposition && suggestedDisposition) {
+          assertDispositionAllowedForGrade(grade, suggestedDisposition);
+          if (suggestedDisposition === "restock" || suggestedDisposition === "repair" || suggestedDisposition === "scrap") {
+            line.disposition = suggestedDisposition;
+          }
+        }
+        assertDispositionAllowedForGrade(grade, line.disposition ?? null);
+        if (shouldQuarantine) line.quarantineStatus = "held";
+        line.updatedAt = /* @__PURE__ */ new Date();
+        appendClaimEvent(em, claim, "system", {
+          visibility: "internal",
+          payload: {
+            action: "line_received",
+            lineId: line.id,
+            conditionGrade: grade,
+            disposition: line.disposition ?? null,
+            quarantineStatus: line.quarantineStatus,
+            quarantineHeld: shouldQuarantine
+          },
+          actorUserId: ctx.auth?.sub ?? null
+        });
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.receive" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineCrud(ctx, "updated", line);
+    if (shouldQuarantine) {
+      await emitWarrantyClaimsEvent("warranty_claims.claim_line.quarantined", {
+        id: line.id,
+        claimId: claim.id,
+        lineId: line.id,
+        grade,
+        scope,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId
+      }, {
+        persistent: true,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId
+      });
+    }
+    return { lineId: line.id, claimId: claim.id };
+  },
+  captureAfter: async (rawInput, result, ctx) => {
+    const input = parseCommandInput(claimLineReceiveSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return loadLineSnapshot(em, result.lineId, scope);
+  },
+  buildLog: async ({ result, snapshots }) => buildLineLog("warranty_claims.audit.claim_line.receive", result.lineId, snapshots),
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const em = ctx.container.resolve("em").fork();
+    const line = await findOneWithDecryption(em, WarrantyClaimLine, { id: before.id, tenantId: scope.tenantId, organizationId: scope.organizationId }, { populate: ["claim"] }, scope);
+    if (!line) return;
+    const claim = await requireScopedClaim(em, before.claimId, scope);
+    await withAtomicFlush(em, [
+      () => restoreLineFromSnapshot(line, before),
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.receive.undo" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineUndoCrud(ctx, "updated", line);
+  }
+};
+const releaseClaimLineQuarantineCommand = {
+  id: "warranty_claims.claim_line.release_quarantine",
+  isUndoable: true,
+  prepare: async (rawInput, ctx) => {
+    const input = parseCommandInput(claimLineReleaseQuarantineSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return { before: await loadLineSnapshot(em, input.id, scope) };
+  },
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(claimLineReleaseQuarantineSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    const line = await requireScopedLine(em, input.id, scope);
+    const claim = await requireScopedClaim(em, claimIdOf(line), scope);
+    assertReceivingStatus(claim);
+    await enforceWarrantyClaimOptimisticLock(ctx, line, WARRANTY_CLAIM_LINE_RESOURCE_KIND, input.updatedAt ?? void 0);
+    await withAtomicFlush(em, [
+      () => {
+        line.quarantineStatus = "released";
+        line.updatedAt = /* @__PURE__ */ new Date();
+        appendClaimEvent(em, claim, "system", {
+          visibility: "internal",
+          payload: {
+            action: "line_quarantine_released",
+            lineId: line.id,
+            quarantineStatus: line.quarantineStatus
+          },
+          actorUserId: ctx.auth?.sub ?? null
+        });
+      },
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.release_quarantine" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineCrud(ctx, "updated", line);
+    return { lineId: line.id, claimId: claim.id };
+  },
+  captureAfter: async (rawInput, result, ctx) => {
+    const input = parseCommandInput(claimLineReleaseQuarantineSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return loadLineSnapshot(em, result.lineId, scope);
+  },
+  buildLog: async ({ result, snapshots }) => buildLineLog("warranty_claims.audit.claim_line.release_quarantine", result.lineId, snapshots),
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const em = ctx.container.resolve("em").fork();
+    const line = await findOneWithDecryption(em, WarrantyClaimLine, { id: before.id, tenantId: scope.tenantId, organizationId: scope.organizationId }, { populate: ["claim"] }, scope);
+    if (!line) return;
+    const claim = await requireScopedClaim(em, before.claimId, scope);
+    await withAtomicFlush(em, [
+      () => restoreLineFromSnapshot(line, before),
+      () => recomputeClaimRollups(em, claim)
+    ], { transaction: true, label: "warranty_claims.claim_line.release_quarantine.undo" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineUndoCrud(ctx, "updated", line);
+  }
+};
+const setClaimLineAssessmentCommand = {
+  id: "warranty_claims.claim_line.set_assessment",
+  isUndoable: true,
+  prepare: async (rawInput, ctx) => {
+    const input = parseCommandInput(lineSetAssessmentSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return { before: await loadLineSnapshot(em, input.id, scope) };
+  },
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(lineSetAssessmentSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    const line = await requireScopedLine(em, input.id, scope);
+    const claim = claimOf(line) ?? await requireScopedClaim(em, claimIdOf(line), scope);
+    assertParentMutable(claim);
+    await enforceWarrantyClaimOptimisticLock(ctx, line, WARRANTY_CLAIM_LINE_RESOURCE_KIND, input.updatedAt ?? void 0);
+    await withAtomicFlush(em, [
+      () => {
+        line.assessmentPayload = input.assessmentPayload;
+        line.updatedAt = /* @__PURE__ */ new Date();
+        claim.updatedAt = /* @__PURE__ */ new Date();
+        appendClaimEvent(em, claim, "system", {
+          visibility: "internal",
+          payload: {
+            action: "ai_assessment_recorded",
+            lineId: line.id
+          },
+          actorUserId: ctx.auth?.sub ?? null
+        });
+      }
+    ], { transaction: true, label: "warranty_claims.claim_line.set_assessment" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineCrud(ctx, "updated", line);
+    return { lineId: line.id, claimId: claim.id };
+  },
+  captureAfter: async (rawInput, result, ctx) => {
+    const input = parseCommandInput(lineSetAssessmentSchema, rawInput);
+    const scope = resolveScope(ctx, input);
+    const em = ctx.container.resolve("em").fork();
+    return loadLineSnapshot(em, result.lineId, scope);
+  },
+  buildLog: async ({ result, snapshots }) => buildLineLog("warranty_claims.audit.claim_line.set_assessment", result.lineId, snapshots),
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const em = ctx.container.resolve("em").fork();
+    const line = await findOneWithDecryption(em, WarrantyClaimLine, { id: before.id, tenantId: scope.tenantId, organizationId: scope.organizationId }, { populate: ["claim"] }, scope);
+    if (!line) return;
+    const claim = claimOf(line) ?? await requireScopedClaim(em, before.claimId, scope);
+    await withAtomicFlush(em, [
+      () => restoreLineFromSnapshot(line, before)
+    ], { transaction: true, label: "warranty_claims.claim_line.set_assessment.undo" });
+    await emitClaimUpdated(ctx, claim);
+    await emitLineUndoCrud(ctx, "updated", line);
+  }
+};
+registerCommand(createClaimLineCommand);
+registerCommand(updateClaimLineCommand);
+registerCommand(deleteClaimLineCommand);
+registerCommand(receiveClaimLineCommand);
+registerCommand(releaseClaimLineQuarantineCommand);
+registerCommand(setClaimLineAssessmentCommand);
+const claimLineCommands = [
+  createClaimLineCommand,
+  updateClaimLineCommand,
+  deleteClaimLineCommand,
+  receiveClaimLineCommand,
+  releaseClaimLineQuarantineCommand,
+  setClaimLineAssessmentCommand
+];
+export {
+  claimLineCommands,
+  createClaimLineCommand,
+  deleteClaimLineCommand,
+  receiveClaimLineCommand,
+  releaseClaimLineQuarantineCommand,
+  setClaimLineAssessmentCommand,
+  updateClaimLineCommand
+};
+//# sourceMappingURL=claim-lines.js.map