@reventlessdev/reventless-core 3.0.0-alpha.215 → 3.0.0-alpha.217

package/tests/commandtopic/CommandOutcomeHookTest.res

@@ -0,0 +1,258 @@
+// The command-outcome hook, at the property the side-channels don't have: it fires on the
+// fire-and-forget dispatch path — no acceptedResultChannel/rejectedResultChannel is installed
+// anywhere in this file — for both write-side component kinds, carrying the owning component
+// and telling a domain rejection apart from an infrastructure failure.
+
+open JestGlobals
+
+// ── StateChangeSlice arm (the aggregate arm reuses AggregateFixtures as-is) ──
+
+let dcbMock = DcbFixtures.makeMockStorage()
+
+module TestDcbOps: DcbEventLog_Operations.Ops = {
+  let name = "TestDcbEventLog"
+  let serviceName = "TestDcbEventLog"
+  let storage = dcbMock.operations
+  let publishJson = dcbMock.mockPublishJson
+}
+
+module EventLogOps = DcbEventLog_Operations.Make(TestDcbOps)
+
+let dcbEventLog: DcbEventLog.operations = {
+  read: EventLogOps.read,
+  append: EventLogOps.append,
+  readStream: EventLogOps.readStream,
+  appendStream: EventLogOps.appendStream,
+}
+
+module SliceBehavior = {
+  type state = DcbFixtures.TestCommandSpec.state
+  let initialState = DcbFixtures.TestCommandSpec.initialState
+  let evolve = DcbFixtures.TestCommandSpec.evolve
+  let decide = DcbFixtures.TestCommandSpec.decide
+  let moduleUrl = DcbFixtures.TestCommandSpec.moduleUrl
+}
+
+module SliceHandler = StateChangeSlice_Callback.Make(DcbFixtures.TestCommandSpec, SliceBehavior)
+
+let sliceItem = (reference, command): CommandTopic.topicItem<
+  Message.command'<Reventless.Id.String.t, DcbFixtures.TestCommandSpec.command>,
+> => {
+  command: {
+    id: Reventless.Id.String.makeFromString("cmd-" ++ reference),
+    meta: DcbFixtures.testMeta,
+    command,
+  },
+  reference,
+}
+
+let runSlice = (reference, command) =>
+  SliceHandler.handleCommands(dcbEventLog, Stream.fromIterable([sliceItem(reference, command)]))
+  ->Effect.runPromise
+
+let runAgg = (~aggId="agg-1", reference, command) =>
+  Stream.fromIterable([AggregateFixtures.makeTopicItem(~aggId, reference, command)])
+  ->AggregateFixtures.TestHandler.handleCommands
+  ->Effect.runPromise
+
+// ── Capture ──
+
+let observed: ref<array<CommandTopic_Helpers.commandOutcomeReport>> = ref([])
+
+// Flattened for readable assertions: (component, reference, disposition, errorCode, eventCount).
+let seen = () =>
+  observed.contents->Array.map(r =>
+    switch r.outcome {
+    | OutcomeAccepted({eventCount}) => (r.component, r.reference, "accepted", "", eventCount)
+    | OutcomeRejected({errorCode, cause}) => (
+        r.component,
+        r.reference,
+        switch cause {
+        | DomainRejection => "rejected/domain"
+        | InfrastructureFailure => "rejected/infrastructure"
+        },
+        errorCode,
+        0,
+      )
+    }
+  )
+
+let record = () =>
+  CommandTopic_Helpers.registerCommandOutcome(r =>
+    observed := observed.contents->Array.concat([r])
+  )
+
+let _ = beforeEach(() => {
+  AggregateFixtures.mock.reset()
+  AggregateFixtures.TestHandler.resetCache()
+  dcbMock.reset()
+  SliceHandler.resetCache()
+  observed := []
+  CommandTopic_Helpers.clearCommandOutcome()
+  RuntimeExtension.reset()
+})
+
+describe("CommandTopic command-outcome hook:", () => {
+  describe("aggregate", () => {
+    testPromise("observes an accepted command with no side-channel installed", async () => {
+      record()
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
+    })
+
+    testPromise("carries the entity id of an accepted command", async () => {
+      record()
+      let _ = await runAgg(~aggId="agg-7", "ref-1", AggregateFixtures.AggSpec.Create({name: "W"}))
+
+      let entityId = switch (observed.contents->Array.getUnsafe(0)).outcome {
+      | OutcomeAccepted({entityId}) => entityId
+      | OutcomeRejected(_) => None
+      }
+      expect(entityId)->toEqual(Some("agg-7"))
+    })
+
+    testPromise("reports a decide rejection as domain, with the declared error code", async () => {
+      // Seed before registering, so only the second (rejected) Create is observed.
+      let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+      record()
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(seen())->toEqual([
+        ("TestAggregate", "ref-1", "rejected/domain", "AlreadyExists", 0),
+      ])
+    })
+
+    testPromise("reports a failed append as infrastructure, not a domain rejection", async () => {
+      record()
+      AggregateFixtures.mock.failNextAppend := true
+      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      // `decide` said Ok here — the store is what failed, and the hook has to say so.
+      expect(seen())->toEqual([
+        ("TestAggregate", "ref-1", "rejected/infrastructure", "AppendFailed", 0),
+      ])
+    })
+
+    testPromise("observes every command of a mixed batch", async () => {
+      let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+      record()
+      let _ =
+        await Stream.fromIterable([
+          AggregateFixtures.makeTopicItem("ref-1", AggregateFixtures.AggSpec.Rename({newName: "A"})),
+          AggregateFixtures.makeTopicItem("ref-2", AggregateFixtures.AggSpec.Create({name: "B"})),
+          AggregateFixtures.makeTopicItem("ref-3", AggregateFixtures.AggSpec.Rename({newName: "C"})),
+        ])
+        ->AggregateFixtures.TestHandler.handleCommands
+        ->Effect.runPromise
+
+      expect(seen())->toEqual([
+        ("TestAggregate", "ref-1", "accepted", "", 2),
+        ("TestAggregate", "ref-2", "rejected/domain", "AlreadyExists", 0),
+        ("TestAggregate", "ref-3", "accepted", "", 2),
+      ])
+    })
+  })
+
+  describe("state-change slice", () => {
+    testPromise("observes an accepted command with no side-channel installed", async () => {
+      record()
+      let _ = await runSlice(
+        "ref-1",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+      )
+
+      expect(seen())->toEqual([
+        ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "accepted", "", 1),
+      ])
+    })
+
+    testPromise("reports a decide rejection as domain, with the declared error code", async () => {
+      let _ = await runSlice(
+        "ref-seed",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+      )
+      record()
+      let _ = await runSlice(
+        "ref-1",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Again"}),
+      )
+
+      expect(seen())->toEqual([
+        (
+          "TestStateChangeSlice",
+          DcbFixtures.testMeta.msgId,
+          "rejected/domain",
+          "ItemAlreadyExists",
+          0,
+        ),
+      ])
+    })
+
+    testPromise("reports exhausted append conflicts as infrastructure", async () => {
+      record()
+      // One more failure than the retry loop can absorb.
+      dcbMock.failNextAppends := 4
+      let _ = await runSlice(
+        "ref-1",
+        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+      )
+
+      expect(seen())->toEqual([
+        ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "rejected/infrastructure", "Conflict", 0),
+      ])
+    })
+  })
+
+  describe("registration", () => {
+    testPromise("with nothing registered nothing is observed and the command is unaffected", async () => {
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
+      expect(observed.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("clearCommandOutcome stops observation", async () => {
+      record()
+      CommandTopic_Helpers.clearCommandOutcome()
+      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(observed.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("an out-of-tree extension can register it from onColdStart", async () => {
+      // The hook needs no registration path of its own: it has the shape the cold-start
+      // seam already reaches, so an extension picks it up alongside the other four.
+      module Accountant: RuntimeExtension.Extension = {
+        let moduleUrl = "file:///pkg/accountant.res.mjs"
+        let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
+          record()
+      }
+      RuntimeExtension.use(module(Accountant: RuntimeExtension.Extension))
+      RuntimeExtension.notifyColdStart(
+        ~runtimeKind=ComponentType.Aggregate,
+        ~component="AllAggregates",
+        ~plugin=Some("Catalog"),
+        ~platform=Some("Shop"),
+      )
+
+      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
+    })
+
+    testPromise("a throwing hook is swallowed and the command still succeeds", async () => {
+      CommandTopic_Helpers.registerCommandOutcome(_ =>
+        JsError.throwWithMessage("hook exploded")
+      )
+      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+      // The outcome the hook observes has already happened — an observer must not undo it.
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
+    })
+  })
+})

package/tests/commandtopic/CommandOutcomeHookTest.res.mjs

@@ -0,0 +1,372 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as DcbFixtures$ReventlessCore from "../dcb/DcbFixtures.res.mjs";
+import * as RuntimeExtension$ReventlessCore from "../../src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
+import * as AggregateFixtures$ReventlessCore from "../aggregate/AggregateFixtures.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "../../src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+import * as StateChangeSlice_Callback$ReventlessCore from "../../src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+
+let dcbMock = DcbFixtures$ReventlessCore.makeMockStorage();
+
+let storage = dcbMock.operations;
+
+let publishJson = dcbMock.mockPublishJson;
+
+let TestDcbOps = {
+  name: "TestDcbEventLog",
+  serviceName: "TestDcbEventLog",
+  storage: storage,
+  publishJson: publishJson
+};
+
+let EventLogOps = DcbEventLog_Operations$ReventlessCore.Make(TestDcbOps);
+
+let dcbEventLog_read = EventLogOps.read;
+
+let dcbEventLog_append = EventLogOps.append;
+
+let dcbEventLog_readStream = EventLogOps.readStream;
+
+let dcbEventLog_appendStream = EventLogOps.appendStream;
+
+let dcbEventLog = {
+  read: dcbEventLog_read,
+  append: dcbEventLog_append,
+  readStream: dcbEventLog_readStream,
+  appendStream: dcbEventLog_appendStream
+};
+
+let initialState = DcbFixtures$ReventlessCore.TestCommandSpec.initialState;
+
+let evolve = DcbFixtures$ReventlessCore.TestCommandSpec.evolve;
+
+let decide = DcbFixtures$ReventlessCore.TestCommandSpec.decide;
+
+let moduleUrl = DcbFixtures$ReventlessCore.TestCommandSpec.moduleUrl;
+
+let SliceBehavior = {
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl
+};
+
+let SliceHandler = StateChangeSlice_Callback$ReventlessCore.Make({
+  name: DcbFixtures$ReventlessCore.TestCommandSpec.name,
+  moduleUrl: DcbFixtures$ReventlessCore.TestCommandSpec.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.consumedEventSchema,
+  errorSchema: DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema,
+  eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,
+  commandSchema: DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema,
+  commandAuthorization: DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization,
+  readConsistency: DcbFixtures$ReventlessCore.TestCommandSpec.readConsistency
+})(SliceBehavior);
+
+function sliceItem(reference, command) {
+  return {
+    command: {
+      id: Id$Reventless.$$String.makeFromString("cmd-" + reference),
+      meta: DcbFixtures$ReventlessCore.testMeta,
+      command: command
+    },
+    reference: reference
+  };
+}
+
+function runSlice(reference, command) {
+  return Effect.runPromise(SliceHandler.handleCommands(undefined, undefined, dcbEventLog, Stream.fromIterable([sliceItem(reference, command)])));
+}
+
+function runAgg(aggIdOpt, reference, command) {
+  let aggId = aggIdOpt !== undefined ? aggIdOpt : "agg-1";
+  return Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(aggId, reference, command)])));
+}
+
+let observed = {
+  contents: []
+};
+
+function seen() {
+  return observed.contents.map(r => {
+    let match = r.outcome;
+    if (match.TAG === "OutcomeAccepted") {
+      return [
+        r.component,
+        r.reference,
+        "accepted",
+        "",
+        match.eventCount
+      ];
+    }
+    let tmp;
+    tmp = match.cause === "DomainRejection" ? "rejected/domain" : "rejected/infrastructure";
+    return [
+      r.component,
+      r.reference,
+      tmp,
+      match.errorCode,
+      0
+    ];
+  });
+}
+
+function record() {
+  CommandTopic_Helpers$ReventlessCore.registerCommandOutcome(r => {
+    observed.contents = observed.contents.concat([r]);
+  });
+}
+
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+  dcbMock.reset();
+  SliceHandler.resetCache();
+  observed.contents = [];
+  CommandTopic_Helpers$ReventlessCore.clearCommandOutcome();
+  RuntimeExtension$ReventlessCore.reset();
+});
+
+globalThis.describe("CommandTopic command-outcome hook:", () => {
+  globalThis.describe("aggregate", () => {
+    globalThis.test("observes an accepted command with no side-channel installed", async () => {
+      record();
+      let results = await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(results).toEqual([{
+          TAG: "Ok",
+          _0: "ref-1"
+        }]);
+      globalThis.expect(seen()).toEqual([[
+          "TestAggregate",
+          "ref-1",
+          "accepted",
+          "",
+          1
+        ]]);
+    });
+    globalThis.test("carries the entity id of an accepted command", async () => {
+      record();
+      await runAgg("agg-7", "ref-1", {
+        TAG: "Create",
+        name: "W"
+      });
+      let match = observed.contents[0].outcome;
+      let entityId;
+      entityId = match.TAG === "OutcomeAccepted" ? match.entityId : undefined;
+      globalThis.expect(entityId).toEqual("agg-7");
+    });
+    globalThis.test("reports a decide rejection as domain, with the declared error code", async () => {
+      await runAgg(undefined, "ref-seed", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      record();
+      let results = await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(results).toEqual([{
+          TAG: "Ok",
+          _0: "ref-1"
+        }]);
+      globalThis.expect(seen()).toEqual([[
+          "TestAggregate",
+          "ref-1",
+          "rejected/domain",
+          "AlreadyExists",
+          0
+        ]]);
+    });
+    globalThis.test("reports a failed append as infrastructure, not a domain rejection", async () => {
+      record();
+      AggregateFixtures$ReventlessCore.mock.failNextAppend.contents = true;
+      await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(seen()).toEqual([[
+          "TestAggregate",
+          "ref-1",
+          "rejected/infrastructure",
+          "AppendFailed",
+          0
+        ]]);
+    });
+    globalThis.test("observes every command of a mixed batch", async () => {
+      await runAgg(undefined, "ref-seed", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      record();
+      await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
+        AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Rename",
+          newName: "A"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-2", {
+          TAG: "Create",
+          name: "B"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-3", {
+          TAG: "Rename",
+          newName: "C"
+        })
+      ])));
+      globalThis.expect(seen()).toEqual([
+        [
+          "TestAggregate",
+          "ref-1",
+          "accepted",
+          "",
+          2
+        ],
+        [
+          "TestAggregate",
+          "ref-2",
+          "rejected/domain",
+          "AlreadyExists",
+          0
+        ],
+        [
+          "TestAggregate",
+          "ref-3",
+          "accepted",
+          "",
+          2
+        ]
+      ]);
+    });
+  });
+  globalThis.describe("state-change slice", () => {
+    globalThis.test("observes an accepted command with no side-channel installed", async () => {
+      record();
+      await runSlice("ref-1", {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      });
+      globalThis.expect(seen()).toEqual([[
+          "TestStateChangeSlice",
+          DcbFixtures$ReventlessCore.testMeta.msgId,
+          "accepted",
+          "",
+          1
+        ]]);
+    });
+    globalThis.test("reports a decide rejection as domain, with the declared error code", async () => {
+      await runSlice("ref-seed", {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      });
+      record();
+      await runSlice("ref-1", {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Again"
+      });
+      globalThis.expect(seen()).toEqual([[
+          "TestStateChangeSlice",
+          DcbFixtures$ReventlessCore.testMeta.msgId,
+          "rejected/domain",
+          "ItemAlreadyExists",
+          0
+        ]]);
+    });
+    globalThis.test("reports exhausted append conflicts as infrastructure", async () => {
+      record();
+      dcbMock.failNextAppends.contents = 4;
+      await runSlice("ref-1", {
+        TAG: "CreateItem",
+        itemId: "item-1",
+        name: "Test"
+      });
+      globalThis.expect(seen()).toEqual([[
+          "TestStateChangeSlice",
+          DcbFixtures$ReventlessCore.testMeta.msgId,
+          "rejected/infrastructure",
+          "Conflict",
+          0
+        ]]);
+    });
+  });
+  globalThis.describe("registration", () => {
+    globalThis.test("with nothing registered nothing is observed and the command is unaffected", async () => {
+      let results = await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(results).toEqual([{
+          TAG: "Ok",
+          _0: "ref-1"
+        }]);
+      globalThis.expect(AggregateFixtures$ReventlessCore.mock.getAll().length).toBe(1);
+      globalThis.expect(observed.contents.length).toBe(0);
+    });
+    globalThis.test("clearCommandOutcome stops observation", async () => {
+      record();
+      CommandTopic_Helpers$ReventlessCore.clearCommandOutcome();
+      await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(observed.contents.length).toBe(0);
+    });
+    globalThis.test("an out-of-tree extension can register it from onColdStart", async () => {
+      let onColdStart = (param, param$1, param$2, param$3) => record();
+      let Accountant = {
+        moduleUrl: "file:///pkg/accountant.res.mjs",
+        onColdStart: onColdStart
+      };
+      RuntimeExtension$ReventlessCore.use(Accountant);
+      RuntimeExtension$ReventlessCore.notifyColdStart("Aggregate", "AllAggregates", "Catalog", "Shop");
+      await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(seen()).toEqual([[
+          "TestAggregate",
+          "ref-1",
+          "accepted",
+          "",
+          1
+        ]]);
+    });
+    globalThis.test("a throwing hook is swallowed and the command still succeeds", async () => {
+      CommandTopic_Helpers$ReventlessCore.registerCommandOutcome(param => Stdlib_JsError.throwWithMessage("hook exploded"));
+      let results = await runAgg(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      });
+      globalThis.expect(results).toEqual([{
+          TAG: "Ok",
+          _0: "ref-1"
+        }]);
+      globalThis.expect(AggregateFixtures$ReventlessCore.mock.getAll().length).toBe(1);
+    });
+  });
+});
+
+export {
+  dcbMock,
+  TestDcbOps,
+  EventLogOps,
+  dcbEventLog,
+  SliceBehavior,
+  SliceHandler,
+  sliceItem,
+  runSlice,
+  runAgg,
+  observed,
+  seen,
+  record,
+}
+/* dcbMock Not a pure module */

package/tests/commandtopic/CommandTopicHelpersRejectionTest.res

@@ -26,8 +26,14 @@ describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
       ->Effect.map(items => {
         items->Array.forEach(item => {
           // Both channels report for the same reference; rejected wins.
-          CommandTopic_Helpers.reportAccepted(item.reference, {entityId: "agg-1", eventCount: 0})
+          CommandTopic_Helpers.reportAccepted(
+            ~component="TestService",
+            item.reference,
+            {entityId: "agg-1", eventCount: 0},
+          )
           CommandTopic_Helpers.reportRejected(
+            ~component="TestService",
+            ~cause=DomainRejection,
             item.reference,
             {errorCode: "AlreadyExists", errorDetail: ""},
           )
@@ -53,6 +59,8 @@ describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
       ->Effect.map(items => {
         items->Array.forEach(item =>
           CommandTopic_Helpers.reportRejected(
+            ~component="TestService",
+            ~cause=DomainRejection,
             item.reference,
             {errorCode: "BusinessRuleViolated", errorDetail: "{\"reason\":\"x\"}"},
           )

package/tests/commandtopic/CommandTopicHelpersRejectionTest.res.mjs

@@ -30,11 +30,11 @@ globalThis.describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
   globalThis.test("Rejected from rejectedResultChannel beats Accepted from acceptedResultChannel", async () => {
     let handler = stream => Effect.map(Stream.runCollect(stream), items => {
       items.forEach(item => {
-        CommandTopic_Helpers$ReventlessCore.reportAccepted(item.reference, {
+        CommandTopic_Helpers$ReventlessCore.reportAccepted("TestService", item.reference, {
           entityId: "agg-1",
           eventCount: 0
         });
-        CommandTopic_Helpers$ReventlessCore.reportRejected(item.reference, {
+        CommandTopic_Helpers$ReventlessCore.reportRejected("TestService", "DomainRejection", item.reference, {
           errorCode: "AlreadyExists",
           errorDetail: ""
         });
@@ -61,7 +61,7 @@ globalThis.describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
   });
   globalThis.test("Rejected from rejectedResultChannel beats Error result (synthesized Conflict)", async () => {
     let handler = stream => Effect.map(Stream.runCollect(stream), items => {
-      items.forEach(item => CommandTopic_Helpers$ReventlessCore.reportRejected(item.reference, {
+      items.forEach(item => CommandTopic_Helpers$ReventlessCore.reportRejected("TestService", "DomainRejection", item.reference, {
         errorCode: "BusinessRuleViolated",
         errorDetail: "{\"reason\":\"x\"}"
       }));

package/tests/message/MessageTest.res

@@ -122,6 +122,7 @@ describe("Message should", () => {
             linkedViews: [],
             consistencyRead: None,
             events: [],
+            errors: [],
             chapter: None,
           },
         ],

package/tests/message/MessageTest.res.mjs

@@ -114,6 +114,7 @@ globalThis.describe("Message should", () => {
               linkedViews: [],
               consistencyRead: undefined,
               events: [],
+              errors: [],
               chapter: undefined
             }],
           automationSlices: [],