@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/counter/CounterCallbackTest.res.mjs

@@ -0,0 +1,140 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Counter$ReventlessCore from "../../src/components/Counter/Counter.res.mjs";
+import * as CounterFixtures$ReventlessCore from "./CounterFixtures.res.mjs";
+import * as Counter_Callback$ReventlessCore from "../../src/components/Counter/Counter_Callback.res.mjs";
+
+globalThis.beforeEach(() => CounterFixtures$ReventlessCore.reset());
+
+globalThis.describe("Counter_Callback.groupByCounterId:", () => {
+  globalThis.test("groups references by counter ID and sums increments", async () => {
+    let result = Counter_Callback$ReventlessCore.groupByCounterId([
+      [
+        Counter$ReventlessCore.makeId([
+          "counter-a",
+          "ref-1"
+        ]),
+        1
+      ],
+      [
+        Counter$ReventlessCore.makeId([
+          "counter-a",
+          "ref-2"
+        ]),
+        2
+      ]
+    ]);
+    let sorted = result.toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+    globalThis.expect(sorted).toEqual([[
+        "counter-a",
+        3
+      ]]);
+  });
+  globalThis.test("groups different counter IDs independently", async () => {
+    let result = Counter_Callback$ReventlessCore.groupByCounterId([
+      [
+        Counter$ReventlessCore.makeId([
+          "counter-a",
+          "ref-1"
+        ]),
+        1
+      ],
+      [
+        Counter$ReventlessCore.makeId([
+          "counter-b",
+          "ref-2"
+        ]),
+        1
+      ]
+    ]);
+    let sorted = result.toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+    globalThis.expect(sorted).toEqual([
+      [
+        "counter-a",
+        1
+      ],
+      [
+        "counter-b",
+        1
+      ]
+    ]);
+  });
+  globalThis.test("returns empty array for empty input", async () => {
+    let result = Counter_Callback$ReventlessCore.groupByCounterId([]);
+    globalThis.expect(result).toEqual([]);
+  });
+});
+
+globalThis.describe("Counter_Callback.counterHandler:", () => {
+  globalThis.describe("count reaches zero", () => {
+    globalThis.test("CountFinished event dispatched via jsonEventsHandler", async () => {
+      let ref1 = Counter$ReventlessCore.makeId([
+        "counter-1",
+        "ref-a"
+      ]);
+      let counts = [CounterFixtures$ReventlessCore.makeCountsJson(ref1, 0)];
+      await CounterFixtures$ReventlessCore.TestCounterHandler.counterHandler([[
+          ref1,
+          1
+        ]], counts);
+      let batches = CounterFixtures$ReventlessCore.capturedEventBatches.contents;
+      globalThis.expect([
+        batches.length,
+        batches[0].length
+      ]).toEqual([
+        1,
+        1
+      ]);
+    });
+  });
+  globalThis.describe("count above zero", () => {
+    globalThis.test("no CountFinished event, countsDbCount still called", async () => {
+      let ref1 = Counter$ReventlessCore.makeId([
+        "counter-1",
+        "ref-a"
+      ]);
+      let counts = [CounterFixtures$ReventlessCore.makeCountsJson(ref1, 3)];
+      await CounterFixtures$ReventlessCore.TestCounterHandler.counterHandler([[
+          ref1,
+          1
+        ]], counts);
+      let batches = CounterFixtures$ReventlessCore.capturedEventBatches.contents;
+      let events = batches[0];
+      globalThis.expect(events.length).toBe(0);
+      globalThis.expect(CounterFixtures$ReventlessCore.capturedCountCalls.contents.length).toBe(1);
+    });
+  });
+  globalThis.describe("multiple counters in batch", () => {
+    globalThis.test("each decremented independently", async () => {
+      let refA = Counter$ReventlessCore.makeId([
+        "counter-a",
+        "ref-1"
+      ]);
+      let refB = Counter$ReventlessCore.makeId([
+        "counter-b",
+        "ref-2"
+      ]);
+      let counts = [
+        CounterFixtures$ReventlessCore.makeCountsJson(refA, 2),
+        CounterFixtures$ReventlessCore.makeCountsJson(refB, 0)
+      ];
+      await CounterFixtures$ReventlessCore.TestCounterHandler.counterHandler([
+        [
+          refA,
+          1
+        ],
+        [
+          refB,
+          1
+        ]
+      ], counts);
+      globalThis.expect(CounterFixtures$ReventlessCore.capturedCountCalls.contents.length).toBe(2);
+      let batches = CounterFixtures$ReventlessCore.capturedEventBatches.contents;
+      let events = batches[0];
+      globalThis.expect(events.length).toBe(1);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/counter/CounterFixtures.res

@@ -0,0 +1,57 @@
+S.enableJson()
+
+// ─────────────────────────────────────────────────────────────
+// Shared captures — reset in beforeEach
+// ─────────────────────────────────────────────────────────────
+
+let capturedCountCalls: ref<array<(Reventless.Id.StringPure.t, string, int)>> = ref([])
+let capturedEventBatches: ref<array<array<JSON.t>>> = ref([])
+
+// ─────────────────────────────────────────────────────────────
+// Mock countsDbCount — records (id, field, delta) calls
+// Returns Ok(0) by default (simulates count reaching 0 is handled
+// via the 'counts' parameter, not the return value of countsDbCount)
+// ─────────────────────────────────────────────────────────────
+
+let mockCountsDbCount: QueryDb.count<string> = async (id, field, delta) => {
+  capturedCountCalls :=
+    capturedCountCalls.contents->Array.concat([(id->Reventless.Id.StringPure.toString, field, delta)])
+  Ok(0)
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mock jsonEventsHandler — captures batches of event JSONs
+// ─────────────────────────────────────────────────────────────
+
+let mockJsonEventsHandler: Counter.jsonEventsHandler = stream =>
+  stream
+  ->Stream.runCollect
+  ->Effect.map(chunk => {
+    capturedEventBatches :=
+      capturedEventBatches.contents->Array.concat([chunk])
+  })
+
+// ─────────────────────────────────────────────────────────────
+// Counter_Callback spec and handler under test
+// ─────────────────────────────────────────────────────────────
+
+module TestCounterSpec: Counter_Callback.Spec = {
+  let name = "TestCounter"
+  let countsDbCount = mockCountsDbCount
+  let jsonEventsHandler = mockJsonEventsHandler
+}
+
+module TestCounterHandler = Counter_Callback.Make(TestCounterSpec)
+
+// ─────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────
+
+// Encode a countsState JSON (what the Lambda callback receives as ~counts)
+let makeCountsJson = (id, count): JSON.t =>
+  ({id, count}: Counter_Callback.countsState)->Message.encode(Counter_Callback.countsStateSchema)
+
+let reset = () => {
+  capturedCountCalls := []
+  capturedEventBatches := []
+}

package/tests/counter/CounterFixtures.res.mjs

@@ -0,0 +1,67 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as Counter_Callback$ReventlessCore from "../../src/components/Counter/Counter_Callback.res.mjs";
+
+S.enableJson();
+
+let capturedCountCalls = {
+  contents: []
+};
+
+let capturedEventBatches = {
+  contents: []
+};
+
+async function mockCountsDbCount(id, field, delta) {
+  capturedCountCalls.contents = capturedCountCalls.contents.concat([[
+      id,
+      field,
+      delta
+    ]]);
+  return {
+    TAG: "Ok",
+    _0: 0
+  };
+}
+
+function mockJsonEventsHandler(stream) {
+  return Effect.map(Stream.runCollect(stream), chunk => {
+    capturedEventBatches.contents = capturedEventBatches.contents.concat([chunk]);
+  });
+}
+
+let TestCounterSpec = {
+  name: "TestCounter",
+  countsDbCount: mockCountsDbCount,
+  jsonEventsHandler: mockJsonEventsHandler
+};
+
+let TestCounterHandler = Counter_Callback$ReventlessCore.Make(TestCounterSpec);
+
+function makeCountsJson(id, count) {
+  return Message$ReventlessCore.encode({
+    id: id,
+    count: count
+  }, Counter_Callback$ReventlessCore.countsStateSchema);
+}
+
+function reset() {
+  capturedCountCalls.contents = [];
+  capturedEventBatches.contents = [];
+}
+
+export {
+  capturedCountCalls,
+  capturedEventBatches,
+  mockCountsDbCount,
+  mockJsonEventsHandler,
+  TestCounterSpec,
+  TestCounterHandler,
+  makeCountsJson,
+  reset,
+}
+/*  Not a pure module */

package/tests/dcb/DcbDecodeTest.res

@@ -0,0 +1,122 @@
+open JestGlobals
+
+// Produced event schema (full shape with tags — represents what's in storage)
+@schema
+type event =
+  | ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string, name: string})
+  | ItemRenamed({itemId: @s.matches(Reventless.DcbTag.string) string, newName: string})
+  | ItemArchived({itemId: @s.matches(Reventless.DcbTag.string) string})
+
+// Consumed event — payload-less
+@schema
+type consumedPayloadLess =
+  | ItemCreated
+  | ItemArchived
+
+// Consumed event — partial projection
+@schema
+type consumedPartial =
+  | ItemCreated({itemId: string})
+  | ItemRenamed({itemId: string})
+
+// Consumed event — full shape (no tags)
+@schema
+type consumedFull =
+  | ItemCreated({itemId: string, name: string})
+  | ItemRenamed({itemId: string, newName: string})
+  | ItemArchived({itemId: string})
+
+describe("DcbDecode:", () => {
+  describe("makeDecoder — payload-less", () => {
+    let {Reventless.DcbDecode.decode: decode, eventTypes} =
+      Reventless.DcbDecode.makeDecoder(consumedPayloadLessSchema)
+
+    testSync("returns correct eventTypes", () => {
+      let sorted = eventTypes->Array.toSorted(String.compare)
+      expect(sorted)->toEqual(["ItemArchived", "ItemCreated"])
+    })
+
+    testSync("decodes ItemCreated as payload-less variant", () => {
+      let result = decode(
+        ~eventType="ItemCreated",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
+      )
+      let expected: option<consumedPayloadLess> = Some(ItemCreated)
+      expect(result)->toEqual(expected)
+    })
+
+    testSync("decodes ItemArchived as payload-less variant", () => {
+      let result = decode(
+        ~eventType="ItemArchived",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
+      )
+      let expected: option<consumedPayloadLess> = Some(ItemArchived)
+      expect(result)->toEqual(expected)
+    })
+
+    testSync("returns None for unknown event type", () => {
+      let result = decode(
+        ~eventType="ItemRenamed",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
+      )
+      expect(result)->toEqual(None)
+    })
+  })
+
+  describe("makeDecoder — partial projection", () => {
+    let {Reventless.DcbDecode.decode: decode} =
+      Reventless.DcbDecode.makeDecoder(consumedPartialSchema)
+
+    testSync("decodes ItemCreated with only itemId field", () => {
+      let result = decode(
+        ~eventType="ItemCreated",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
+      )
+      let expected: option<consumedPartial> = Some(ItemCreated({itemId: "i-1"}))
+      expect(result)->toEqual(expected)
+    })
+
+    testSync("decodes ItemRenamed with only itemId field", () => {
+      let result = decode(
+        ~eventType="ItemRenamed",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("newName", JSON.String("New"))]),
+      )
+      let expected: option<consumedPartial> = Some(ItemRenamed({itemId: "i-1"}))
+      expect(result)->toEqual(expected)
+    })
+
+    testSync("returns None for unknown event type", () => {
+      let result = decode(~eventType="ItemArchived", ~data=Dict.fromArray([]))
+      expect(result)->toEqual(None)
+    })
+  })
+
+  describe("makeDecoder — full shape", () => {
+    let {Reventless.DcbDecode.decode: decode} =
+      Reventless.DcbDecode.makeDecoder(consumedFullSchema)
+
+    testSync("decodes ItemCreated with all fields", () => {
+      let result = decode(
+        ~eventType="ItemCreated",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
+      )
+      expect(result)->toEqual(Some(ItemCreated({itemId: "i-1", name: "Test"})))
+    })
+
+    testSync("decodes ItemRenamed with all fields", () => {
+      let result = decode(
+        ~eventType="ItemRenamed",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("newName", JSON.String("New"))]),
+      )
+      expect(result)->toEqual(Some(ItemRenamed({itemId: "i-1", newName: "New"})))
+    })
+
+    testSync("decodes ItemArchived with all fields", () => {
+      let result = decode(
+        ~eventType="ItemArchived",
+        ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
+      )
+      expect(result)->toEqual(Some(ItemArchived({itemId: "i-1"})))
+    })
+  })
+})

package/tests/dcb/DcbDecodeTest.res.mjs

@@ -0,0 +1,194 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    itemId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemRenamed",
+    itemId: s.m(DcbTag$Reventless.string),
+    newName: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemArchived",
+    itemId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let consumedPayloadLessSchema = S.union([
+  S.literal("ItemCreated"),
+  S.literal("ItemArchived")
+]);
+
+let consumedPartialSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    itemId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemRenamed",
+    itemId: s.m(S.string)
+  }))
+]);
+
+let consumedFullSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    itemId: s.m(S.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemRenamed",
+    itemId: s.m(S.string),
+    newName: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemArchived",
+    itemId: s.m(S.string)
+  }))
+]);
+
+globalThis.describe("DcbDecode:", () => {
+  globalThis.describe("makeDecoder — payload-less", () => {
+    let match = DcbDecode$Reventless.makeDecoder(consumedPayloadLessSchema);
+    let eventTypes = match.eventTypes;
+    let decode = match.decode;
+    globalThis.test("returns correct eventTypes", () => {
+      let sorted = eventTypes.toSorted(Primitive_string.compare);
+      globalThis.expect(sorted).toEqual([
+        "ItemArchived",
+        "ItemCreated"
+      ]);
+    });
+    globalThis.test("decodes ItemCreated as payload-less variant", () => {
+      let result = decode("ItemCreated", Object.fromEntries([
+        [
+          "itemId",
+          "i-1"
+        ],
+        [
+          "name",
+          "Test"
+        ]
+      ]));
+      globalThis.expect(result).toEqual("ItemCreated");
+    });
+    globalThis.test("decodes ItemArchived as payload-less variant", () => {
+      let result = decode("ItemArchived", Object.fromEntries([[
+          "itemId",
+          "i-1"
+        ]]));
+      globalThis.expect(result).toEqual("ItemArchived");
+    });
+    globalThis.test("returns None for unknown event type", () => {
+      let result = decode("ItemRenamed", Object.fromEntries([[
+          "itemId",
+          "i-1"
+        ]]));
+      globalThis.expect(result).toEqual(undefined);
+    });
+  });
+  globalThis.describe("makeDecoder — partial projection", () => {
+    let match = DcbDecode$Reventless.makeDecoder(consumedPartialSchema);
+    let decode = match.decode;
+    globalThis.test("decodes ItemCreated with only itemId field", () => {
+      let result = decode("ItemCreated", Object.fromEntries([
+        [
+          "itemId",
+          "i-1"
+        ],
+        [
+          "name",
+          "Test"
+        ]
+      ]));
+      globalThis.expect(result).toEqual({
+        TAG: "ItemCreated",
+        itemId: "i-1"
+      });
+    });
+    globalThis.test("decodes ItemRenamed with only itemId field", () => {
+      let result = decode("ItemRenamed", Object.fromEntries([
+        [
+          "itemId",
+          "i-1"
+        ],
+        [
+          "newName",
+          "New"
+        ]
+      ]));
+      globalThis.expect(result).toEqual({
+        TAG: "ItemRenamed",
+        itemId: "i-1"
+      });
+    });
+    globalThis.test("returns None for unknown event type", () => {
+      let result = decode("ItemArchived", Object.fromEntries([]));
+      globalThis.expect(result).toEqual(undefined);
+    });
+  });
+  globalThis.describe("makeDecoder — full shape", () => {
+    let match = DcbDecode$Reventless.makeDecoder(consumedFullSchema);
+    let decode = match.decode;
+    globalThis.test("decodes ItemCreated with all fields", () => {
+      let result = decode("ItemCreated", Object.fromEntries([
+        [
+          "itemId",
+          "i-1"
+        ],
+        [
+          "name",
+          "Test"
+        ]
+      ]));
+      globalThis.expect(result).toEqual({
+        TAG: "ItemCreated",
+        itemId: "i-1",
+        name: "Test"
+      });
+    });
+    globalThis.test("decodes ItemRenamed with all fields", () => {
+      let result = decode("ItemRenamed", Object.fromEntries([
+        [
+          "itemId",
+          "i-1"
+        ],
+        [
+          "newName",
+          "New"
+        ]
+      ]));
+      globalThis.expect(result).toEqual({
+        TAG: "ItemRenamed",
+        itemId: "i-1",
+        newName: "New"
+      });
+    });
+    globalThis.test("decodes ItemArchived with all fields", () => {
+      let result = decode("ItemArchived", Object.fromEntries([[
+          "itemId",
+          "i-1"
+        ]]));
+      globalThis.expect(result).toEqual({
+        TAG: "ItemArchived",
+        itemId: "i-1"
+      });
+    });
+  });
+});
+
+export {
+  eventSchema,
+  consumedPayloadLessSchema,
+  consumedPartialSchema,
+  consumedFullSchema,
+}
+/* eventSchema Not a pure module */