@reventlessdev/reventless-core 3.0.0-alpha.260 → 3.0.0-alpha.261

package/tests/eventmapper/EventMapperCallbackTest.res

@@ -9,41 +9,54 @@ let _ = beforeEach(() => resetMocks())
 
 describe("MakeCounterHandler.handleCounterEvents:", () => {
   describe("event with matching source mapping", () => {
-    testPromise("publishes command JSON for OrderPlaced", async () => {
-      let eventJson =
-        makeEventJson(
+    testPromise(
+      "publishes command JSON for OrderPlaced",
+      async () => {
+        let eventJson = makeEventJson(
           "src-1",
           CmdSourceSpec.OrderPlaced({orderId: "order-1", amount: 99.99})->Message.encode(
             CmdSourceSpec.eventSchema,
           ),
         )
-      await TestCounterHandler.handleCounterEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
-      // publishJsons should have been called with 1 command
-      expect(capturedCmds.contents->Array.length)->toBe(1)
-    })
+        await TestCounterHandler.handleCounterEvents(
+          Stream.fromIterable([eventJson]),
+        )->Effect.runPromise
+        // publishJsons should have been called with 1 command
+        expect(capturedCmds.contents->Array.length)->toBe(1)
+      },
+    )
   })
 
   describe("event with unknown service", () => {
-    testPromise("skipped — no publish", async () => {
-      let eventJson =
-        makeEventJson(
+    testPromise(
+      "skipped — no publish",
+      async () => {
+        let eventJson = makeEventJson(
           ~service="UnknownService",
           "src-1",
           CmdSourceSpec.OrderPlaced({orderId: "order-1", amount: 50.0})->Message.encode(
             CmdSourceSpec.eventSchema,
           ),
         )
-      await TestCounterHandler.handleCounterEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
-      expect(capturedCmds.contents->Array.length)->toBe(0)
-    })
+        await TestCounterHandler.handleCounterEvents(
+          Stream.fromIterable([eventJson]),
+        )->Effect.runPromise
+        expect(capturedCmds.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("invalid event JSON", () => {
-    testPromise("skipped gracefully — no throw, no publish", async () => {
-      let invalidJson = JSON.Encode.string("not-an-object")
-      await TestCounterHandler.handleCounterEvents(Stream.fromIterable([invalidJson]))->Effect.runPromise
-      expect(capturedCmds.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "skipped gracefully — no throw, no publish",
+      async () => {
+        let invalidJson = JSON.Encode.string("not-an-object")
+        await TestCounterHandler.handleCounterEvents(
+          Stream.fromIterable([invalidJson]),
+        )->Effect.runPromise
+        expect(capturedCmds.contents->Array.length)->toBe(0)
+      },
+    )
   })
 })
 
@@ -53,82 +66,104 @@ describe("MakeCounterHandler.handleCounterEvents:", () => {
 
 describe("MakeEventCollectorHandler.handleJsonEvents:", () => {
   describe("Count action", () => {
-    testPromise("calls count with the countItem", async () => {
-      let countItem: ReventlessInfra.Counter.countItem = {
-        counterId: "c1",
-        reference: "ref-1",
-        inc: 1,
-      }
-      mockCommonHandler :=
-        async _ => (Promise.resolve([]), [Counter.Count(countItem)])
-      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
-      expect(capturedCountItems.contents)->toEqual([countItem])
-    })
+    testPromise(
+      "calls count with the countItem",
+      async () => {
+        let countItem: ReventlessInfra.Counter.countItem = {
+          counterId: "c1",
+          reference: "ref-1",
+          inc: 1,
+        }
+        mockCommonHandler := (async _ => (Promise.resolve([]), [Counter.Count(countItem)]))
+        await TestECHandler.handleJsonEvents(
+          Stream.fromIterable([JSON.Encode.null]),
+        )->Effect.runPromise
+        expect(capturedCountItems.contents)->toEqual([countItem])
+      },
+    )
   })
 
   describe("AddToCounterTarget action", () => {
-    testPromise("calls addToCounterTarget with the counterTargetRef", async () => {
-      let target: ReventlessInfra.Counter.counterTargetRef = {
-        counterId: "c1",
-        target: 5,
-        targetRef: "ref-1",
-      }
-      mockCommonHandler :=
-        async _ => (Promise.resolve([]), [Counter.AddToCounterTarget(target)])
-      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
-      expect(capturedCounterTargets.contents)->toEqual([target])
-    })
+    testPromise(
+      "calls addToCounterTarget with the counterTargetRef",
+      async () => {
+        let target: ReventlessInfra.Counter.counterTargetRef = {
+          counterId: "c1",
+          target: 5,
+          targetRef: "ref-1",
+        }
+        mockCommonHandler :=
+          (async _ => (Promise.resolve([]), [Counter.AddToCounterTarget(target)]))
+        await TestECHandler.handleJsonEvents(
+          Stream.fromIterable([JSON.Encode.null]),
+        )->Effect.runPromise
+        expect(capturedCounterTargets.contents)->toEqual([target])
+      },
+    )
   })
 
   describe("Publisher action", () => {
-    testPromise("calls publishJsons with the command", async () => {
-      let cmd: Message.commandJson = {
-        id: "agg-1",
-        meta: evtMapTestMeta,
-        commandJson: JSON.Encode.string("DoSomething"),
-      }
-      mockCommonHandler := async _ => (Promise.resolve([cmd]), [])
-      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
-      expect(capturedCmds.contents->Array.length)->toBe(1)
-    })
+    testPromise(
+      "calls publishJsons with the command",
+      async () => {
+        let cmd: Message.commandJson = {
+          id: "agg-1",
+          meta: evtMapTestMeta,
+          commandJson: JSON.Encode.string("DoSomething"),
+        }
+        mockCommonHandler := (async _ => (Promise.resolve([cmd]), []))
+        await TestECHandler.handleJsonEvents(
+          Stream.fromIterable([JSON.Encode.null]),
+        )->Effect.runPromise
+        expect(capturedCmds.contents->Array.length)->toBe(1)
+      },
+    )
   })
 
   describe("mixed actions", () => {
-    testPromise("both publish and count called", async () => {
-      let countItem: ReventlessInfra.Counter.countItem = {
-        counterId: "c1",
-        reference: "ref-1",
-        inc: 2,
-      }
-      let cmd: Message.commandJson = {
-        id: "agg-1",
-        meta: evtMapTestMeta,
-        commandJson: JSON.Encode.string("Cmd"),
-      }
-      mockCommonHandler :=
-        async _ => (Promise.resolve([cmd]), [Counter.Count(countItem)])
-      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
-      expect((
-        capturedCmds.contents->Array.length,
-        capturedCountItems.contents->Array.length,
-      ))->toEqual((1, 1))
-    })
+    testPromise(
+      "both publish and count called",
+      async () => {
+        let countItem: ReventlessInfra.Counter.countItem = {
+          counterId: "c1",
+          reference: "ref-1",
+          inc: 2,
+        }
+        let cmd: Message.commandJson = {
+          id: "agg-1",
+          meta: evtMapTestMeta,
+          commandJson: JSON.Encode.string("Cmd"),
+        }
+        mockCommonHandler := (async _ => (Promise.resolve([cmd]), [Counter.Count(countItem)]))
+        await TestECHandler.handleJsonEvents(
+          Stream.fromIterable([JSON.Encode.null]),
+        )->Effect.runPromise
+        expect((
+          capturedCmds.contents->Array.length,
+          capturedCountItems.contents->Array.length,
+        ))->toEqual((1, 1))
+      },
+    )
   })
 
   describe("doCount retry", () => {
-    testPromise("retries when count throws, eventually succeeds", async () => {
-      let countItem: ReventlessInfra.Counter.countItem = {
-        counterId: "c1",
-        reference: "ref-1",
-        inc: 1,
-      }
-      // Fail on first call, succeed on second
-      mockCountFailUntil := 1
-      mockCommonHandler :=
-        async _ => (Promise.resolve([]), [Counter.Count(countItem)])
-      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
-      // count was called at least twice (1 failure + 1 success)
-      expect(mockCountCallCount.contents >= 2)->toBe(true)
-    })
+    testPromise(
+      "retries when count throws, eventually succeeds",
+      async () => {
+        let countItem: ReventlessInfra.Counter.countItem = {
+          counterId: "c1",
+          reference: "ref-1",
+          inc: 1,
+        }
+        // Fail on first call, succeed on second
+        mockCountFailUntil := 1
+        mockCommonHandler := (async _ => (Promise.resolve([]), [Counter.Count(countItem)]))
+        await TestECHandler.handleJsonEvents(
+          Stream.fromIterable([JSON.Encode.null]),
+        )->Effect.runPromise
+        // count was called at least twice (1 failure + 1 success)
+        expect(mockCountCallCount.contents >= 2)->toBe(true)
+      },
+    )
   })
 })

package/tests/eventmapper/EventMapperFixtures.res

@@ -1,6 +1,5 @@
 open Reventless.Projection
 
-
 // ─────────────────────────────────────────────────────────────
 // Source event spec (aggregate events)
 // ─────────────────────────────────────────────────────────────
@@ -63,11 +62,11 @@ let testMeta: Reventless.Message.meta = {
   correlationId: "corr-001",
 }
 
-let makeSourceEvent' = (id, event) => ({
+let makeSourceEvent' = (id, event): Reventless.Message.event'<string, SourceSpec.event> => {
   Reventless.Message.id,
   meta: testMeta,
   event,
-}: Reventless.Message.event'<string, SourceSpec.event>)
+}
 
 // ─────────────────────────────────────────────────────────────
 // EventMapper_Callback test fixtures
@@ -103,14 +102,13 @@ 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>> =>
+  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}))]
+    | OrderPlaced({orderId, amount}) => [
+        Reventless.EventMapping.Publish(id, CmdTargetSpec.ProcessOrder({orderId, amount})),
+      ]
     | OrderShipped({orderId}) =>
       let cmd = CmdTargetSpec.ShipOrder({orderId: orderId})
       [Reventless.EventMapping.Publish(id, cmd)]
@@ -122,15 +120,12 @@ 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>> =>
+  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(_) =>
-      [
+    | OrderShipped(_) => [
         Reventless.EventMapping.AddToCounterTarget({
           counterId: "order-counter",
           target: 5,
@@ -191,10 +186,7 @@ module TestCounterHandler = EventMapper_Callback.MakeCounterHandler(
 
 // configurable mock for commonEventsHandler — reassigned in each test
 let mockCommonHandler: ref<
-  array<JSON.t> => promise<(
-    promise<array<Reventless.Message.commandJson>>,
-    array<Counter.action>,
-  )>,
+  array<JSON.t> => promise<(promise<array<Reventless.Message.commandJson>>, array<Counter.action>)>,
 > = ref(async _ => (Promise.resolve([]), []))
 
 let mockCountFailUntil = ref(0)
@@ -237,7 +229,7 @@ let makeEventJson = (~service=CmdSourceSpec.name, id, eventJson): JSON.t =>
     ("id", JSON.Encode.string(id)),
     (
       "meta",
-      {...evtMapTestMeta, service: service}->Reventless.Message.encode(Reventless.Message.metaSchema),
+      {...evtMapTestMeta, service}->Reventless.Message.encode(Reventless.Message.metaSchema),
     ),
     ("event", eventJson),
   ]
@@ -250,5 +242,5 @@ let resetMocks = () => {
   capturedCounterTargets := []
   mockCountFailUntil := 0
   mockCountCallCount := 0
-  mockCommonHandler := async _ => (Promise.resolve([]), [])
+  mockCommonHandler := (async _ => (Promise.resolve([]), []))
 }

package/tests/eventmapper/EventMapperTest.res

@@ -4,50 +4,66 @@ open EventMapperFixtures
 
 describe("Mapping.Make:", () => {
   describe("sourceName", () => {
-    testSync("equals source spec name", () =>
-      expect(ItemMapping.sourceName)->toBe("SourceAggregate")
+    testSync(
+      "equals source spec name",
+      () => expect(ItemMapping.sourceName)->toBe("SourceAggregate"),
     )
   })
 
   describe("project", () => {
-    testSync("ItemCreated maps to Create action", () => {
-      let event' = makeSourceEvent'("item-1", SourceSpec.ItemCreated({name: "Widget", price: 9.99}))
-      let action = ItemMapping.project(event')
-      switch action {
-      | Create(id, state) =>
-        expect((id, state.name, state.price))->toEqual(("item-1", "Widget", 9.99))
-      | _ => fail("Expected Create action")
-      }
-    })
+    testSync(
+      "ItemCreated maps to Create action",
+      () => {
+        let event' = makeSourceEvent'(
+          "item-1",
+          SourceSpec.ItemCreated({name: "Widget", price: 9.99}),
+        )
+        let action = ItemMapping.project(event')
+        switch action {
+        | Create(id, state) =>
+          expect((id, state.name, state.price))->toEqual(("item-1", "Widget", 9.99))
+        | _ => fail("Expected Create action")
+        }
+      },
+    )
 
-    testSync("ItemPriceUpdated maps to Update action", () => {
-      let event' = makeSourceEvent'("item-1", SourceSpec.ItemPriceUpdated({newPrice: 14.99}))
-      let action = ItemMapping.project(event')
-      switch action {
-      | Update(id, _) => expect(id)->toBe("item-1")
-      | _ => fail("Expected Update action")
-      }
-    })
+    testSync(
+      "ItemPriceUpdated maps to Update action",
+      () => {
+        let event' = makeSourceEvent'("item-1", SourceSpec.ItemPriceUpdated({newPrice: 14.99}))
+        let action = ItemMapping.project(event')
+        switch action {
+        | Update(id, _) => expect(id)->toBe("item-1")
+        | _ => fail("Expected Update action")
+        }
+      },
+    )
 
-    testSync("ItemRemoved maps to Delete action", () => {
-      let event' = makeSourceEvent'("item-1", SourceSpec.ItemRemoved)
-      let action = ItemMapping.project(event')
-      switch action {
-      | Delete(id) => expect(id)->toBe("item-1")
-      | _ => fail("Expected Delete action")
-      }
-    })
+    testSync(
+      "ItemRemoved maps to Delete action",
+      () => {
+        let event' = makeSourceEvent'("item-1", SourceSpec.ItemRemoved)
+        let action = ItemMapping.project(event')
+        switch action {
+        | Delete(id) => expect(id)->toBe("item-1")
+        | _ => fail("Expected Delete action")
+        }
+      },
+    )
 
-    testSync("Update action applies function correctly", () => {
-      let event' = makeSourceEvent'("item-1", SourceSpec.ItemPriceUpdated({newPrice: 14.99}))
-      let action = ItemMapping.project(event')
-      switch action {
-      | Update(_, fn) =>
-        let originalState: TargetSpec.state = {name: "Widget", price: 9.99}
-        let updated = fn(originalState)
-        expect(updated.price)->toBe(14.99)
-      | _ => fail("Expected Update action")
-      }
-    })
+    testSync(
+      "Update action applies function correctly",
+      () => {
+        let event' = makeSourceEvent'("item-1", SourceSpec.ItemPriceUpdated({newPrice: 14.99}))
+        let action = ItemMapping.project(event')
+        switch action {
+        | Update(_, fn) =>
+          let originalState: TargetSpec.state = {name: "Widget", price: 9.99}
+          let updated = fn(originalState)
+          expect(updated.price)->toBe(14.99)
+        | _ => fail("Expected Update action")
+        }
+      },
+    )
   })
 })

package/tests/eventtopic/EventTopicFixtures.res

@@ -1,11 +1,10 @@
-
 // Test event spec for EventTopic
 module ItemEventTopicSpec = {
   module Id = Reventless.Id.StringPure
   let name = "TestItemEventTopic"
 
   @schema
-  type event = | ItemPublished({name: string}) | ItemRemoved({id: string})
+  type event = ItemPublished({name: string}) | ItemRemoved({id: string})
 }
 
 // Captured publish calls
@@ -24,11 +23,11 @@ let testMeta: Message.meta = {
   correlationId: "corr-001",
 }
 
-let makeEvent' = (id, event) => ({
+let makeEvent' = (id, event): Message.event'<string, ItemEventTopicSpec.event> => {
   Reventless.Message.id,
   meta: testMeta,
   event,
-}: Message.event'<string, ItemEventTopicSpec.event>)
+}
 
 let reset = () => {
   capturedCalls := []

package/tests/eventtopic/EventTopicOperationsTest.res

@@ -12,37 +12,49 @@ let _ = beforeEach(() => reset())
 
 describe("EventTopic_Operations:", () => {
   describe("publish", () => {
-    testPromise("calls publishJson for each event", async () => {
-      let events = [
-        makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"})),
-        makeEvent'("item-2", ItemEventTopicSpec.ItemRemoved({id: "item-2"})),
-      ]
-      await Ops.publish(events)
-      expect(capturedCalls.contents->Array.length)->toBe(2)
-    })
+    testPromise(
+      "calls publishJson for each event",
+      async () => {
+        let events = [
+          makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"})),
+          makeEvent'("item-2", ItemEventTopicSpec.ItemRemoved({id: "item-2"})),
+        ]
+        await Ops.publish(events)
+        expect(capturedCalls.contents->Array.length)->toBe(2)
+      },
+    )
 
-    testPromise("calls publishJson with correct service (id string)", async () => {
-      let event' = makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"}))
-      await Ops.publish([event'])
-      let first = capturedCalls.contents->Array.getUnsafe(0)
-      let (service, _, _) = first
-      expect(service)->toBe("item-1")
-    })
+    testPromise(
+      "calls publishJson with correct service (id string)",
+      async () => {
+        let event' = makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"}))
+        await Ops.publish([event'])
+        let first = capturedCalls.contents->Array.getUnsafe(0)
+        let (service, _, _) = first
+        expect(service)->toBe("item-1")
+      },
+    )
 
-    testPromise("publishes empty array without error", async () => {
-      await Ops.publish([])
-      expect(capturedCalls.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "publishes empty array without error",
+      async () => {
+        await Ops.publish([])
+        expect(capturedCalls.contents->Array.length)->toBe(0)
+      },
+    )
 
-    testPromise("encodes event with correct JSON structure", async () => {
-      let event' = makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"}))
-      await Ops.publish([event'])
-      let (_, _, json) = capturedCalls.contents->Array.getUnsafe(0)
-      // JSON should contain the event type info
-      let hasExpectedFields =
-        json->JSON.Decode.object->Option.map(d => d->Dict.has("event"))->Option.getOr(false) ||
-        json->JSON.Decode.object->Option.map(d => d->Dict.has("id"))->Option.getOr(false)
-      expect(hasExpectedFields)->toBe(true)
-    })
+    testPromise(
+      "encodes event with correct JSON structure",
+      async () => {
+        let event' = makeEvent'("item-1", ItemEventTopicSpec.ItemPublished({name: "Widget"}))
+        await Ops.publish([event'])
+        let (_, _, json) = capturedCalls.contents->Array.getUnsafe(0)
+        // JSON should contain the event type info
+        let hasExpectedFields =
+          json->JSON.Decode.object->Option.map(d => d->Dict.has("event"))->Option.getOr(false) ||
+            json->JSON.Decode.object->Option.map(d => d->Dict.has("id"))->Option.getOr(false)
+        expect(hasExpectedFields)->toBe(true)
+      },
+    )
   })
 })