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

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: [],

package/tests/plugin/PluginStructureTest.res

@@ -245,6 +245,33 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
       expect(shipOrder.producedEventTypes)->toEqual(["TestPlugin.OrderShipped"])
     })
+
+    // A slice's declared errors are the third family of its contract, beside the
+    // commands it accepts and the events it emits — what a caller has to handle
+    // when a decision is refused.
+    testSync("PlaceOrder: the single payload-less error variant is surfaced", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.errors->Array.map(e => e.name))->toEqual(["AlreadyPlaced"])
+    })
+
+    testSync("ShipOrder: both error variants surface, in declaration order", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.errors->Array.map(e => e.name))->toEqual(["OrderNotFound", "NotShippable"])
+    })
+
+    testSync("ShipOrder: a payload-carrying error carries its field schema", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      let notShippable =
+        shipOrder.errors->Array.find(e => e.name == "NotShippable")->Option.getOrThrow
+      expect(notShippable.schema->String.includes("\"reason\""))->toBe(true)
+    })
+
+    testSync("ShipOrder: a payload-less error carries no fields and no references", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      let notFound = shipOrder.errors->Array.find(e => e.name == "OrderNotFound")->Option.getOrThrow
+      expect((notFound.schema->String.includes("\"reason\""), notFound.references->Array.length))
+      ->toEqual((false, 0))
+    })
   })
 
   describe("stateViewSlices", () => {

package/tests/plugin/PluginStructureTest.res.mjs

@@ -398,6 +398,33 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       let shipOrder = structure.stateChangeSlices[1];
       globalThis.expect(shipOrder.producedEventTypes).toEqual(["TestPlugin.OrderShipped"]);
     });
+    globalThis.test("PlaceOrder: the single payload-less error variant is surfaced", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      globalThis.expect(placeOrder.errors.map(e => e.name)).toEqual(["AlreadyPlaced"]);
+    });
+    globalThis.test("ShipOrder: both error variants surface, in declaration order", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.errors.map(e => e.name)).toEqual([
+        "OrderNotFound",
+        "NotShippable"
+      ]);
+    });
+    globalThis.test("ShipOrder: a payload-carrying error carries its field schema", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      let notShippable = Stdlib_Option.getOrThrow(shipOrder.errors.find(e => e.name === "NotShippable"), undefined);
+      globalThis.expect(notShippable.schema.includes("\"reason\"")).toBe(true);
+    });
+    globalThis.test("ShipOrder: a payload-less error carries no fields and no references", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      let notFound = Stdlib_Option.getOrThrow(shipOrder.errors.find(e => e.name === "OrderNotFound"), undefined);
+      globalThis.expect([
+        notFound.schema.includes("\"reason\""),
+        notFound.references.length
+      ]).toEqual([
+        false,
+        0
+      ]);
+    });
   });
   globalThis.describe("stateViewSlices", () => {
     globalThis.test("produces four SVS entries in declaration order", () => {

package/tests/plugin/StateChangeSlice/PsShipOrder.res

@@ -21,8 +21,10 @@ let evolve = (_state, _event) => true
 @schema
 type command = @targetState("Shipped") ShipOrder({orderId: string}) | @noApi CancelShipment
 
+// Two variants, one payload-less and one carrying a field — the same two branches
+// `events` exercises, so the structure's `errors` list is pinned on both.
 @schema
-type error = OrderNotFound
+type error = OrderNotFound | NotShippable({reason: string})
 
 // ShipmentVoided is payload-less — excluded from producedEventTypes (DCB filter),
 // but still surfaced in `events` (toEventDef's payload-less branch).

package/tests/plugin/StateChangeSlice/PsShipOrder.res.mjs

@@ -22,7 +22,13 @@ let commandSchema = S.union([
   S.literal("CancelShipment")
 ]);
 
-let errorSchema = S.literal("OrderNotFound");
+let errorSchema = S.union([
+  S.literal("OrderNotFound"),
+  S.schema(s => ({
+    TAG: "NotShippable",
+    reason: s.m(S.string)
+  }))
+]);
 
 let eventSchema = S.union([
   S.schema(s => ({

package/tests/plugin/pluginDefinitionRequiredScalars.txt

@@ -43,6 +43,10 @@
 .structure.aggregates[].commands[].references[].fieldName: string
 .structure.aggregates[].commands[].schema: string
 .structure.aggregates[].consumedEventTypes[]: string
+.structure.aggregates[].errors[].name: string
+.structure.aggregates[].errors[].references[].entity: string
+.structure.aggregates[].errors[].references[].fieldName: string
+.structure.aggregates[].errors[].schema: string
 .structure.aggregates[].events[].name: string
 .structure.aggregates[].events[].references[].entity: string
 .structure.aggregates[].events[].references[].fieldName: string
@@ -86,6 +90,10 @@
 .structure.stateChangeSlices[].commands[].references[].fieldName: string
 .structure.stateChangeSlices[].commands[].schema: string
 .structure.stateChangeSlices[].consumedEventTypes[]: string
+.structure.stateChangeSlices[].errors[].name: string
+.structure.stateChangeSlices[].errors[].references[].entity: string
+.structure.stateChangeSlices[].errors[].references[].fieldName: string
+.structure.stateChangeSlices[].errors[].schema: string
 .structure.stateChangeSlices[].events[].name: string
 .structure.stateChangeSlices[].events[].references[].entity: string
 .structure.stateChangeSlices[].events[].references[].fieldName: string