@reventlessdev/reventless-core 3.0.0-alpha.170 → 3.0.0-alpha.172

package/tests/commandtopic/CommandTopicHelpersRejectionTest.res.mjs

@@ -1,109 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
-import * as Effect from "effect/Effect";
-import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
-
-function metaWithMsgId(msgId) {
-  return {
-    service: "TestService",
-    time: "2024-01-01T00:00:00Z",
-    ip: "127.0.0.1",
-    user: "test-user",
-    msgId: msgId,
-    correlationId: "corr-1"
-  };
-}
-
-function cmdJson(msgId) {
-  return {
-    id: "agg-1",
-    meta: metaWithMsgId(msgId),
-    commandJson: Object.fromEntries([[
-        "TAG",
-        "Noop"
-      ]])
-  };
-}
-
-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, {
-          entityId: "agg-1",
-          eventCount: 0
-        });
-        CommandTopic_Helpers$ReventlessCore.reportRejected(item.reference, {
-          errorCode: "AlreadyExists",
-          errorDetail: ""
-        });
-      });
-      return items.map(item => ({
-        TAG: "Ok",
-        _0: item.reference
-      }));
-    });
-    let outcomes = await CommandTopic_Helpers$ReventlessCore.runInlineAndCollect([cmdJson("msg-1")], handler);
-    globalThis.expect(outcomes.length).toBe(1);
-    let match = outcomes[0];
-    switch (match.TAG) {
-      case "Rejected" :
-        globalThis.expect(match.msgId).toEqual("msg-1");
-        globalThis.expect(match.errorCode).toEqual("AlreadyExists");
-        globalThis.expect(match.errorDetail).toEqual(undefined);
-        return;
-      case "Accepted" :
-      case "Pending" :
-        globalThis.expect("expected Rejected").toEqual("got other");
-        return;
-    }
-  });
-  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, {
-        errorCode: "BusinessRuleViolated",
-        errorDetail: "{\"reason\":\"x\"}"
-      }));
-      return items.map(item => ({
-        TAG: "Error",
-        _0: item.reference
-      }));
-    });
-    let outcomes = await CommandTopic_Helpers$ReventlessCore.runInlineAndCollect([cmdJson("msg-1")], handler);
-    let match = outcomes[0];
-    switch (match.TAG) {
-      case "Rejected" :
-        globalThis.expect(match.errorCode).toEqual("BusinessRuleViolated");
-        globalThis.expect(match.errorDetail).toEqual("{\"reason\":\"x\"}");
-        return;
-      case "Accepted" :
-      case "Pending" :
-        globalThis.expect("expected Rejected").toEqual("got other");
-        return;
-    }
-  });
-  globalThis.test("Error result without rejectedChannel still synthesizes Conflict", async () => {
-    let handler = stream => Effect.map(Stream.runCollect(stream), items => items.map(item => ({
-      TAG: "Error",
-      _0: item.reference
-    })));
-    let outcomes = await CommandTopic_Helpers$ReventlessCore.runInlineAndCollect([cmdJson("msg-1")], handler);
-    let match = outcomes[0];
-    switch (match.TAG) {
-      case "Rejected" :
-        globalThis.expect(match.errorCode).toEqual("Conflict");
-        return;
-      case "Accepted" :
-      case "Pending" :
-        globalThis.expect("expected Rejected(Conflict)").toEqual("got other");
-        return;
-    }
-  });
-});
-
-export {
-  metaWithMsgId,
-  cmdJson,
-}
-/*  Not a pure module */

package/tests/counter/CounterCallbackTest.res.mjs

@@ -1,140 +0,0 @@
-// 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.mjs

@@ -1,67 +0,0 @@
-// 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.mjs

@@ -1,194 +0,0 @@
-// 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 */