@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/eventmapper/EventMapperFixtures.res

@@ -0,0 +1,255 @@
+open Reventless.Projection
+
+S.enableJson()
+
+// ─────────────────────────────────────────────────────────────
+// Source event spec (aggregate events)
+// ─────────────────────────────────────────────────────────────
+
+module SourceSpec = {
+  module Id = Reventless.Id.String
+  let name = "SourceAggregate"
+
+  @schema
+  type event =
+    | ItemCreated({name: string, price: float})
+    | ItemPriceUpdated({newPrice: float})
+    | ItemRemoved
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+// ─────────────────────────────────────────────────────────────
+// Target read model spec
+// ─────────────────────────────────────────────────────────────
+
+module TargetSpec = {
+  module Id = Reventless.Id.String
+  let name = "ItemCatalog"
+
+  @schema
+  type state = {name: string, price: float}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mapping: SourceSpec events → TargetSpec projection actions
+// ─────────────────────────────────────────────────────────────
+
+module ItemMapping = Mapping.Make(
+  SourceSpec,
+  TargetSpec,
+  {
+    let project = (msg: Reventless.Message.event'<string, SourceSpec.event>) =>
+      switch msg.event {
+      | ItemCreated({name, price}) => Create(msg.id, ({name, price}: TargetSpec.state))
+      | ItemPriceUpdated({newPrice}) => Update(msg.id, s => {...s, price: newPrice})
+      | ItemRemoved => Delete(msg.id)
+      }
+  },
+)
+
+// ─────────────────────────────────────────────────────────────
+// Test metadata
+// ─────────────────────────────────────────────────────────────
+
+let testMeta: Reventless.Message.meta = {
+  service: "SourceAggregate",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001",
+}
+
+let makeSourceEvent' = (id, event) => ({
+  Reventless.Message.id,
+  meta: testMeta,
+  event,
+}: Reventless.Message.event'<string, SourceSpec.event>)
+
+// ─────────────────────────────────────────────────────────────
+// EventMapper_Callback test fixtures
+// Source → Target (event → command) mapping
+// ─────────────────────────────────────────────────────────────
+
+module CmdSourceSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestCmdSource"
+
+  @schema
+  type event =
+    | OrderPlaced({orderId: string, amount: float})
+    | OrderShipped({orderId: string})
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+module CmdTargetSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestCmdTarget"
+
+  @schema
+  type command =
+    | ProcessOrder({orderId: string, amount: float})
+    | ShipOrder({orderId: string})
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+// Publish mapping: OrderPlaced → ProcessOrder
+module OrderMapping = {
+  module Source = CmdSourceSpec
+  module Target = CmdTargetSpec
+
+  let map = (
+    id: CmdSourceSpec.Id.t,
+    event: CmdSourceSpec.event,
+    _queryEngine,
+  ): array<Reventless.EventMapping.action<CmdTargetSpec.Id.t, CmdTargetSpec.command>> =>
+    switch event {
+    | OrderPlaced({orderId, amount}) =>
+      [Reventless.EventMapping.Publish(id, CmdTargetSpec.ProcessOrder({orderId, amount}))]
+    | OrderShipped({orderId}) =>
+      let cmd = CmdTargetSpec.ShipOrder({orderId: orderId})
+      [Reventless.EventMapping.Publish(id, cmd)]
+    }
+}
+
+// Counter mapping: OrderPlaced → Count action
+module CountOrderMapping = {
+  module Source = CmdSourceSpec
+  module Target = CmdTargetSpec
+
+  let map = (
+    _id: CmdSourceSpec.Id.t,
+    event: CmdSourceSpec.event,
+    _queryEngine,
+  ): array<Reventless.EventMapping.action<CmdTargetSpec.Id.t, CmdTargetSpec.command>> =>
+    switch event {
+    | OrderPlaced(_) => [Reventless.EventMapping.Count("order-counter")]
+    | OrderShipped(_) =>
+      [
+        Reventless.EventMapping.AddToCounterTarget({
+          counterId: "order-counter",
+          target: 5,
+        }),
+      ]
+    }
+}
+
+module OrderMappings: EventMapper.Mappings with module Target = CmdTargetSpec = {
+  module Target = CmdTargetSpec
+  module type Mapping = Reventless.EventMapping.T with module Target := CmdTargetSpec
+  let mappings: array<module(Mapping)> = [module(OrderMapping)]
+  let counter = None
+}
+
+module CountOrderMappings: EventMapper.Mappings with module Target = CmdTargetSpec = {
+  module Target = CmdTargetSpec
+  module type Mapping = Reventless.EventMapping.T with module Target := CmdTargetSpec
+  let mappings: array<module(Mapping)> = [module(CountOrderMapping)]
+  let counter = None
+}
+
+// ─────────────────────────────────────────────────────────────
+// Shared mocks for EventMapper_Callback tests
+// ─────────────────────────────────────────────────────────────
+
+let capturedCmds: ref<array<Reventless.Message.commandJson>> = ref([])
+let capturedCountItems: ref<array<ReventlessInfra.Counter.countItem>> = ref([])
+let capturedCounterTargets: ref<array<ReventlessInfra.Counter.counterTargetRef>> = ref([])
+
+let mockQueryEngine: Reventless.QueryEngine.operations = {
+  scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => [],
+}
+
+// CounterOps mock for MakeCounterHandler
+module MockCounterOps: EventMapper_Callback.CounterOps = {
+  let publishJsons: CommandTopic.publishJsons = async cmds => {
+    capturedCmds := capturedCmds.contents->Array.concat(cmds)
+  }
+  let queryEngine = mockQueryEngine
+}
+
+// MakeCounterHandler under test
+module TestCounterHandler = EventMapper_Callback.MakeCounterHandler(
+  CmdTargetSpec,
+  OrderMappings,
+  MockCounterOps,
+)
+
+// configurable mock for commonEventsHandler — reassigned in each test
+let mockCommonHandler: ref<
+  array<JSON.t> => promise<(
+    promise<array<Reventless.Message.commandJson>>,
+    array<Counter.action>,
+  )>,
+> = ref(async _ => (Promise.resolve([]), []))
+
+let mockCountFailUntil = ref(0)
+let mockCountCallCount = ref(0)
+
+// EventCollectorOps mock for MakeEventCollectorHandler
+module MockECOps: EventMapper_Callback.EventCollectorOps = {
+  let publishJsons: CommandTopic.publishJsons = async cmds => {
+    capturedCmds := capturedCmds.contents->Array.concat(cmds)
+  }
+  let count: ReventlessInfra.Counter.count = async items => {
+    mockCountCallCount := mockCountCallCount.contents + 1
+    capturedCountItems := capturedCountItems.contents->Array.concat(items)
+    if mockCountCallCount.contents <= mockCountFailUntil.contents {
+      JsError.throwWithMessage("count failed")
+    }
+  }
+  let addToCounterTarget: ReventlessInfra.Counter.addToCounterTarget = async target => {
+    capturedCounterTargets := capturedCounterTargets.contents->Array.concat([target])
+  }
+  let commonEventsHandler = async eventsJson' => {
+    await mockCommonHandler.contents(eventsJson')
+  }
+}
+
+// MakeEventCollectorHandler under test
+module TestECHandler = EventMapper_Callback.MakeEventCollectorHandler(MockECOps)
+
+let evtMapTestMeta: Reventless.Message.meta = {
+  service: CmdSourceSpec.name,
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "test-msg-1",
+  correlationId: "test-corr-1",
+}
+
+let makeEventJson = (~service=CmdSourceSpec.name, id, eventJson): JSON.t =>
+  [
+    ("id", JSON.Encode.string(id)),
+    (
+      "meta",
+      {...evtMapTestMeta, service: service}->Reventless.Message.encode(Reventless.Message.metaSchema),
+    ),
+    ("event", eventJson),
+  ]
+  ->Dict.fromArray
+  ->JSON.Encode.object
+
+let resetMocks = () => {
+  capturedCmds := []
+  capturedCountItems := []
+  capturedCounterTargets := []
+  mockCountFailUntil := 0
+  mockCountCallCount := 0
+  mockCommonHandler := async _ => (Promise.resolve([]), [])
+}

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