@open-mercato/core 0.6.8-develop.6925.1.cefa200fa4 → 0.6.8-develop.6930.1.1e5976efc3

package/dist/modules/eudr/commands/risk-assessments.js

@@ -0,0 +1,599 @@
+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 { emitEudrLifecycleEvent } from "./lifecycle-events.js";
+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 { findOneWithDecryption, findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { E } from "../../../generated/entities.ids.generated.js";
+import { randomUUID } from "crypto";
+import { z } from "zod";
+import {
+  EudrDueDiligenceStatement,
+  EudrEvidenceSubmission,
+  EudrMitigationAction,
+  EudrRiskAssessment
+} from "../data/entities.js";
+import {
+  riskAssessmentCreateSchema,
+  riskAssessmentUpdateSchema
+} from "../data/validators.js";
+import { getCountryRiskTier } from "../lib/reference-data.js";
+const RISK_ASSESSMENT_ENTITY_ID = "eudr:eudr_risk_assessment";
+const scopedCommandInputSchema = z.object({
+  tenantId: z.string().uuid(),
+  organizationId: z.string().uuid()
+});
+const riskAssessmentCrudIndexer = {
+  entityType: E.eudr.eudr_risk_assessment
+};
+const riskAssessmentCrudEvents = {
+  module: "eudr",
+  entity: "risk_assessment",
+  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 toDate(value) {
+  return value ? new Date(value) : null;
+}
+function cloneCountryRisks(value) {
+  return value.map((risk) => ({ country: risk.country, tier: risk.tier }));
+}
+function cloneCriteria(value) {
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      {
+        answer: entry.answer,
+        ...entry.note !== void 0 ? { note: entry.note } : {}
+      }
+    ])
+  );
+}
+function defaultReviewDueAt(assessedAt) {
+  return new Date(Date.UTC(
+    assessedAt.getUTCFullYear() + 1,
+    assessedAt.getUTCMonth(),
+    assessedAt.getUTCDate()
+  ));
+}
+function assertNotFuture(date, errorKey) {
+  if (date.getTime() > Date.now()) {
+    throw new CrudHttpError(400, { error: errorKey });
+  }
+}
+function resolveActorDisplayName(ctx) {
+  const auth = ctx.auth;
+  if (!auth) return null;
+  const record = auth;
+  for (const key of ["displayName", "name", "email"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return null;
+}
+function hasConcernAnswer(criteria) {
+  return Object.values(criteria).some((entry) => entry.answer === "concern");
+}
+function computeOverallTier(countryRisks) {
+  if (countryRisks.length === 0) return "unknown";
+  const tiers = countryRisks.map((risk) => risk.tier);
+  if (tiers.includes("unknown")) return "unknown";
+  if (tiers.includes("high")) return "high";
+  const uniqueTiers = new Set(tiers);
+  if (uniqueTiers.size > 1) return "mixed";
+  return tiers[0] ?? "unknown";
+}
+async function requireStatementInScope(em, statementId, scope) {
+  const statement = await em.findOne(EudrDueDiligenceStatement, {
+    id: statementId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    deletedAt: null
+  });
+  if (!statement) throw new CrudHttpError(400, { error: "eudr.errors.statementNotFound" });
+  return statement;
+}
+async function computeRiskSummary(em, statementId, scope) {
+  const submissions = await findWithDecryption(
+    em,
+    EudrEvidenceSubmission,
+    {
+      statementId,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      deletedAt: null
+    },
+    void 0,
+    scope
+  );
+  const countries = Array.from(
+    new Set(
+      submissions.map((submission) => submission.originCountry?.trim().toUpperCase() ?? "").filter((country) => country.length > 0)
+    )
+  ).sort((left, right) => left.localeCompare(right));
+  const countryRisks = countries.map((country) => ({
+    country,
+    tier: getCountryRiskTier(country)
+  }));
+  return {
+    countryRisks,
+    overallTier: computeOverallTier(countryRisks),
+    isSimplified: countryRisks.length > 0 && countryRisks.every((risk) => risk.tier === "low")
+  };
+}
+async function assertCompletedMitigationIfRequired(em, assessmentId, scope, criteria, conclusion) {
+  if (conclusion !== "negligible" || !hasConcernAnswer(criteria)) return;
+  const completedCount = await em.count(EudrMitigationAction, {
+    riskAssessmentId: assessmentId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    status: "completed",
+    deletedAt: null
+  });
+  if (completedCount < 1) {
+    throw new CrudHttpError(400, { error: "eudr.errors.mitigationRequired" });
+  }
+}
+function riskAssessmentSeedFromSnapshot(snapshot) {
+  return {
+    id: snapshot.id,
+    organizationId: snapshot.organizationId,
+    tenantId: snapshot.tenantId,
+    statementId: snapshot.statementId,
+    countryRisks: cloneCountryRisks(snapshot.countryRisks),
+    overallTier: snapshot.overallTier,
+    criteria: cloneCriteria(snapshot.criteria),
+    conclusion: snapshot.conclusion,
+    isSimplified: snapshot.isSimplified,
+    assessedAt: new Date(snapshot.assessedAt),
+    assessedByName: snapshot.assessedByName,
+    reviewDueAt: toDate(snapshot.reviewDueAt),
+    notes: snapshot.notes,
+    createdAt: new Date(snapshot.createdAt),
+    updatedAt: new Date(snapshot.updatedAt),
+    deletedAt: toDate(snapshot.deletedAt)
+  };
+}
+async function findRiskAssessment(em, entityId, includeDeleted = true) {
+  return includeDeleted ? findOneWithDecryption(em, EudrRiskAssessment, { id: entityId }) : findOneWithDecryption(em, EudrRiskAssessment, { id: entityId, deletedAt: null });
+}
+async function loadRiskAssessmentSnapshot(em, entityId) {
+  const record = await findRiskAssessment(em, entityId);
+  if (!record) return null;
+  const custom = await loadCustomFieldSnapshot(em, {
+    entityId: RISK_ASSESSMENT_ENTITY_ID,
+    recordId: record.id,
+    tenantId: record.tenantId,
+    organizationId: record.organizationId
+  });
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    statementId: record.statementId,
+    countryRisks: cloneCountryRisks(record.countryRisks),
+    overallTier: record.overallTier,
+    criteria: cloneCriteria(record.criteria),
+    conclusion: record.conclusion,
+    isSimplified: record.isSimplified,
+    assessedAt: record.assessedAt.toISOString(),
+    assessedByName: record.assessedByName ?? null,
+    reviewDueAt: record.reviewDueAt ? record.reviewDueAt.toISOString() : 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 restoreRiskAssessment(record, snapshot) {
+  record.organizationId = snapshot.organizationId;
+  record.tenantId = snapshot.tenantId;
+  record.statementId = snapshot.statementId;
+  record.countryRisks = cloneCountryRisks(snapshot.countryRisks);
+  record.overallTier = snapshot.overallTier;
+  record.criteria = cloneCriteria(snapshot.criteria);
+  record.conclusion = snapshot.conclusion;
+  record.isSimplified = snapshot.isSimplified;
+  record.assessedAt = new Date(snapshot.assessedAt);
+  record.assessedByName = snapshot.assessedByName;
+  record.reviewDueAt = toDate(snapshot.reviewDueAt);
+  record.notes = snapshot.notes;
+  record.createdAt = new Date(snapshot.createdAt);
+  record.updatedAt = new Date(snapshot.updatedAt);
+  record.deletedAt = toDate(snapshot.deletedAt);
+}
+async function setRiskAssessmentCustomFields(dataEngine, entityId, organizationId, tenantId, values) {
+  await setCustomFieldsIfAny({
+    dataEngine,
+    entityId: RISK_ASSESSMENT_ENTITY_ID,
+    recordId: entityId,
+    organizationId,
+    tenantId,
+    values,
+    notify: false
+  });
+}
+const createRiskAssessmentCommand = {
+  id: "eudr.risk_assessments.create",
+  async execute(rawInput, ctx) {
+    const { parsed, custom } = parseWithCustomFields(riskAssessmentCreateSchema, rawInput);
+    const scope = parseScopedCommandInput(rawInput);
+    ensureTenantScope(ctx, scope.tenantId);
+    ensureOrganizationScope(ctx, scope.organizationId);
+    const entityManager = ctx.container.resolve("em").fork();
+    let record;
+    let statementTitle = "";
+    await runCrudCommandWrite({
+      ctx,
+      em: entityManager,
+      entityId: RISK_ASSESSMENT_ENTITY_ID,
+      action: "created",
+      scope,
+      customFields: custom,
+      events: riskAssessmentCrudEvents,
+      indexer: riskAssessmentCrudIndexer,
+      sideEffect: () => ({
+        entity: record,
+        identifiers: {
+          id: record.id,
+          organizationId: record.organizationId,
+          tenantId: record.tenantId
+        }
+      }),
+      phases: [
+        async () => {
+          const statement = await requireStatementInScope(entityManager, parsed.statementId, scope);
+          statementTitle = statement.title;
+          const summary = await computeRiskSummary(entityManager, parsed.statementId, scope);
+          const assessedAt = parsed.assessedAt ?? /* @__PURE__ */ new Date();
+          assertNotFuture(assessedAt, "eudr.errors.assessedAtInFuture");
+          if (parsed.conclusion === "negligible" && hasConcernAnswer(parsed.criteria)) {
+            throw new CrudHttpError(400, { error: "eudr.errors.mitigationRequired" });
+          }
+          record = entityManager.create(EudrRiskAssessment, {
+            id: randomUUID(),
+            organizationId: scope.organizationId,
+            tenantId: scope.tenantId,
+            statementId: parsed.statementId,
+            countryRisks: summary.countryRisks,
+            overallTier: summary.overallTier,
+            criteria: cloneCriteria(parsed.criteria),
+            conclusion: parsed.conclusion,
+            isSimplified: summary.isSimplified,
+            assessedAt,
+            assessedByName: resolveActorDisplayName(ctx),
+            reviewDueAt: parsed.reviewDueAt ?? defaultReviewDueAt(assessedAt),
+            notes: parsed.notes ?? null
+          });
+          entityManager.persist(record);
+        }
+      ]
+    });
+    await emitEudrLifecycleEvent(ctx.container, "eudr.risk_assessment.concluded", {
+      id: record.id,
+      tenantId: record.tenantId,
+      organizationId: record.organizationId,
+      statementId: record.statementId,
+      statementTitle,
+      conclusion: record.conclusion
+    });
+    return { entityId: record.id };
+  },
+  captureAfter: async (_rawInput, result, ctx) => {
+    const entityManager = ctx.container.resolve("em").fork();
+    return loadRiskAssessmentSnapshot(entityManager, result.entityId);
+  },
+  buildLog: async ({ snapshots }) => {
+    const after = snapshots.after;
+    if (!after) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("eudr.audit.risk_assessments.create", "Create EUDR risk assessment"),
+      resourceKind: "eudr.risk_assessment",
+      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 findRiskAssessment(entityManager, 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 setRiskAssessmentCustomFields(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: riskAssessmentCrudIndexer,
+      events: riskAssessmentCrudEvents
+    });
+  },
+  redo: makeCreateRedo({
+    entityClass: EudrRiskAssessment,
+    seedFromSnapshot: riskAssessmentSeedFromSnapshot,
+    buildResult: (entity) => ({ entityId: entity.id }),
+    indexer: riskAssessmentCrudIndexer,
+    events: riskAssessmentCrudEvents,
+    findRow: ({ em, id }) => findRiskAssessment(em, id),
+    afterRestore: async ({ ctx, entity, snapshot }) => {
+      if (!snapshot.custom || !Object.keys(snapshot.custom).length) return;
+      await setRiskAssessmentCustomFields(
+        ctx.container.resolve("dataEngine"),
+        entity.id,
+        entity.organizationId,
+        entity.tenantId,
+        snapshot.custom
+      );
+    }
+  })
+};
+const updateRiskAssessmentCommand = {
+  id: "eudr.risk_assessments.update",
+  async prepare(rawInput, ctx) {
+    const { parsed } = parseWithCustomFields(riskAssessmentUpdateSchema, rawInput);
+    const entityManager = ctx.container.resolve("em").fork();
+    const snapshot = await loadRiskAssessmentSnapshot(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(riskAssessmentUpdateSchema, rawInput);
+    const entityManager = ctx.container.resolve("em").fork();
+    const record = await findRiskAssessment(entityManager, parsed.id, false);
+    if (!record) throw new CrudHttpError(404, { error: "eudr.errors.riskAssessmentNotFound" });
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    const scope = { tenantId: record.tenantId, organizationId: record.organizationId };
+    const previousConclusion = record.conclusion;
+    let statementTitle = "";
+    await runCrudCommandWrite({
+      ctx,
+      em: entityManager,
+      entityId: RISK_ASSESSMENT_ENTITY_ID,
+      action: "updated",
+      scope,
+      customFields: custom,
+      events: riskAssessmentCrudEvents,
+      indexer: riskAssessmentCrudIndexer,
+      sideEffect: () => ({
+        entity: record,
+        identifiers: {
+          id: record.id,
+          organizationId: record.organizationId,
+          tenantId: record.tenantId
+        }
+      }),
+      phases: [
+        async () => {
+          const nextStatementId = parsed.statementId ?? record.statementId;
+          const statement = await requireStatementInScope(entityManager, nextStatementId, scope);
+          statementTitle = statement.title;
+          const summary = await computeRiskSummary(entityManager, nextStatementId, scope);
+          const nextCriteria = parsed.criteria ? cloneCriteria(parsed.criteria) : cloneCriteria(record.criteria);
+          const nextConclusion = parsed.conclusion ?? record.conclusion;
+          const nextAssessedAt = parsed.assessedAt ?? record.assessedAt;
+          assertNotFuture(nextAssessedAt, "eudr.errors.assessedAtInFuture");
+          await assertCompletedMitigationIfRequired(entityManager, record.id, scope, nextCriteria, nextConclusion);
+          record.statementId = nextStatementId;
+          record.countryRisks = summary.countryRisks;
+          record.overallTier = summary.overallTier;
+          record.criteria = nextCriteria;
+          record.conclusion = nextConclusion;
+          record.isSimplified = summary.isSimplified;
+          record.assessedAt = nextAssessedAt;
+          record.assessedByName = resolveActorDisplayName(ctx);
+          if (parsed.reviewDueAt !== void 0) {
+            record.reviewDueAt = parsed.reviewDueAt;
+          } else if (parsed.assessedAt !== void 0 || !record.reviewDueAt) {
+            record.reviewDueAt = defaultReviewDueAt(nextAssessedAt);
+          }
+          if (parsed.notes !== void 0) record.notes = parsed.notes ?? null;
+        }
+      ]
+    });
+    if (record.conclusion !== previousConclusion) {
+      await emitEudrLifecycleEvent(ctx.container, "eudr.risk_assessment.concluded", {
+        id: record.id,
+        tenantId: record.tenantId,
+        organizationId: record.organizationId,
+        statementId: record.statementId,
+        statementTitle,
+        conclusion: record.conclusion
+      });
+    }
+    return { entityId: record.id, updatedAt: record.updatedAt };
+  },
+  captureAfter: async (_rawInput, result, ctx) => {
+    const entityManager = ctx.container.resolve("em").fork();
+    return loadRiskAssessmentSnapshot(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.risk_assessments.update", "Update EUDR risk assessment"),
+      resourceKind: "eudr.risk_assessment",
+      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 findRiskAssessment(entityManager, before.id);
+    if (!record) {
+      record = entityManager.create(EudrRiskAssessment, riskAssessmentSeedFromSnapshot(before));
+      entityManager.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreRiskAssessment(record, before);
+    }
+    await entityManager.flush();
+    const dataEngine = ctx.container.resolve("dataEngine");
+    const resetValues = buildCustomFieldResetMap(before.custom ?? void 0, payload?.after?.custom ?? void 0);
+    await setRiskAssessmentCustomFields(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: riskAssessmentCrudIndexer,
+      events: riskAssessmentCrudEvents
+    });
+  }
+};
+const deleteRiskAssessmentCommand = {
+  id: "eudr.risk_assessments.delete",
+  async prepare(input, ctx) {
+    const entityId = requireId(input, "eudr.errors.riskAssessmentIdRequired");
+    const entityManager = ctx.container.resolve("em").fork();
+    const snapshot = await loadRiskAssessmentSnapshot(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.errors.riskAssessmentIdRequired");
+    const entityManager = ctx.container.resolve("em").fork();
+    const record = await findRiskAssessment(entityManager, entityId, false);
+    if (!record) throw new CrudHttpError(404, { error: "eudr.errors.riskAssessmentNotFound" });
+    ensureTenantScope(ctx, record.tenantId);
+    ensureOrganizationScope(ctx, record.organizationId);
+    const snapshot = await loadRiskAssessmentSnapshot(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 setRiskAssessmentCustomFields(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: riskAssessmentCrudIndexer,
+      events: riskAssessmentCrudEvents
+    });
+    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.risk_assessments.delete", "Delete EUDR risk assessment"),
+      resourceKind: "eudr.risk_assessment",
+      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 findRiskAssessment(entityManager, before.id);
+    if (!record) {
+      record = entityManager.create(EudrRiskAssessment, riskAssessmentSeedFromSnapshot(before));
+      entityManager.persist(record);
+    } else {
+      ensureTenantScope(ctx, before.tenantId);
+      ensureOrganizationScope(ctx, before.organizationId);
+      restoreRiskAssessment(record, before);
+    }
+    await entityManager.flush();
+    const dataEngine = ctx.container.resolve("dataEngine");
+    if (before.custom) {
+      await setRiskAssessmentCustomFields(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: riskAssessmentCrudIndexer,
+      events: riskAssessmentCrudEvents
+    });
+  }
+};
+registerCommand(createRiskAssessmentCommand);
+registerCommand(updateRiskAssessmentCommand);
+registerCommand(deleteRiskAssessmentCommand);
+//# sourceMappingURL=risk-assessments.js.map