@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/dcb/DcbEventLogOperationsTest.res

@@ -0,0 +1,195 @@
+open JestGlobals
+
+let mock = DcbFixtures.makeMockStorage()
+
+module TestOps: DcbEventLog_Operations.Ops = {
+  let name = "TestDcbEventLog"
+  let serviceName = "TestDcbEventLog"
+  let storage = mock.operations
+  let publishJson = mock.mockPublishJson
+}
+
+module Ops = DcbEventLog_Operations.Make(TestOps)
+
+// Verifies Phase 1.5 of Plan 03: the `service` carried on published events
+// comes from `serviceName`, not `name`. Plugin_Builder relies on this to align
+// `meta.service` with `allEventTopics`'s dict key.
+module TestOpsAlt: DcbEventLog_Operations.Ops = {
+  let name = "Catalog"
+  let serviceName = "CatalogDcbEventLog"
+  let storage = mock.operations
+  let publishJson = mock.mockPublishJson
+}
+module OpsAlt = DcbEventLog_Operations.Make(TestOpsAlt)
+
+let _ = beforeEach(() => mock.reset())
+
+// Helper to encode a TestEventLogSpec event to a rawEvent for testing
+let encodeEvent = (event: DcbFixtures.TestEventLogSpec.event): ReventlessInfra.DcbEventLog.rawEvent => {
+  let json = event->S.reverseConvertToJsonOrThrow(DcbFixtures.TestEventLogSpec.eventSchema)
+  let (eventType, data) = json->Message.splitMessage
+  let tags = Reventless.DcbTag.extractTags(DcbFixtures.TestEventLogSpec.eventSchema, event)
+  let meta = Message.generateMeta(~service="test")
+  {eventType, data: JSON.Object(data), tags, meta}
+}
+
+// Helper to decode a rawSequencedEvent back to a TestEventLogSpec event
+let decodeEvent = (raw: ReventlessInfra.DcbEventLog.rawSequencedEvent): DcbFixtures.TestEventLogSpec.event => {
+  let json = Message.combineMessage(
+    raw.eventType,
+    raw.data->JSON.Decode.object->Option.getOr(Dict.make()),
+  )
+  json->S.parseJsonOrThrow(DcbFixtures.TestEventLogSpec.eventSchema)
+}
+
+describe("DcbEventLog_Operations:", () => {
+  describe("round-trip (append then read)", () => {
+    testPromise("ItemCreated preserves through round-trip", async () => {
+      let event = DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})
+      let rawEvent = encodeEvent(event)
+      let _ = await Ops.append([rawEvent])
+      let result = await Ops.read(~query=[{}])
+
+      expect((
+        result.events->Array.length,
+        result.events->Array.get(0)->Option.map(se => decodeEvent(se)),
+      ))->toEqual((1, Some(event)))
+    })
+
+    testPromise("CountUpdated with int tag preserves through round-trip", async () => {
+      let event = DcbFixtures.TestEventLogSpec.CountUpdated({category: "electronics", amount: 42})
+      let rawEvent = encodeEvent(event)
+      let _ = await Ops.append([rawEvent])
+      let result = await Ops.read(~query=[{}])
+
+      expect(result.events->Array.get(0)->Option.map(se => decodeEvent(se)))->toEqual(Some(event))
+    })
+
+    testPromise("multiple events in single append all read back", async () => {
+      let events = [
+        DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"}),
+        DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"}),
+      ]
+      let rawEvents = events->Array.map(encodeEvent)
+      let _ = await Ops.append(rawEvents)
+      let result = await Ops.read(~query=[{}])
+
+      expect((
+        result.events->Array.length,
+        result.events->Array.map(se => decodeEvent(se)),
+      ))->toEqual((2, events))
+    })
+  })
+
+  describe("append", () => {
+    testPromise("stores events and publishes to event topic", async () => {
+      let event = DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})
+      let result = await Ops.append([encodeEvent(event)])
+
+      expect((
+        Result.isOk(result),
+        mock.getEvents()->Array.length,
+        mock.publishedEvents.contents->Array.length,
+      ))->toEqual((true, 1, 1))
+    })
+
+    testPromise("published events have correct service name", async () => {
+      let _ = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+      ])
+
+      expect(
+        mock.publishedEvents.contents->Array.get(0)->Option.map(pe => pe.service),
+      )->toEqual(Some("TestDcbEventLog"))
+    })
+
+    testPromise("service comes from Ops.serviceName, not Ops.name", async () => {
+      let _ = await OpsAlt.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+      ])
+
+      expect(
+        mock.publishedEvents.contents->Array.get(0)->Option.map(pe => pe.service),
+      )->toEqual(Some("CatalogDcbEventLog"))
+    })
+
+    testPromise("error from storage does not publish to event topic", async () => {
+      mock.failNextAppends := 1
+      let result = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+      ])
+
+      expect((Result.isError(result), mock.publishedEvents.contents->Array.length))->toEqual((
+        true,
+        0,
+      ))
+    })
+
+    testPromise("with condition (no conflict) succeeds", async () => {
+      let _ = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+      ])
+      let condition: Reventless.DcbTag.appendCondition = {
+        query: [{eventTypes: ["ItemCreated"], tags: [{Reventless.DcbTag.key: "itemId", value: "item-1"}]}],
+        after: "1",
+      }
+      let result = await Ops.append(
+        [encodeEvent(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Updated"}))],
+        ~condition,
+      )
+
+      expect(Result.isOk(result))->toBe(true)
+    })
+
+    testPromise("multiple events all stored and published", async () => {
+      let events = [
+        DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"}),
+        DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-2", name: "Second"}),
+      ]
+      let _ = await Ops.append(events->Array.map(encodeEvent))
+
+      expect((
+        mock.getEvents()->Array.length,
+        mock.publishedEvents.contents->Array.length,
+      ))->toEqual((2, 2))
+    })
+  })
+
+  describe("read", () => {
+    testPromise("returns headPosition from storage", async () => {
+      let _ = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+      ])
+      let result = await Ops.read(~query=[{}])
+
+      expect(result.headPosition)->toEqual(Some("1"))
+    })
+
+    testPromise("with ~after parameter filters out earlier events", async () => {
+      let _ = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"})),
+      ])
+      let _ = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"})),
+      ])
+      let result = await Ops.read(~query=[{}], ~after="1")
+
+      expect((
+        result.events->Array.length,
+        result.events->Array.get(0)->Option.map(se => decodeEvent(se)),
+      ))->toEqual((
+        1,
+        Some(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"})),
+      ))
+    })
+
+    testPromise("no matching events returns empty array", async () => {
+      let _ = await Ops.append([
+        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+      ])
+      let result = await Ops.read(~query=[{eventTypes: ["NonExistent"]}])
+
+      expect(result.events->Array.length)->toEqual(0)
+    })
+  })
+})

package/tests/dcb/DcbEventLogOperationsTest.res.mjs

@@ -0,0 +1,268 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as DcbFixtures$ReventlessCore from "./DcbFixtures.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "../../src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+
+let mock = DcbFixtures$ReventlessCore.makeMockStorage();
+
+let storage = mock.operations;
+
+let publishJson = mock.mockPublishJson;
+
+let TestOps = {
+  name: "TestDcbEventLog",
+  serviceName: "TestDcbEventLog",
+  storage: storage,
+  publishJson: publishJson
+};
+
+let Ops = DcbEventLog_Operations$ReventlessCore.Make(TestOps);
+
+let storage$1 = mock.operations;
+
+let publishJson$1 = mock.mockPublishJson;
+
+let TestOpsAlt = {
+  name: "Catalog",
+  serviceName: "CatalogDcbEventLog",
+  storage: storage$1,
+  publishJson: publishJson$1
+};
+
+let OpsAlt = DcbEventLog_Operations$ReventlessCore.Make(TestOpsAlt);
+
+globalThis.beforeEach(() => mock.reset());
+
+function encodeEvent(event) {
+  let json = S.reverseConvertToJsonOrThrow(event, DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
+  let match = Message$ReventlessCore.splitMessage(json);
+  let tags = DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema, event);
+  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  return {
+    eventType: match[0],
+    data: match[1],
+    tags: tags,
+    meta: meta
+  };
+}
+
+function decodeEvent(raw) {
+  let json = Message$ReventlessCore.combineMessage(raw.eventType, Stdlib_Option.getOr(Stdlib_JSON.Decode.object(raw.data), {}));
+  return S.parseJsonOrThrow(json, DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
+}
+
+globalThis.describe("DcbEventLog_Operations:", () => {
+  globalThis.describe("round-trip (append then read)", () => {
+    globalThis.test("ItemCreated preserves through round-trip", async () => {
+      let event = {
+        TAG: "ItemCreated",
+        itemId: "item-1",
+        name: "Test"
+      };
+      let rawEvent = encodeEvent(event);
+      await Ops.append([rawEvent], undefined);
+      let result = await Ops.read([{}], undefined);
+      globalThis.expect([
+        result.events.length,
+        Stdlib_Option.map(result.events[0], decodeEvent)
+      ]).toEqual([
+        1,
+        event
+      ]);
+    });
+    globalThis.test("CountUpdated with int tag preserves through round-trip", async () => {
+      let event = {
+        TAG: "CountUpdated",
+        category: "electronics",
+        amount: 42
+      };
+      let rawEvent = encodeEvent(event);
+      await Ops.append([rawEvent], undefined);
+      let result = await Ops.read([{}], undefined);
+      globalThis.expect(Stdlib_Option.map(result.events[0], decodeEvent)).toEqual(event);
+    });
+    globalThis.test("multiple events in single append all read back", async () => {
+      let events = [
+        {
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "First"
+        },
+        {
+          TAG: "ItemRenamed",
+          itemId: "item-1",
+          newName: "Second"
+        }
+      ];
+      let rawEvents = events.map(encodeEvent);
+      await Ops.append(rawEvents, undefined);
+      let result = await Ops.read([{}], undefined);
+      globalThis.expect([
+        result.events.length,
+        result.events.map(decodeEvent)
+      ]).toEqual([
+        2,
+        events
+      ]);
+    });
+  });
+  globalThis.describe("append", () => {
+    globalThis.test("stores events and publishes to event topic", async () => {
+      let result = await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      globalThis.expect([
+        Stdlib_Result.isOk(result),
+        mock.getEvents().length,
+        mock.publishedEvents.contents.length
+      ]).toEqual([
+        true,
+        1,
+        1
+      ]);
+    });
+    globalThis.test("published events have correct service name", async () => {
+      await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      globalThis.expect(Stdlib_Option.map(mock.publishedEvents.contents[0], pe => pe.service)).toEqual("TestDcbEventLog");
+    });
+    globalThis.test("service comes from Ops.serviceName, not Ops.name", async () => {
+      await OpsAlt.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      globalThis.expect(Stdlib_Option.map(mock.publishedEvents.contents[0], pe => pe.service)).toEqual("CatalogDcbEventLog");
+    });
+    globalThis.test("error from storage does not publish to event topic", async () => {
+      mock.failNextAppends.contents = 1;
+      let result = await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      globalThis.expect([
+        Stdlib_Result.isError(result),
+        mock.publishedEvents.contents.length
+      ]).toEqual([
+        true,
+        0
+      ]);
+    });
+    globalThis.test("with condition (no conflict) succeeds", async () => {
+      await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      let condition_query = [{
+          eventTypes: ["ItemCreated"],
+          tags: [{
+              key: "itemId",
+              value: "item-1"
+            }]
+        }];
+      let condition_after = "1";
+      let condition = {
+        query: condition_query,
+        after: condition_after
+      };
+      let result = await Ops.append([encodeEvent({
+          TAG: "ItemRenamed",
+          itemId: "item-1",
+          newName: "Updated"
+        })], condition);
+      globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    });
+    globalThis.test("multiple events all stored and published", async () => {
+      let events = [
+        {
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "First"
+        },
+        {
+          TAG: "ItemCreated",
+          itemId: "item-2",
+          name: "Second"
+        }
+      ];
+      await Ops.append(events.map(encodeEvent), undefined);
+      globalThis.expect([
+        mock.getEvents().length,
+        mock.publishedEvents.contents.length
+      ]).toEqual([
+        2,
+        2
+      ]);
+    });
+  });
+  globalThis.describe("read", () => {
+    globalThis.test("returns headPosition from storage", async () => {
+      await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      let result = await Ops.read([{}], undefined);
+      globalThis.expect(result.headPosition).toEqual("1");
+    });
+    globalThis.test("with ~after parameter filters out earlier events", async () => {
+      await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "First"
+        })], undefined);
+      await Ops.append([encodeEvent({
+          TAG: "ItemRenamed",
+          itemId: "item-1",
+          newName: "Second"
+        })], undefined);
+      let result = await Ops.read([{}], "1");
+      globalThis.expect([
+        result.events.length,
+        Stdlib_Option.map(result.events[0], decodeEvent)
+      ]).toEqual([
+        1,
+        {
+          TAG: "ItemRenamed",
+          itemId: "item-1",
+          newName: "Second"
+        }
+      ]);
+    });
+    globalThis.test("no matching events returns empty array", async () => {
+      await Ops.append([encodeEvent({
+          TAG: "ItemCreated",
+          itemId: "item-1",
+          name: "Test"
+        })], undefined);
+      let result = await Ops.read([{
+          eventTypes: ["NonExistent"]
+        }], undefined);
+      globalThis.expect(result.events.length).toEqual(0);
+    });
+  });
+});
+
+export {
+  mock,
+  TestOps,
+  Ops,
+  TestOpsAlt,
+  OpsAlt,
+  encodeEvent,
+  decodeEvent,
+}
+/* mock Not a pure module */