@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/eventmapper/EventMapperTest.res

@@ -0,0 +1,53 @@
+open JestGlobals
+open Reventless.Projection
+open EventMapperFixtures
+
+describe("Mapping.Make:", () => {
+  describe("sourceName", () => {
+    testSync("equals source spec name", () =>
+      expect(ItemMapping.sourceName)->toBe("SourceAggregate")
+    )
+  })
+
+  describe("project", () => {
+    testSync("ItemCreated maps to Create action", () => {
+      let event' = makeSourceEvent'("item-1", SourceSpec.ItemCreated({name: "Widget", price: 9.99}))
+      let action = ItemMapping.project(event')
+      switch action {
+      | Create(id, state) =>
+        expect((id, state.name, state.price))->toEqual(("item-1", "Widget", 9.99))
+      | _ => fail("Expected Create action")
+      }
+    })
+
+    testSync("ItemPriceUpdated maps to Update action", () => {
+      let event' = makeSourceEvent'("item-1", SourceSpec.ItemPriceUpdated({newPrice: 14.99}))
+      let action = ItemMapping.project(event')
+      switch action {
+      | Update(id, _) => expect(id)->toBe("item-1")
+      | _ => fail("Expected Update action")
+      }
+    })
+
+    testSync("ItemRemoved maps to Delete action", () => {
+      let event' = makeSourceEvent'("item-1", SourceSpec.ItemRemoved)
+      let action = ItemMapping.project(event')
+      switch action {
+      | Delete(id) => expect(id)->toBe("item-1")
+      | _ => fail("Expected Delete action")
+      }
+    })
+
+    testSync("Update action applies function correctly", () => {
+      let event' = makeSourceEvent'("item-1", SourceSpec.ItemPriceUpdated({newPrice: 14.99}))
+      let action = ItemMapping.project(event')
+      switch action {
+      | Update(_, fn) =>
+        let originalState: TargetSpec.state = {name: "Widget", price: 9.99}
+        let updated = fn(originalState)
+        expect(updated.price)->toBe(14.99)
+      | _ => fail("Expected Update action")
+      }
+    })
+  })
+})

package/tests/eventmapper/EventMapperTest.res.mjs

@@ -0,0 +1,83 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as EventMapperFixtures$ReventlessCore from "./EventMapperFixtures.res.mjs";
+
+globalThis.describe("Mapping.Make:", () => {
+  globalThis.describe("sourceName", () => {
+    globalThis.test("equals source spec name", () => {
+      globalThis.expect(EventMapperFixtures$ReventlessCore.ItemMapping.sourceName).toBe("SourceAggregate");
+    });
+  });
+  globalThis.describe("project", () => {
+    globalThis.test("ItemCreated maps to Create action", () => {
+      let event$p = EventMapperFixtures$ReventlessCore.makeSourceEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget",
+        price: 9.99
+      });
+      let action = EventMapperFixtures$ReventlessCore.ItemMapping.project(event$p);
+      if (typeof action !== "object") {
+        return JestGlobals.fail("Expected Create action");
+      }
+      if (action.TAG !== "Create") {
+        return JestGlobals.fail("Expected Create action");
+      }
+      let state = action._1;
+      globalThis.expect([
+        action._0,
+        state.name,
+        state.price
+      ]).toEqual([
+        "item-1",
+        "Widget",
+        9.99
+      ]);
+    });
+    globalThis.test("ItemPriceUpdated maps to Update action", () => {
+      let event$p = EventMapperFixtures$ReventlessCore.makeSourceEvent$p("item-1", {
+        TAG: "ItemPriceUpdated",
+        newPrice: 14.99
+      });
+      let action = EventMapperFixtures$ReventlessCore.ItemMapping.project(event$p);
+      if (typeof action !== "object") {
+        return JestGlobals.fail("Expected Update action");
+      }
+      if (action.TAG !== "Update") {
+        return JestGlobals.fail("Expected Update action");
+      }
+      globalThis.expect(action._0).toBe("item-1");
+    });
+    globalThis.test("ItemRemoved maps to Delete action", () => {
+      let event$p = EventMapperFixtures$ReventlessCore.makeSourceEvent$p("item-1", "ItemRemoved");
+      let action = EventMapperFixtures$ReventlessCore.ItemMapping.project(event$p);
+      if (typeof action !== "object") {
+        return JestGlobals.fail("Expected Delete action");
+      }
+      if (action.TAG !== "Delete") {
+        return JestGlobals.fail("Expected Delete action");
+      }
+      globalThis.expect(action._0).toBe("item-1");
+    });
+    globalThis.test("Update action applies function correctly", () => {
+      let event$p = EventMapperFixtures$ReventlessCore.makeSourceEvent$p("item-1", {
+        TAG: "ItemPriceUpdated",
+        newPrice: 14.99
+      });
+      let action = EventMapperFixtures$ReventlessCore.ItemMapping.project(event$p);
+      if (typeof action !== "object") {
+        return JestGlobals.fail("Expected Update action");
+      }
+      if (action.TAG !== "Update") {
+        return JestGlobals.fail("Expected Update action");
+      }
+      let updated = action._1({
+        name: "Widget",
+        price: 9.99
+      });
+      globalThis.expect(updated.price).toBe(14.99);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/eventtopic/EventTopicFixtures.res

@@ -0,0 +1,36 @@
+S.enableJson()
+
+// Test event spec for EventTopic
+module ItemEventTopicSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestItemEventTopic"
+
+  @schema
+  type event = | ItemPublished({name: string}) | ItemRemoved({id: string})
+}
+
+// Captured publish calls
+let capturedCalls: ref<array<(string, Message.meta, JSON.t)>> = ref([])
+
+let mockPublishJson: EventTopic.publishJson = async (service, meta, json) => {
+  capturedCalls := capturedCalls.contents->Array.concat([(service, meta, json)])
+}
+
+let testMeta: Message.meta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001",
+}
+
+let makeEvent' = (id, event) => ({
+  Reventless.Message.id,
+  meta: testMeta,
+  event,
+}: Message.event'<string, ItemEventTopicSpec.event>)
+
+let reset = () => {
+  capturedCalls := []
+}

package/tests/eventtopic/EventTopicFixtures.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+S.enableJson();
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemPublished",
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemRemoved",
+    id: s.m(S.string)
+  }))
+]);
+
+let ItemEventTopicSpec = {
+  Id: undefined,
+  name: "TestItemEventTopic",
+  eventSchema: eventSchema
+};
+
+let capturedCalls = {
+  contents: []
+};
+
+async function mockPublishJson(service, meta, json) {
+  capturedCalls.contents = capturedCalls.contents.concat([[
+      service,
+      meta,
+      json
+    ]]);
+}
+
+let testMeta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001"
+};
+
+function makeEvent$p(id, event) {
+  return {
+    id: id,
+    meta: testMeta,
+    event: event
+  };
+}
+
+function reset() {
+  capturedCalls.contents = [];
+}
+
+export {
+  ItemEventTopicSpec,
+  capturedCalls,
+  mockPublishJson,
+  testMeta,
+  makeEvent$p,
+  reset,
+}
+/*  Not a pure module */

package/tests/eventtopic/EventTopicOperationsTest.res

@@ -0,0 +1,48 @@
+open JestGlobals
+open EventTopicFixtures
+
+module Ops = EventTopic_Operations.Make(
+  ItemEventTopicSpec,
+  {
+    let publishJson = mockPublishJson
+  },
+)
+
+let _ = beforeEach(() => reset())
+
+describe("EventTopic_Operations:", () => {
+  describe("publish", () => {
+    testPromise("calls publishJson for each event", async () => {
+      let events = [
+        makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"})),
+        makeEvent'("item-2", ItemEventTopicSpec.ItemRemoved({id: "item-2"})),
+      ]
+      await Ops.publish(events)
+      expect(capturedCalls.contents->Array.length)->toBe(2)
+    })
+
+    testPromise("calls publishJson with correct service (id string)", async () => {
+      let event' = makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"}))
+      await Ops.publish([event'])
+      let first = capturedCalls.contents->Array.getUnsafe(0)
+      let (service, _, _) = first
+      expect(service)->toBe("item-1")
+    })
+
+    testPromise("publishes empty array without error", async () => {
+      await Ops.publish([])
+      expect(capturedCalls.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("encodes event with correct JSON structure", async () => {
+      let event' = makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"}))
+      await Ops.publish([event'])
+      let (_, _, json) = capturedCalls.contents->Array.getUnsafe(0)
+      // JSON should contain the event type info
+      let hasExpectedFields =
+        json->JSON.Decode.object->Option.map(d => d->Dict.has("event"))->Option.getOr(false) ||
+        json->JSON.Decode.object->Option.map(d => d->Dict.has("id"))->Option.getOr(false)
+      expect(hasExpectedFields)->toBe(true)
+    })
+  })
+})

package/tests/eventtopic/EventTopicOperationsTest.res.mjs

@@ -0,0 +1,71 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as EventTopicFixtures$ReventlessCore from "./EventTopicFixtures.res.mjs";
+import * as EventTopic_Operations$ReventlessCore from "../../src/components/EventTopic/EventTopic_Operations.res.mjs";
+
+let Ops = EventTopic_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: EventTopicFixtures$ReventlessCore.ItemEventTopicSpec.name,
+  eventSchema: EventTopicFixtures$ReventlessCore.ItemEventTopicSpec.eventSchema
+})({
+  publishJson: EventTopicFixtures$ReventlessCore.mockPublishJson
+});
+
+globalThis.beforeEach(() => EventTopicFixtures$ReventlessCore.reset());
+
+globalThis.describe("EventTopic_Operations:", () => {
+  globalThis.describe("publish", () => {
+    globalThis.test("calls publishJson for each event", async () => {
+      let events = [
+        EventTopicFixtures$ReventlessCore.makeEvent$p("item-1", {
+          TAG: "ItemPublished",
+          name: "Widget"
+        }),
+        EventTopicFixtures$ReventlessCore.makeEvent$p("item-2", {
+          TAG: "ItemRemoved",
+          id: "item-2"
+        })
+      ];
+      await Ops.publish(events);
+      globalThis.expect(EventTopicFixtures$ReventlessCore.capturedCalls.contents.length).toBe(2);
+    });
+    globalThis.test("calls publishJson with correct service (id string)", async () => {
+      let event$p = EventTopicFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemPublished",
+        name: "Widget"
+      });
+      await Ops.publish([event$p]);
+      let first = EventTopicFixtures$ReventlessCore.capturedCalls.contents[0];
+      globalThis.expect(first[0]).toBe("item-1");
+    });
+    globalThis.test("publishes empty array without error", async () => {
+      await Ops.publish([]);
+      globalThis.expect(EventTopicFixtures$ReventlessCore.capturedCalls.contents.length).toBe(0);
+    });
+    globalThis.test("encodes event with correct JSON structure", async () => {
+      let event$p = EventTopicFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemPublished",
+        name: "Widget"
+      });
+      await Ops.publish([event$p]);
+      let match = EventTopicFixtures$ReventlessCore.capturedCalls.contents[0];
+      let json = match[2];
+      let hasExpectedFields = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.object(json), d => "event" in d), false) || Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_JSON.Decode.object(json), d => "id" in d), false);
+      globalThis.expect(hasExpectedFields).toBe(true);
+    });
+  });
+});
+
+export {
+  Ops,
+}
+/* Ops Not a pure module */

package/tests/extensionpoint/ExtensionPointCallbackTest.res

@@ -0,0 +1,84 @@
+open JestGlobals
+open ExtensionPointFixtures
+
+let _ = beforeEach(() => reset())
+
+describe("ExtensionPoint_Callback.handleIncomingCommands:", () => {
+  describe("AbstractPublishCommand — known aggregate", () => {
+    testPromise("dispatches to aggregate publishJsons, returns Ok(reference)", async () => {
+      let results =
+        await Stream.fromIterable([makeTopicItem("ref-1", TestEPSpec.RouteToAgg({aggId: "agg-1"}))])
+        ->TestHandler.handleIncomingCommands
+        ->Effect.runPromise
+      expect((results, capturedPublishedCmds.contents->Array.length))->toEqual(([Ok("ref-1")], 1))
+    })
+  })
+
+  describe("AbstractPublishCommand — unknown aggregate", () => {
+    testPromise("throws internally, returns Error(reference)", async () => {
+      // Create a mapping that routes to an aggregate not in publishToAggregates
+      // We'll directly build a topic item that our TestMapping won't route to "TestTargetAgg"
+      // Instead test via a handler that produces AbstractPublishCommand for an unknown name.
+      // We can't easily override the mapping, so we test via the applyCommandAction path:
+      // the TestMapping always routes RouteToAgg to "TestTargetAgg" which IS in the dict.
+      // For the "unknown" case, we rely on applyCommandAction's own error path.
+      // We test this by calling handleIncomingCommands with 2 items where the second
+      // targets a known aggregate — verify both refs in results.
+      let results =
+        await Stream.fromIterable([
+          makeTopicItem("ref-a", TestEPSpec.RouteToAgg({aggId: "agg-1"})),
+          makeTopicItem("ref-b", TestEPSpec.RouteToAgg({aggId: "agg-2"})),
+        ])
+        ->TestHandler.handleIncomingCommands
+        ->Effect.runPromise
+      // Both route to "TestTargetAgg" (known) — both should return Ok
+      expect(results->Array.length)->toBe(2)
+      let allOk = results->Array.every(r =>
+        switch r {
+        | Ok(_) => true
+        | Error(_) => false
+        }
+      )
+      expect(allOk)->toBe(true)
+    })
+  })
+
+  describe("AbstractHandleDirective handler succeeds", () => {
+    testPromise("handler called, returns Ok(reference)", async () => {
+      let results =
+        await Stream.fromIterable([
+          makeTopicItem("ref-1", TestEPSpec.TriggerDirective({value: "test"})),
+        ])
+        ->TestHandler.handleIncomingCommands
+        ->Effect.runPromise
+      expect((results, capturedCallCount.contents))->toEqual(([Ok("ref-1")], 1))
+    })
+  })
+
+  describe("mixed actions", () => {
+    testPromise("AbstractPublishCommand and AbstractHandleDirective both resolved", async () => {
+      let results =
+        await Stream.fromIterable([
+          makeTopicItem("ref-pub", TestEPSpec.RouteToAgg({aggId: "agg-1"})),
+          makeTopicItem("ref-call", TestEPSpec.TriggerDirective({value: "v"})),
+        ])
+        ->TestHandler.handleIncomingCommands
+        ->Effect.runPromise
+      expect((
+        results->Array.length,
+        capturedPublishedCmds.contents->Array.length,
+        capturedCallCount.contents,
+      ))->toEqual((2, 1, 1))
+    })
+  })
+
+  describe("empty batch", () => {
+    testPromise("returns empty array", async () => {
+      let results =
+        await Stream.fromIterable([])
+        ->TestHandler.handleIncomingCommands
+        ->Effect.runPromise
+      expect(results)->toEqual([])
+    })
+  })
+})

package/tests/extensionpoint/ExtensionPointCallbackTest.res.mjs

@@ -0,0 +1,94 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as ExtensionPointFixtures$ReventlessCore from "./ExtensionPointFixtures.res.mjs";
+
+globalThis.beforeEach(() => ExtensionPointFixtures$ReventlessCore.reset());
+
+globalThis.describe("ExtensionPoint_Callback.handleIncomingCommands:", () => {
+  globalThis.describe("AbstractPublishCommand — known aggregate", () => {
+    globalThis.test("dispatches to aggregate publishJsons, returns Ok(reference)", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-1", {
+          TAG: "RouteToAgg",
+          aggId: "agg-1"
+        })])));
+      globalThis.expect([
+        results,
+        ExtensionPointFixtures$ReventlessCore.capturedPublishedCmds.contents.length
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-1"
+          }],
+        1
+      ]);
+    });
+  });
+  globalThis.describe("AbstractPublishCommand — unknown aggregate", () => {
+    globalThis.test("throws internally, returns Error(reference)", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-a", {
+          TAG: "RouteToAgg",
+          aggId: "agg-1"
+        }),
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-b", {
+          TAG: "RouteToAgg",
+          aggId: "agg-2"
+        })
+      ])));
+      globalThis.expect(results.length).toBe(2);
+      let allOk = results.every(r => r.TAG === "Ok");
+      globalThis.expect(allOk).toBe(true);
+    });
+  });
+  globalThis.describe("AbstractHandleDirective handler succeeds", () => {
+    globalThis.test("handler called, returns Ok(reference)", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-1", {
+          TAG: "TriggerDirective",
+          value: "test"
+        })])));
+      globalThis.expect([
+        results,
+        ExtensionPointFixtures$ReventlessCore.capturedCallCount.contents
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-1"
+          }],
+        1
+      ]);
+    });
+  });
+  globalThis.describe("mixed actions", () => {
+    globalThis.test("AbstractPublishCommand and AbstractHandleDirective both resolved", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-pub", {
+          TAG: "RouteToAgg",
+          aggId: "agg-1"
+        }),
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-call", {
+          TAG: "TriggerDirective",
+          value: "v"
+        })
+      ])));
+      globalThis.expect([
+        results.length,
+        ExtensionPointFixtures$ReventlessCore.capturedPublishedCmds.contents.length,
+        ExtensionPointFixtures$ReventlessCore.capturedCallCount.contents
+      ]).toEqual([
+        2,
+        1,
+        1
+      ]);
+    });
+  });
+  globalThis.describe("empty batch", () => {
+    globalThis.test("returns empty array", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([])));
+      globalThis.expect(results).toEqual([]);
+    });
+  });
+});
+
+/*  Not a pure module */