@reventlessdev/reventless-core 3.0.0-alpha.180 → 3.0.0-alpha.182

package/tests/eventmapper/EventMapperFixtures.res.mjs

@@ -0,0 +1,440 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
+import * as EventMapper_Callback$ReventlessCore from "../../src/components/EventMapper/EventMapper_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "SourceAggregate";
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    name: s.m(S.string),
+    price: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "ItemPriceUpdated",
+    newPrice: s.m(S.float)
+  })),
+  S.literal("ItemRemoved")
+]);
+
+let moduleUrl = import.meta.url;
+
+let SourceSpec = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema,
+  moduleUrl: moduleUrl
+};
+
+let name$1 = "ItemCatalog";
+
+let stateSchema = S.schema(s => ({
+  name: s.m(S.string),
+  price: s.m(S.float)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let TargetSpec = {
+  Id: undefined,
+  name: name$1,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function project(msg) {
+  let match = msg.event;
+  if (typeof match !== "object") {
+    return {
+      TAG: "Delete",
+      _0: msg.id
+    };
+  }
+  if (match.TAG === "ItemCreated") {
+    return {
+      TAG: "Create",
+      _0: msg.id,
+      _1: {
+        name: match.name,
+        price: match.price
+      }
+    };
+  }
+  let newPrice = match.newPrice;
+  return {
+    TAG: "Update",
+    _0: msg.id,
+    _1: s => ({
+      name: s.name,
+      price: newPrice
+    })
+  };
+}
+
+let ItemMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: name$1,
+  stateSchema: stateSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+let testMeta = {
+  service: "SourceAggregate",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001"
+};
+
+function makeSourceEvent$p(id, event) {
+  return {
+    id: id,
+    meta: testMeta,
+    event: event
+  };
+}
+
+let name$2 = "TestCmdSource";
+
+let eventSchema$1 = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string),
+    amount: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let moduleUrl$1 = import.meta.url;
+
+let CmdSourceSpec = {
+  Id: undefined,
+  name: name$2,
+  eventSchema: eventSchema$1,
+  moduleUrl: moduleUrl$1
+};
+
+let name$3 = "TestCmdTarget";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "ProcessOrder",
+    orderId: s.m(S.string),
+    amount: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "ShipOrder",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let moduleUrl$2 = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let CmdTargetSpec = {
+  Id: undefined,
+  name: name$3,
+  commandSchema: commandSchema,
+  moduleUrl: moduleUrl$2,
+  commandAuthorization: commandAuthorization
+};
+
+function map(id, event, _queryEngine) {
+  if (event.TAG === "OrderPlaced") {
+    return [{
+        TAG: "Publish",
+        _0: id,
+        _1: {
+          TAG: "ProcessOrder",
+          orderId: event.orderId,
+          amount: event.amount
+        }
+      }];
+  }
+  let cmd = {
+    TAG: "ShipOrder",
+    orderId: event.orderId
+  };
+  return [{
+      TAG: "Publish",
+      _0: id,
+      _1: cmd
+    }];
+}
+
+let OrderMapping = {
+  Source: undefined,
+  Target: undefined,
+  map: map
+};
+
+function map$1(_id, event, _queryEngine) {
+  if (event.TAG === "OrderPlaced") {
+    return [{
+        TAG: "Count",
+        _0: "order-counter"
+      }];
+  } else {
+    return [{
+        TAG: "AddToCounterTarget",
+        _0: {
+          counterId: "order-counter",
+          target: 5
+        }
+      }];
+  }
+}
+
+let CountOrderMapping = {
+  Source: undefined,
+  Target: undefined,
+  map: map$1
+};
+
+let mappings = [{
+    Source: {
+      name: name$2,
+      Id: {
+        schema: Id$Reventless.StringPure.schema,
+        make: prim => prim,
+        makeFromString: prim => prim,
+        toString: prim => prim,
+        cmp: Id$Reventless.StringPure.cmp
+      },
+      eventSchema: eventSchema$1
+    },
+    map: map
+  }];
+
+let OrderMappings_Target = {
+  Id: Id$Reventless.StringPure,
+  name: name$3,
+  commandSchema: commandSchema,
+  moduleUrl: moduleUrl$2,
+  commandAuthorization: commandAuthorization
+};
+
+let OrderMappings = {
+  Target: OrderMappings_Target,
+  mappings: mappings,
+  counter: undefined
+};
+
+let mappings$1 = [{
+    Source: {
+      name: name$2,
+      Id: {
+        schema: Id$Reventless.StringPure.schema,
+        make: prim => prim,
+        makeFromString: prim => prim,
+        toString: prim => prim,
+        cmp: Id$Reventless.StringPure.cmp
+      },
+      eventSchema: eventSchema$1
+    },
+    map: map$1
+  }];
+
+let CountOrderMappings_Target = {
+  Id: Id$Reventless.StringPure,
+  name: name$3,
+  commandSchema: commandSchema,
+  moduleUrl: moduleUrl$2,
+  commandAuthorization: commandAuthorization
+};
+
+let CountOrderMappings = {
+  Target: CountOrderMappings_Target,
+  mappings: mappings$1,
+  counter: undefined
+};
+
+let capturedCmds = {
+  contents: []
+};
+
+let capturedCountItems = {
+  contents: []
+};
+
+let capturedCounterTargets = {
+  contents: []
+};
+
+async function mockQueryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function mockQueryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let mockQueryEngine = {
+  scan: mockQueryEngine_scan,
+  query: mockQueryEngine_query
+};
+
+async function publishJsons(cmds) {
+  capturedCmds.contents = capturedCmds.contents.concat(cmds);
+}
+
+let MockCounterOps = {
+  publishJsons: publishJsons,
+  queryEngine: mockQueryEngine
+};
+
+let TestCounterHandler = EventMapper_Callback$ReventlessCore.MakeCounterHandler({
+  name: name$3,
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  commandSchema: commandSchema
+})({
+  mappings: mappings,
+  counter: undefined
+})(MockCounterOps);
+
+let mockCommonHandler = {
+  contents: async param => [
+    Promise.resolve([]),
+    []
+  ]
+};
+
+let mockCountFailUntil = {
+  contents: 0
+};
+
+let mockCountCallCount = {
+  contents: 0
+};
+
+async function publishJsons$1(cmds) {
+  capturedCmds.contents = capturedCmds.contents.concat(cmds);
+}
+
+async function count(items) {
+  mockCountCallCount.contents = mockCountCallCount.contents + 1 | 0;
+  capturedCountItems.contents = capturedCountItems.contents.concat(items);
+  if (mockCountCallCount.contents <= mockCountFailUntil.contents) {
+    return Stdlib_JsError.throwWithMessage("count failed");
+  }
+}
+
+async function addToCounterTarget(target) {
+  capturedCounterTargets.contents = capturedCounterTargets.contents.concat([target]);
+}
+
+async function commonEventsHandler(eventsJson$p) {
+  return await mockCommonHandler.contents(eventsJson$p);
+}
+
+let MockECOps = {
+  publishJsons: publishJsons$1,
+  count: count,
+  addToCounterTarget: addToCounterTarget,
+  commonEventsHandler: commonEventsHandler
+};
+
+let TestECHandler = EventMapper_Callback$ReventlessCore.MakeEventCollectorHandler(MockECOps);
+
+let evtMapTestMeta_ip = "127.0.0.1";
+
+let evtMapTestMeta_user = "test-user";
+
+let evtMapTestMeta = {
+  service: name$2,
+  time: "2024-01-01T00:00:00Z",
+  ip: evtMapTestMeta_ip,
+  user: evtMapTestMeta_user,
+  msgId: "test-msg-1",
+  correlationId: "test-corr-1"
+};
+
+function makeEventJson(serviceOpt, id, eventJson) {
+  let service = serviceOpt !== undefined ? serviceOpt : name$2;
+  let newrecord = {...evtMapTestMeta};
+  return Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "meta",
+      Message$Reventless.encode((newrecord.service = service, newrecord), Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      eventJson
+    ]
+  ]);
+}
+
+function resetMocks() {
+  capturedCmds.contents = [];
+  capturedCountItems.contents = [];
+  capturedCounterTargets.contents = [];
+  mockCountFailUntil.contents = 0;
+  mockCountCallCount.contents = 0;
+  mockCommonHandler.contents = async param => [
+    Promise.resolve([]),
+    []
+  ];
+}
+
+export {
+  SourceSpec,
+  TargetSpec,
+  ItemMapping,
+  testMeta,
+  makeSourceEvent$p,
+  CmdSourceSpec,
+  CmdTargetSpec,
+  OrderMapping,
+  CountOrderMapping,
+  OrderMappings,
+  CountOrderMappings,
+  capturedCmds,
+  capturedCountItems,
+  capturedCounterTargets,
+  mockQueryEngine,
+  MockCounterOps,
+  TestCounterHandler,
+  mockCommonHandler,
+  mockCountFailUntil,
+  mockCountCallCount,
+  MockECOps,
+  TestECHandler,
+  evtMapTestMeta,
+  makeEventJson,
+  resetMocks,
+}
+/*  Not a pure module */

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.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.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 */