@open-mercato/core 0.6.8-develop.6925.1.cefa200fa4 → 0.6.8-develop.6931.1.4a1e1c786b

package/dist/modules/eudr/commands/statements.js

@@ -0,0 +1,747 @@
+import { registerCommand } from "@open-mercato/shared/lib/commands";
+import {
+  parseWithCustomFields,
+  emitCrudSideEffects,
+  emitCrudUndoSideEffects,
+  requireId,
+  setCustomFieldsIfAny,
+  snapshotsEqual
+} from "@open-mercato/shared/lib/commands/helpers";
+import { extractUndoPayload } from "@open-mercato/shared/lib/commands/undo";
+import { makeCreateRedo } from "@open-mercato/shared/lib/commands/redo";
+import { runCrudCommandWrite } from "@open-mercato/shared/lib/commands/runCrudCommandWrite";
+import { ensureOrganizationScope, ensureTenantScope } from "@open-mercato/shared/lib/commands/scope";
+import {
+  loadCustomFieldSnapshot,
+  buildCustomFieldResetMap
+} from "@open-mercato/shared/lib/commands/customFieldSnapshots";
+import { CrudHttpError } from "@open-mercato/shared/lib/crud/errors";
+import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
+import { findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { emitEudrLifecycleEvent } from "./lifecycle-events.js";
+import { E } from "../../../generated/entities.ids.generated.js";
+import { sql } from "kysely";
+import { z } from "zod";
+import {
+  EudrDueDiligenceStatement,
+  EudrEvidenceSubmission,
+  EudrMitigationAction,
+  EudrRiskAssessment
+} from "../data/entities.js";
+import {
+  EUDR_STATEMENT_STATUSES,
+  statementCreateSchema,
+  statementUpdateSchema
+} from "../data/validators.js";
+import {
+  EUDR_AMEND_GUARDED_FIELDS,
+  canTransition,
+  evaluateSubmissionGate,
+  isAmendWindowOpen
+} from "../lib/statement-lifecycle.js";
+const STATEMENT_ENTITY_ID = "eudr:eudr_due_diligence_statement";
+const scopedCommandInputSchema = z.object({
+  tenantId: z.string().uuid(),
+  organizationId: z.string().uuid()
+});
+const statementCrudIndexer = {
+  entityType: E.eudr.eudr_due_diligence_statement
+};
+const statementCrudEvents = {
+  module: "eudr",
+  entity: "due_diligence_statement",
+  persistent: true,
+  buildPayload: (emitContext) => ({
+    id: emitContext.identifiers.id,
+    entityId: emitContext.entity?.id ?? emitContext.identifiers.id,
+    organizationId: emitContext.identifiers.organizationId,
+    tenantId: emitContext.identifiers.tenantId
+  })
+};
+function parseScopedCommandInput(input) {
+  return scopedCommandInputSchema.parse(input);
+}
+function toNumericString(value) {
+  return value == null ? null : String(value);
+}
+function toDate(value) {
+  return value ? new Date(value) : null;
+}
+function statementSeedFromSnapshot(snapshot) {
+  return {
+    id: snapshot.id,
+    organizationId: snapshot.organizationId,
+    tenantId: snapshot.tenantId,
+    title: snapshot.title,
+    commodity: snapshot.commodity,
+    referenceNumber: snapshot.referenceNumber,
+    verificationNumber: snapshot.verificationNumber,
+    status: snapshot.status,
+    activityType: snapshot.activityType,
+    actorRole: snapshot.actorRole,
+    referencedStatements: snapshot.referencedStatements.map((entry) => ({ ...entry })),
+    quantityKg: snapshot.quantityKg,
+    supplementaryUnit: snapshot.supplementaryUnit,
+    supplementaryQuantity: snapshot.supplementaryQuantity,
+    orderId: snapshot.orderId,
+    submittedAt: toDate(snapshot.submittedAt),
+    referenceIssuedAt: toDate(snapshot.referenceIssuedAt),
+    orderSnapshot: snapshot.orderSnapshot,
+    notes: snapshot.notes,
+    createdAt: new Date(snapshot.createdAt),
+    updatedAt: new Date(snapshot.updatedAt),
+    deletedAt: toDate(snapshot.deletedAt)
+  };
+}
+async function loadStatementSnapshot(em, entityId) {
+  const record = await em.findOne(EudrDueDiligenceStatement, { id: entityId });
+  if (!record) return null;
+  const custom = await loadCustomFieldSnapshot(em, {
+    entityId: STATEMENT_ENTITY_ID,
+    recordId: record.id,
+    tenantId: record.tenantId,
+    organizationId: record.organizationId
+  });
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    title: record.title,
+    commodity: record.commodity,
+    referenceNumber: record.referenceNumber ?? null,
+    verificationNumber: record.verificationNumber ?? null,
+    status: record.status,
+    activityType: record.activityType ?? null,
+    actorRole: record.actorRole ?? null,
+    referencedStatements: Array.isArray(record.referencedStatements) ? record.referencedStatements.map((entry) => ({ ...entry })) : [],
+    quantityKg: record.quantityKg ?? null,
+    supplementaryUnit: record.supplementaryUnit ?? null,
+    supplementaryQuantity: record.supplementaryQuantity ?? null,
+    orderId: record.orderId ?? null,
+    submittedAt: record.submittedAt ? record.submittedAt.toISOString() : null,
+    referenceIssuedAt: record.referenceIssuedAt ? record.referenceIssuedAt.toISOString() : null,
+    orderSnapshot: record.orderSnapshot ?? null,
+    notes: record.notes ?? null,
+    createdAt: record.createdAt.toISOString(),
+    updatedAt: record.updatedAt.toISOString(),
+    deletedAt: record.deletedAt ? record.deletedAt.toISOString() : null,
+    custom: Object.keys(custom).length ? custom : null
+  };
+}
+function applyStatementUpdate(record, parsed) {
+  if (parsed.title !== void 0) record.title = parsed.title;
+  if (parsed.commodity !== void 0) record.commodity = parsed.commodity;
+  if (parsed.referenceNumber !== void 0) record.referenceNumber = parsed.referenceNumber ?? null;
+  if (parsed.verificationNumber !== void 0) record.verificationNumber = parsed.verificationNumber ?? null;
+  if (parsed.status !== void 0) record.status = parsed.status;
+  if (parsed.activityType !== void 0) record.activityType = parsed.activityType ?? null;
+  if (parsed.actorRole !== void 0) record.actorRole = parsed.actorRole ?? null;
+  if (parsed.referencedStatements !== void 0) {
+    record.referencedStatements = parsed.referencedStatements.map((entry) => ({ ...entry }));
+  }
+  if (parsed.quantityKg !== void 0) record.quantityKg = toNumericString(parsed.quantityKg);
+  if (parsed.supplementaryUnit !== void 0) record.supplementaryUnit = parsed.supplementaryUnit ?? null;
+  if (parsed.supplementaryQuantity !== void 0) record.supplementaryQuantity = toNumericString(parsed.supplementaryQuantity);
+  if (parsed.orderId !== void 0) record.orderId = parsed.orderId ?? null;
+  if (parsed.referenceIssuedAt !== void 0) record.referenceIssuedAt = parsed.referenceIssuedAt;
+  if (parsed.orderSnapshot !== void 0) record.orderSnapshot = parsed.orderSnapshot ?? null;
+  if (parsed.notes !== void 0) record.notes = parsed.notes ?? null;
+}
+function restoreStatement(record, snapshot) {
+  record.organizationId = snapshot.organizationId;
+  record.tenantId = snapshot.tenantId;
+  record.title = snapshot.title;
+  record.commodity = snapshot.commodity;
+  record.referenceNumber = snapshot.referenceNumber;
+  record.verificationNumber = snapshot.verificationNumber;
+  record.status = snapshot.status;
+  record.activityType = snapshot.activityType;
+  record.actorRole = snapshot.actorRole;
+  record.referencedStatements = snapshot.referencedStatements.map((entry) => ({ ...entry }));
+  record.quantityKg = snapshot.quantityKg;
+  record.supplementaryUnit = snapshot.supplementaryUnit;
+  record.supplementaryQuantity = snapshot.supplementaryQuantity;
+  record.orderId = snapshot.orderId;
+  record.submittedAt = toDate(snapshot.submittedAt);
+  record.referenceIssuedAt = toDate(snapshot.referenceIssuedAt);
+  record.orderSnapshot = snapshot.orderSnapshot;
+  record.notes = snapshot.notes;
+  record.createdAt = new Date(snapshot.createdAt);
+  record.updatedAt = new Date(snapshot.updatedAt);
+  record.deletedAt = toDate(snapshot.deletedAt);
+}
+async function setStatementCustomFields(dataEngine, entityId, organizationId, tenantId, values) {
+  await setCustomFieldsIfAny({
+    dataEngine,
+    entityId: STATEMENT_ENTITY_ID,
+    recordId: entityId,
+    organizationId,
+    tenantId,
+    values,
+    notify: false
+  });
+}
+const STATEMENT_STATUS_SET = new Set(EUDR_STATEMENT_STATUSES);
+const STATEMENT_UPDATE_FIELDS = [
+  "title",
+  "commodity",
+  "referenceNumber",
+  "verificationNumber",
+  "status",
+  "activityType",
+  "actorRole",
+  "referencedStatements",
+  "quantityKg",
+  "supplementaryUnit",
+  "supplementaryQuantity",
+  "orderId",
+  "referenceIssuedAt",
+  "orderSnapshot",
+  "notes"
+];
+function isStatementStatus(value) {
+  return STATEMENT_STATUS_SET.has(value);
+}
+function isNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function dateValuesEqual(left, right) {
+  const leftTime = left ? left.getTime() : null;
+  const rightTime = right ? right.getTime() : null;
+  return leftTime === rightTime;
+}
+function jsonValuesEqual(left, right) {
+  return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function numericValuesEqual(left, right) {
+  const leftNumber = left === null || left === void 0 || left === "" ? null : Number(left);
+  const rightNumber = right === null || right === void 0 || right === "" ? null : Number(right);
+  if (leftNumber === null || rightNumber === null) return leftNumber === rightNumber;
+  return Number.isFinite(leftNumber) && Number.isFinite(rightNumber) && leftNumber === rightNumber;
+}
+function referencedStatementsEqual(left, right) {
+  return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
+}
+function statementFieldChanged(record, parsed, field) {
+  switch (field) {
+    case "title":
+      return parsed.title !== void 0 && parsed.title !== record.title;
+    case "commodity":
+      return parsed.commodity !== void 0 && parsed.commodity !== record.commodity;
+    case "referenceNumber":
+      return parsed.referenceNumber !== void 0 && (parsed.referenceNumber ?? null) !== (record.referenceNumber ?? null);
+    case "verificationNumber":
+      return parsed.verificationNumber !== void 0 && (parsed.verificationNumber ?? null) !== (record.verificationNumber ?? null);
+    case "status":
+      return parsed.status !== void 0 && parsed.status !== record.status;
+    case "activityType":
+      return parsed.activityType !== void 0 && (parsed.activityType ?? null) !== (record.activityType ?? null);
+    case "actorRole":
+      return parsed.actorRole !== void 0 && (parsed.actorRole ?? null) !== (record.actorRole ?? null);
+    case "referencedStatements":
+      return parsed.referencedStatements !== void 0 && !referencedStatementsEqual(parsed.referencedStatements, record.referencedStatements);
+    case "quantityKg":
+      return parsed.quantityKg !== void 0 && !numericValuesEqual(toNumericString(parsed.quantityKg), record.quantityKg ?? null);
+    case "supplementaryUnit":
+      return parsed.supplementaryUnit !== void 0 && (parsed.supplementaryUnit ?? null) !== (record.supplementaryUnit ?? null);
+    case "supplementaryQuantity":
+      return parsed.supplementaryQuantity !== void 0 && !numericValuesEqual(toNumericString(parsed.supplementaryQuantity), record.supplementaryQuantity ?? null);
+    case "orderId":
+      return parsed.orderId !== void 0 && (parsed.orderId ?? null) !== (record.orderId ?? null);
+    case "referenceIssuedAt":
+      return parsed.referenceIssuedAt !== void 0 && !dateValuesEqual(parsed.referenceIssuedAt, record.referenceIssuedAt ?? null);
+    case "orderSnapshot":
+      return parsed.orderSnapshot !== void 0 && !jsonValuesEqual(parsed.orderSnapshot ?? null, record.orderSnapshot ?? null);
+    case "notes":
+      return parsed.notes !== void 0 && (parsed.notes ?? null) !== (record.notes ?? null);
+  }
+}
+function hasStatementFieldChanges(record, parsed) {
+  return STATEMENT_UPDATE_FIELDS.some((field) => statementFieldChanged(record, parsed, field));
+}
+function buildPatchedStatementView(record, parsed) {
+  return {
+    referenceNumber: parsed.referenceNumber !== void 0 ? parsed.referenceNumber ?? null : record.referenceNumber ?? null,
+    verificationNumber: parsed.verificationNumber !== void 0 ? parsed.verificationNumber ?? null : record.verificationNumber ?? null,
+    actorRole: parsed.actorRole !== void 0 ? parsed.actorRole ?? null : record.actorRole ?? null,
+    referencedStatements: parsed.referencedStatements !== void 0 ? parsed.referencedStatements.map((entry) => ({ ...entry })) : Array.isArray(record.referencedStatements) ? record.referencedStatements.map((entry) => ({ ...entry })) : []
+  };
+}
+function hasChangedAmendGuardedField(record, parsed) {
+  return EUDR_AMEND_GUARDED_FIELDS.some((field) => statementFieldChanged(record, parsed, field));
+}
+function hasConcernAnswers(criteria) {
+  return Object.values(criteria).some((entry) => entry.answer === "concern");
+}
+async function loadStatementSubmissionsForGate(em, record) {
+  const submissions = await findWithDecryption(
+    em,
+    EudrEvidenceSubmission,
+    {
+      statementId: record.id,
+      tenantId: record.tenantId,
+      organizationId: record.organizationId,
+      deletedAt: null
+    },
+    void 0,
+    { tenantId: record.tenantId, organizationId: record.organizationId }
+  );
+  return submissions.map((submission) => ({
+    status: submission.status,
+    completenessScore: submission.completenessScore,
+    originCountry: submission.originCountry ?? null
+  }));
+}
+async function loadLatestAssessmentForGate(em, record) {
+  const assessments = await findWithDecryption(
+    em,
+    EudrRiskAssessment,
+    {
+      statementId: record.id,
+      tenantId: record.tenantId,
+      organizationId: record.organizationId,
+      deletedAt: null
+    },
+    {
+      orderBy: { assessedAt: "desc", createdAt: "desc" },
+      limit: 1
+    },
+    { tenantId: record.tenantId, organizationId: record.organizationId }
+  );
+  const assessment = assessments[0];
+  if (!assessment) return null;
+  const completedMitigationCount = await em.count(EudrMitigationAction, {
+    riskAssessmentId: assessment.id,
+    tenantId: record.tenantId,
+    organizationId: record.organizationId,
+    status: "completed",
+    deletedAt: null
+  });
+  return {
+    conclusion: assessment.conclusion,
+    countryRisks: assessment.countryRisks.map((risk) => ({ country: risk.country, tier: risk.tier })),
+    reviewDueAt: assessment.reviewDueAt ?? null,
+    hasConcernAnswers: hasConcernAnswers(assessment.criteria),
+    hasCompletedMitigation: completedMitigationCount > 0
+  };
+}
+async function assertNoDownstreamReferences(em, record) {
+  const referenceNumber = record.referenceNumber?.trim().toUpperCase() ?? "";
+  if (!referenceNumber) return;
+  const db = em.getKysely();
+  const containment = JSON.stringify([{ referenceNumber }]);
+  const downstreamRow = await db.selectFrom("eudr_due_diligence_statements").select(sql`count(*)`.as("total")).where("tenant_id", "=", record.tenantId).where("organization_id", "=", record.organizationId).where("deleted_at", "is", null).where("id", "!=", record.id).where(sql`referenced_statements @> ${containment}::jsonb`).executeTakeFirst();
+  if (Number(downstreamRow?.total ?? 0) > 0) {
+    throw new CrudHttpError(400, { error: "eudr.errors.referencedDownstream" });
+  }
+}
+async function validateStatementUpdate(em, record, parsed, custom) {
+  if (!isStatementStatus(record.status)) {
+    throw new CrudHttpError(400, { error: "eudr.errors.invalidTransition" });
+  }
+  const requestedStatus = parsed.status;
+  const statusChanged = requestedStatus !== void 0 && requestedStatus !== record.status;
+  if (statusChanged && (!isStatementStatus(requestedStatus) || !canTransition(record.status, requestedStatus))) {
+    throw new CrudHttpError(400, { error: "eudr.errors.invalidTransition" });
+  }
+  const hasBaseChanges = hasStatementFieldChanges(record, parsed);
+  if (record.status === "archived" && (hasBaseChanges || Object.keys(custom).length > 0)) {
+    throw new CrudHttpError(400, { error: "eudr.errors.archivedReadOnly" });
+  }
+  const patched = buildPatchedStatementView(record, parsed);
+  const serverFields = {};
+  const isSubmittedToAvailable = record.status === "submitted" && requestedStatus === "available";
+  if (statusChanged) {
+    if (record.status === "draft" && requestedStatus === "submitted") {
+      const submissions = await loadStatementSubmissionsForGate(em, record);
+      const latestAssessment = await loadLatestAssessmentForGate(em, record);
+      const gate = evaluateSubmissionGate({
+        actorRole: patched.actorRole,
+        referencedStatementsCount: patched.referencedStatements.length,
+        submissions,
+        latestAssessment
+      });
+      if (!gate.allowed) {
+        throw new CrudHttpError(400, {
+          error: "eudr.errors.gateFailed",
+          details: {
+            reasons: gate.reasons.map((reason) => `eudr.gate.${reason}`)
+          }
+        });
+      }
+      serverFields.submittedAt = /* @__PURE__ */ new Date();
+    }
+    if (isSubmittedToAvailable) {
+      if (!isNonEmpty(patched.referenceNumber) || !isNonEmpty(patched.verificationNumber)) {
+        throw new CrudHttpError(400, {
+          error: "eudr.errors.referenceNumbersRequired",
+          details: {
+            reasons: ["eudr.gate.referenceNumbersRequired"]
+          }
+        });
+      }
+      const issuedAt = parsed.referenceIssuedAt ?? /* @__PURE__ */ new Date();
+      if (issuedAt.getTime() > Date.now()) {
+        throw new CrudHttpError(400, { error: "eudr.errors.referenceIssuedAtInvalid" });
+      }
+      serverFields.referenceIssuedAt = issuedAt;
+    }
+    if (record.status === "available" && requestedStatus === "withdrawn") {
+      if (!isAmendWindowOpen(record.referenceIssuedAt ?? null)) {
+        throw new CrudHttpError(400, { error: "eudr.errors.amendWindowElapsed" });
+      }
+      await assertNoDownstreamReferences(em, record);
+    }
+  }
+  if (parsed.referenceIssuedAt !== void 0 && !isSubmittedToAvailable && !dateValuesEqual(parsed.referenceIssuedAt, record.referenceIssuedAt ?? null)) {
+    throw new CrudHttpError(400, { error: "eudr.errors.referenceIssuedAtImmutable" });
+  }
+  if (record.status === "available" && !isAmendWindowOpen(record.referenceIssuedAt ?? null) && hasChangedAmendGuardedField(record, parsed)) {
+    throw new CrudHttpError(400, { error: "eudr.errors.amendWindowElapsed" });
+  }
+  return serverFields;
+}
+const createStatementCommand = {
+  id: "eudr.statements.create",
+  async execute(rawInput, ctx) {
+    const { parsed, custom } = parseWithCustomFields(statementCreateSchema, rawInput);
+    const scope = parseScopedCommandInput(rawInput);
+    ensureTenantScope(ctx, scope.tenantId);
+    ensureOrganizationScope(ctx, scope.organizationId);
+    if (parsed.status !== void 0 && parsed.status !== "draft") {
+      throw new CrudHttpError(400, { error: "eudr.errors.invalidTransition" });
+    }
+    if (parsed.referenceIssuedAt !== void 0) {
+      throw new CrudHttpError(400, { error: "eudr.errors.referenceIssuedAtImmutable" });
+    }
+    const entityManager = ctx.container.resolve("em").fork();
+    let record;
+    await runCrudCommandWrite({
+      ctx,
+      em: entityManager,
+      entityId: STATEMENT_ENTITY_ID,
+      action: "created",
+      scope,
+      customFields: custom,
+      events: statementCrudEvents,
+      indexer: statementCrudIndexer,
+      sideEffect: () => ({
+        entity: record,
+        identifiers: {
+          id: record.id,
+          organizationId: record.organizationId,
+          tenantId: record.tenantId
+        }
+      }),
+      phases: [
+        () => {
+          record = entityManager.create(EudrDueDiligenceStatement, {
+            organizationId: scope.organizationId,
+            tenantId: scope.tenantId,
+            title: parsed.title,
+            commodity: parsed.commodity,
+            referenceNumber: parsed.referenceNumber ?? null,
+            verificationNumber: parsed.verificationNumber ?? null,
+            status: parsed.status ?? "draft",
+            activityType: parsed.activityType ?? null,
+            actorRole: parsed.actorRole ?? null,
+            referencedStatements: parsed.referencedStatements ? parsed.referencedStatements.map((entry) => ({ ...entry })) : [],
+            quantityKg: toNumericString(parsed.quantityKg),
+            supplementaryUnit: parsed.supplementaryUnit ?? null,
+            supplementaryQuantity: toNumericString(parsed.supplementaryQuantity),
+            orderId: parsed.orderId ?? null,
+            referenceIssuedAt: null,
+            orderSnapshot: parsed.orderSnapshot ?? null,
+            notes: parsed.notes ?? null
+          });
+          entityManager.persist(record);
+        }
+      ]
+    });
+    return { entityId: record.id };
+  },
+  captureAfter: async (_rawInput, result, ctx) => {
+    const entityManager = ctx.container.resolve("em").fork();
+    return loadStatementSnapshot(entityManager, result.entityId);
+  },
+  buildLog: async ({ snapshots }) => {
+    const after = snapshots.after;
+    if (!after) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("eudr.audit.statements.create", "Create EUDR due diligence statement"),
+      resourceKind: "eudr.due_diligence_statement",
+      resourceId: after.id,
+      tenantId: after.tenantId,
+      organizationId: after.organizationId,
+      snapshotAfter: after,
+      payload: {
+        undo: { after }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const entityManager = ctx.container.resolve("em").fork();
+    const record = await entityManager.findOne(EudrDueDiligenceStatement, { id: after.id });
+    if (!record) return;
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await entityManager.flush();
+    const dataEngine = ctx.container.resolve("dataEngine");
+    const resetValues = buildCustomFieldResetMap(void 0, after.custom ?? void 0);
+    await setStatementCustomFields(dataEngine, after.id, after.organizationId, after.tenantId, resetValues);
+    await emitCrudUndoSideEffects({
+      dataEngine,
+      action: "deleted",
+      entity: record,
+      identifiers: {
+        id: record.id,
+        organizationId: record.organizationId,
+        tenantId: record.tenantId
+      },
+      indexer: statementCrudIndexer,
+      events: statementCrudEvents
+    });
+  },
+  redo: makeCreateRedo({
+    entityClass: EudrDueDiligenceStatement,
+    seedFromSnapshot: statementSeedFromSnapshot,
+    buildResult: (entity) => ({ entityId: entity.id }),
+    indexer: statementCrudIndexer,
+    events: statementCrudEvents,
+    afterRestore: async ({ ctx, entity, snapshot }) => {
+      if (!snapshot.custom || !Object.keys(snapshot.custom).length) return;
+      await setStatementCustomFields(
+        ctx.container.resolve("dataEngine"),
+        entity.id,
+        entity.organizationId,
+        entity.tenantId,
+        snapshot.custom
+      );
+    }
+  })
+};
+const updateStatementCommand = {
+  id: "eudr.statements.update",
+  async prepare(rawInput, ctx) {
+    const { parsed } = parseWithCustomFields(statementUpdateSchema, rawInput);
+    const entityManager = ctx.container.resolve("em").fork();
+    const snapshot = await loadStatementSnapshot(entityManager, parsed.id);
+    if (snapshot) {
+      ensureTenantScope(ctx, snapshot.tenantId);
+      ensureOrganizationScope(ctx, snapshot.organizationId);
+    }
+    return snapshot ? { before: snapshot } : {};
+  },
+  async execute(rawInput, ctx) {
+    const { parsed, custom } = parseWithCustomFields(statementUpdateSchema, rawInput);
+    const entityManager = ctx.container.resolve("em").fork();
+    const record = await entityManager.findOne(EudrDueDiligenceStatement, { id: parsed.id, deletedAt: null });
+    if (!record) throw new CrudHttpError(404, { error: "EUDR due diligence statement not found" });
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    const previousStatus = record.status;
+    await runCrudCommandWrite({
+      ctx,
+      em: entityManager,
+      entityId: STATEMENT_ENTITY_ID,
+      action: "updated",
+      scope: { tenantId: record.tenantId, organizationId: record.organizationId },
+      customFields: custom,
+      events: statementCrudEvents,
+      indexer: statementCrudIndexer,
+      sideEffect: () => ({
+        entity: record,
+        identifiers: {
+          id: record.id,
+          organizationId: record.organizationId,
+          tenantId: record.tenantId
+        }
+      }),
+      phases: [
+        async () => {
+          const serverFields = await validateStatementUpdate(entityManager, record, parsed, custom);
+          applyStatementUpdate(record, parsed);
+          if (serverFields.submittedAt !== void 0) record.submittedAt = serverFields.submittedAt;
+          if (serverFields.referenceIssuedAt !== void 0) record.referenceIssuedAt = serverFields.referenceIssuedAt;
+        }
+      ]
+    });
+    const lifecycleEventId = record.status === previousStatus ? null : previousStatus === "draft" && record.status === "submitted" ? "eudr.due_diligence_statement.submitted" : previousStatus === "submitted" && record.status === "available" ? "eudr.due_diligence_statement.reference_issued" : previousStatus === "available" && record.status === "withdrawn" ? "eudr.due_diligence_statement.withdrawn" : null;
+    if (lifecycleEventId) {
+      await emitEudrLifecycleEvent(ctx.container, lifecycleEventId, {
+        id: record.id,
+        tenantId: record.tenantId,
+        organizationId: record.organizationId,
+        title: record.title,
+        referenceNumber: record.referenceNumber ?? null
+      });
+    }
+    return { entityId: record.id, updatedAt: record.updatedAt };
+  },
+  captureAfter: async (_rawInput, result, ctx) => {
+    const entityManager = ctx.container.resolve("em").fork();
+    return loadStatementSnapshot(entityManager, result.entityId);
+  },
+  buildLog: async ({ snapshots }) => {
+    const before = snapshots.before;
+    const after = snapshots.after;
+    if (!before) return null;
+    if (after && snapshotsEqual(before, after)) return { skipLog: true };
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("eudr.audit.statements.update", "Update EUDR due diligence statement"),
+      resourceKind: "eudr.due_diligence_statement",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      snapshotAfter: after ?? null,
+      payload: {
+        undo: { before, after: after ?? null }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const entityManager = ctx.container.resolve("em").fork();
+    let record = await entityManager.findOne(EudrDueDiligenceStatement, { id: before.id });
+    if (!record) {
+      record = entityManager.create(EudrDueDiligenceStatement, statementSeedFromSnapshot(before));
+      entityManager.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreStatement(record, before);
+    }
+    await entityManager.flush();
+    const dataEngine = ctx.container.resolve("dataEngine");
+    const resetValues = buildCustomFieldResetMap(before.custom ?? void 0, payload?.after?.custom ?? void 0);
+    await setStatementCustomFields(dataEngine, before.id, before.organizationId, before.tenantId, resetValues);
+    await emitCrudUndoSideEffects({
+      dataEngine,
+      action: "updated",
+      entity: record,
+      identifiers: {
+        id: record.id,
+        organizationId: record.organizationId,
+        tenantId: record.tenantId
+      },
+      indexer: statementCrudIndexer,
+      events: statementCrudEvents
+    });
+  }
+};
+const deleteStatementCommand = {
+  id: "eudr.statements.delete",
+  async prepare(input, ctx) {
+    const entityId = requireId(input, "EUDR due diligence statement id required");
+    const entityManager = ctx.container.resolve("em").fork();
+    const snapshot = await loadStatementSnapshot(entityManager, entityId);
+    if (snapshot) {
+      ensureTenantScope(ctx, snapshot.tenantId);
+      ensureOrganizationScope(ctx, snapshot.organizationId);
+    }
+    return snapshot ? { before: snapshot } : {};
+  },
+  async execute(input, ctx) {
+    const entityId = requireId(input, "EUDR due diligence statement id required");
+    const entityManager = ctx.container.resolve("em").fork();
+    const record = await entityManager.findOne(EudrDueDiligenceStatement, { id: entityId, deletedAt: null });
+    if (!record) throw new CrudHttpError(404, { error: "EUDR due diligence statement not found" });
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    if (record.status === "archived") {
+      throw new CrudHttpError(400, { error: "eudr.errors.archivedReadOnly" });
+    }
+    if (record.status === "available") {
+      if (!isAmendWindowOpen(record.referenceIssuedAt ?? null)) {
+        throw new CrudHttpError(400, { error: "eudr.errors.amendWindowElapsed" });
+      }
+      await assertNoDownstreamReferences(entityManager, record);
+    }
+    const snapshot = await loadStatementSnapshot(entityManager, entityId);
+    record.deletedAt = /* @__PURE__ */ new Date();
+    await entityManager.flush();
+    const dataEngine = ctx.container.resolve("dataEngine");
+    if (snapshot?.custom) {
+      const resetValues = buildCustomFieldResetMap(snapshot.custom, void 0);
+      await setStatementCustomFields(dataEngine, snapshot.id, snapshot.organizationId, snapshot.tenantId, resetValues);
+    }
+    await emitCrudSideEffects({
+      dataEngine,
+      action: "deleted",
+      entity: record,
+      identifiers: {
+        id: record.id,
+        organizationId: record.organizationId,
+        tenantId: record.tenantId
+      },
+      indexer: statementCrudIndexer,
+      events: statementCrudEvents
+    });
+    return { entityId: record.id, updatedAt: record.updatedAt };
+  },
+  buildLog: async ({ snapshots }) => {
+    const before = snapshots.before;
+    if (!before) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("eudr.audit.statements.delete", "Delete EUDR due diligence statement"),
+      resourceKind: "eudr.due_diligence_statement",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      payload: {
+        undo: { before }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const entityManager = ctx.container.resolve("em").fork();
+    let record = await entityManager.findOne(EudrDueDiligenceStatement, { id: before.id });
+    if (!record) {
+      record = entityManager.create(EudrDueDiligenceStatement, statementSeedFromSnapshot(before));
+      entityManager.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreStatement(record, before);
+    }
+    await entityManager.flush();
+    const dataEngine = ctx.container.resolve("dataEngine");
+    if (before.custom) {
+      await setStatementCustomFields(dataEngine, before.id, before.organizationId, before.tenantId, before.custom);
+    }
+    await emitCrudUndoSideEffects({
+      dataEngine,
+      action: "created",
+      entity: record,
+      identifiers: {
+        id: record.id,
+        organizationId: record.organizationId,
+        tenantId: record.tenantId
+      },
+      indexer: statementCrudIndexer,
+      events: statementCrudEvents
+    });
+  }
+};
+registerCommand(createStatementCommand);
+registerCommand(updateStatementCommand);
+registerCommand(deleteStatementCommand);
+export {
+  loadLatestAssessmentForGate,
+  loadStatementSubmissionsForGate
+};
+//# sourceMappingURL=statements.js.map