@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.250

package/tests/components/eventlog/EventLogStreamTest.res

@@ -13,86 +13,149 @@ describe("EventLog.replayStream (in-memory adapter)", () => {
   let _ = beforeEach(() => reset())
 
   describe("basic streaming", () => {
-    testPromise("replayStream returns all appended events", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(0, "stream-1", [makeEvent'("stream-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))])
-      let _ = await ops.append(1, "stream-1", [makeEvent'("stream-1", ItemEventLogSpec.ItemDeleted({id: "stream-1"}))])
-      let count = await ops.replayStream("stream-1")
+    testPromise(
+      "replayStream returns all appended events",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "stream-1",
+          [makeEvent'("stream-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))],
+        )
+        let _ = await ops.append(
+          1,
+          "stream-1",
+          [makeEvent'("stream-1", ItemEventLogSpec.ItemDeleted({id: "stream-1"}))],
+        )
+        let count = await ops.replayStream("stream-1")
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      expect(count)->toBe(2)
-    })
+        expect(count)->toBe(2)
+      },
+    )
 
-    testPromise("replayStream for unknown id returns empty stream", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let count = await ops.replayStream("no-such-id")
+    testPromise(
+      "replayStream for unknown id returns empty stream",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let count = await ops.replayStream("no-such-id")
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      expect(count)->toBe(0)
-    })
+        expect(count)->toBe(0)
+      },
+    )
 
-    testPromise("replayStream emits events in append order", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(0, "stream-2", [makeEvent'("stream-2", ItemEventLogSpec.ItemCreated({name: "First"}))])
-      let _ = await ops.append(1, "stream-2", [makeEvent'("stream-2", ItemEventLogSpec.ItemDeleted({id: "stream-2"}))])
-      let events = await ops.replayStream("stream-2")
+    testPromise(
+      "replayStream emits events in append order",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "stream-2",
+          [makeEvent'("stream-2", ItemEventLogSpec.ItemCreated({name: "First"}))],
+        )
+        let _ = await ops.append(
+          1,
+          "stream-2",
+          [makeEvent'("stream-2", ItemEventLogSpec.ItemDeleted({id: "stream-2"}))],
+        )
+        let events = await ops.replayStream("stream-2")
         ->Stream.runCollect
         ->Effect.runPromise
-      expect(events->Array.length)->toBe(2)
-      // First emitted is the Created event
-      let first = events->Array.getUnsafe(0)
-      expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "First"}))
-    })
+        expect(events->Array.length)->toBe(2)
+        // First emitted is the Created event
+        let first = events->Array.getUnsafe(0)
+        expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "First"}))
+      },
+    )
 
-    testPromise("separate aggregate IDs have independent streams", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(0, "agg-X", [makeEvent'("agg-X", ItemEventLogSpec.ItemCreated({name: "X"}))])
-      let _ = await ops.append(0, "agg-Y", [makeEvent'("agg-Y", ItemEventLogSpec.ItemCreated({name: "Y1"})), makeEvent'("agg-Y", ItemEventLogSpec.ItemDeleted({id: "agg-Y"}))])
-      let countX = await ops.replayStream("agg-X")
+    testPromise(
+      "separate aggregate IDs have independent streams",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "agg-X",
+          [makeEvent'("agg-X", ItemEventLogSpec.ItemCreated({name: "X"}))],
+        )
+        let _ = await ops.append(
+          0,
+          "agg-Y",
+          [
+            makeEvent'("agg-Y", ItemEventLogSpec.ItemCreated({name: "Y1"})),
+            makeEvent'("agg-Y", ItemEventLogSpec.ItemDeleted({id: "agg-Y"})),
+          ],
+        )
+        let countX = await ops.replayStream("agg-X")
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      let countY = await ops.replayStream("agg-Y")
+        let countY = await ops.replayStream("agg-Y")
         ->Stream.runFold(0, (n, _) => n + 1)
         ->Effect.runPromise
-      expect(countX)->toBe(1)
-      expect(countY)->toBe(2)
-    })
+        expect(countX)->toBe(1)
+        expect(countY)->toBe(2)
+      },
+    )
 
-    testPromise("take(2) on a 5-event log returns only 2 events", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(0, "stream-3", [
-        makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e1"})),
-        makeEvent'("stream-3", ItemEventLogSpec.ItemDeleted({id: "e2"})),
-        makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e3"})),
-        makeEvent'("stream-3", ItemEventLogSpec.ItemDeleted({id: "e4"})),
-        makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e5"})),
-      ])
-      let first2 = await ops.replayStream("stream-3")
+    testPromise(
+      "take(2) on a 5-event log returns only 2 events",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "stream-3",
+          [
+            makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e1"})),
+            makeEvent'("stream-3", ItemEventLogSpec.ItemDeleted({id: "e2"})),
+            makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e3"})),
+            makeEvent'("stream-3", ItemEventLogSpec.ItemDeleted({id: "e4"})),
+            makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e5"})),
+          ],
+        )
+        let first2 = await ops.replayStream("stream-3")
         ->Stream.take(2)
         ->Stream.runCollect
         ->Effect.runPromise
-      expect(first2->Array.length)->toBe(2)
-    })
+        expect(first2->Array.length)->toBe(2)
+      },
+    )
   })
 
   describe("tuple fold — (state, count) pattern used in Aggregate_Callback", () => {
-    testPromise("runFold produces correct count for sequenceNr", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let _ = await ops.append(0, "fold-1", [makeEvent'("fold-1", ItemEventLogSpec.ItemCreated({name: "e1"})), makeEvent'("fold-1", ItemEventLogSpec.ItemDeleted({id: "e2"}))])
-      let _ = await ops.append(2, "fold-1", [makeEvent'("fold-1", ItemEventLogSpec.ItemCreated({name: "e3"}))])
-      let (_state, count) = await ops.replayStream("fold-1")
+    testPromise(
+      "runFold produces correct count for sequenceNr",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let _ = await ops.append(
+          0,
+          "fold-1",
+          [
+            makeEvent'("fold-1", ItemEventLogSpec.ItemCreated({name: "e1"})),
+            makeEvent'("fold-1", ItemEventLogSpec.ItemDeleted({id: "e2"})),
+          ],
+        )
+        let _ = await ops.append(
+          2,
+          "fold-1",
+          [makeEvent'("fold-1", ItemEventLogSpec.ItemCreated({name: "e3"}))],
+        )
+        let (_state, count) = await ops.replayStream("fold-1")
         ->Stream.runFold((None, 0), ((st, n), _ev) => (st, n + 1))
         ->Effect.runPromise
-      expect(count)->toBe(3)
-    })
+        expect(count)->toBe(3)
+      },
+    )
 
-    testPromise("runFold on empty stream returns initial accumulator", async () => {
-      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-      let (state, count) = await ops.replayStream("unknown-fold")
+    testPromise(
+      "runFold on empty stream returns initial accumulator",
+      async () => {
+        let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+        let (state, count) = await ops.replayStream("unknown-fold")
         ->Stream.runFold((None, 0), ((st, n), _ev) => (st, n + 1))
         ->Effect.runPromise
-      expect(state)->toEqual(None)
-      expect(count)->toBe(0)
-    })
+        expect(state)->toEqual(None)
+        expect(count)->toBe(0)
+      },
+    )
   })
 })

package/tests/components/eventlog/EventLogTest.res

@@ -36,16 +36,32 @@ describe("EventLog (in-memory)", () => {
 
   testPromise("multiple appends accumulate events", async () => {
     let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-    let _ = await ops.append(0, "agg-1", [makeEvent'("agg-1", ItemEventLogSpec.ItemCreated({name: "First"}))])
-    let _ = await ops.append(1, "agg-1", [makeEvent'("agg-1", ItemEventLogSpec.ItemDeleted({id: "agg-1"}))])
+    let _ = await ops.append(
+      0,
+      "agg-1",
+      [makeEvent'("agg-1", ItemEventLogSpec.ItemCreated({name: "First"}))],
+    )
+    let _ = await ops.append(
+      1,
+      "agg-1",
+      [makeEvent'("agg-1", ItemEventLogSpec.ItemDeleted({id: "agg-1"}))],
+    )
     let replayed = await ops.replay("agg-1")
     expect(replayed->Array.length)->toBe(2)
   })
 
   testPromise("separate aggregates have independent event logs", async () => {
     let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-    let _ = await ops.append(0, "agg-A", [makeEvent'("agg-A", ItemEventLogSpec.ItemCreated({name: "A"}))])
-    let _ = await ops.append(0, "agg-B", [makeEvent'("agg-B", ItemEventLogSpec.ItemDeleted({id: "B"}))])
+    let _ = await ops.append(
+      0,
+      "agg-A",
+      [makeEvent'("agg-A", ItemEventLogSpec.ItemCreated({name: "A"}))],
+    )
+    let _ = await ops.append(
+      0,
+      "agg-B",
+      [makeEvent'("agg-B", ItemEventLogSpec.ItemDeleted({id: "B"}))],
+    )
     let eventsA = await ops.replay("agg-A")
     let eventsB = await ops.replay("agg-B")
     expect((eventsA->Array.length, eventsB->Array.length))->toEqual((1, 1))

package/tests/components/eventtopic/EventTopicFixtures.res

@@ -7,7 +7,7 @@ module ItemEventTopicSpec = {
   let name = "TestItemEventTopic"
 
   @schema
-  type event = | ItemPublished({name: string}) | ItemRemoved({id: string})
+  type event = ItemPublished({name: string}) | ItemRemoved({id: string})
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -36,11 +36,11 @@ module EventTopicMaker = ReventlessCore.EventTopic_Builder.Make(
 
 let eventTopic = EventTopicMaker.make(~name="TestItemEventTopic", ~storageResources=[])
 
-let makeEvent' = (id, event) => ({
+let makeEvent' = (id, event): Reventless.Message.event'<string, ItemEventTopicSpec.event> => {
   Reventless.Message.id,
   meta: testMeta,
   event,
-}: Reventless.Message.event'<string, ItemEventTopicSpec.event>)
+}
 
 let reset = () => {
   capturedEventCount := 0

package/tests/components/eventtopic/EventTopicStreamFixtures.res

@@ -5,7 +5,7 @@ module ItemStreamSpec = {
   let name = "StreamEvtItem"
 
   @schema
-  type event = | ItemPublished({name: string}) | ItemRemoved({id: string})
+  type event = ItemPublished({name: string}) | ItemRemoved({id: string})
 }
 
 module StreamEvtBus = LocalBus.Make()
@@ -24,4 +24,3 @@ module StreamEvtTopicMaker = ReventlessCore.EventTopic_Builder.Make(
 )
 
 let evtTopic = StreamEvtTopicMaker.make(~name="StreamEvtTopic", ~storageResources=[])
-

package/tests/components/eventtopic/EventTopicStreamTest.res

@@ -17,7 +17,13 @@ describe("EventTopic.publishJsonStream", () => {
   testPromise("streams 2 events to all subscribers", async () => {
     let ops = await evtTopic->ReventlessCore.Component.operations->TestRunner.resolve
     let stream = [
-      ({service: "svc", meta: testMeta, json: JSON.parseOrThrow("{\"ev\":1}")}: ReventlessInfra.EventTopic.publishJsonStreamItem),
+      (
+        {
+          service: "svc",
+          meta: testMeta,
+          json: JSON.parseOrThrow("{\"ev\":1}"),
+        }: ReventlessInfra.EventTopic.publishJsonStreamItem
+      ),
       {service: "svc", meta: testMeta, json: JSON.parseOrThrow("{\"ev\":2}")},
     ]->Stream.fromIterable
     let _ = await ops.publishJsonStream(stream)->Effect.runPromise

package/tests/components/extensionpoint/ExtensionPointFixtures.res

@@ -3,7 +3,6 @@
 
 open TestFixtures
 
-
 // ─────────────────────────────────────────────────────────────
 // Isolated bus + Pulumi mock mode
 // ─────────────────────────────────────────────────────────────
@@ -20,13 +19,13 @@ module TestEPSpec = {
   let name = "TestEP"
 
   @schema
-  type command = | Forward({targetId: string})
+  type command = Forward({targetId: string})
 
   @schema
-  type event = | TEPNoEvent // unused — mapOutgoingEvent = None
+  type event = TEPNoEvent // unused — mapOutgoingEvent = None
 
   @schema
-  type directive = | TEPNoDirective // unused — mapIncomingCommand only uses PublishCommand
+  type directive = TEPNoDirective // unused — mapIncomingCommand only uses PublishCommand
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -40,13 +39,13 @@ module DelegateAggSpec = {
   let name = "TargetAgg"
 
   @schema
-  type command = | Execute({targetId: string})
+  type command = Execute({targetId: string})
 
   @schema
-  type event = | Executed({targetId: string}) // unused but required by Aggregate.Spec
+  type event = Executed({targetId: string}) // unused but required by Aggregate.Spec
 
   @schema
-  type error = | TEAggNoError // unused but required by Aggregate.Spec
+  type error = TEAggNoError // unused but required by Aggregate.Spec
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -65,7 +64,12 @@ module ForwardMapping = {
     _id: string,
     cmd: TestEPSpec.command,
     _meta: Reventless.Message.meta,
-  ): array<ReventlessInfra.ExtensionPointMapping.commandAction<DelegateAggSpec.command, TestEPSpec.directive>> =>
+  ): array<
+    ReventlessInfra.ExtensionPointMapping.commandAction<
+      DelegateAggSpec.command,
+      TestEPSpec.directive,
+    >,
+  > =>
     switch cmd {
     | Forward({targetId}) =>
       let execCmd = DelegateAggSpec.Execute({targetId: targetId})
@@ -93,7 +97,8 @@ module TestEPMapping1 = ReventlessInfra.ExtensionPointMapping.Make(ForwardMappin
 
 module TestEPMappings = {
   module Spec = TestEPSpec
-  module type Mapping = ReventlessInfra.ExtensionPointMapping.T with module ExtensionPoint := TestEPSpec
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T
+    with module ExtensionPoint := TestEPSpec
   let name = "TestEPMappings"
   let moduleUrl: string = %raw(`import.meta.url`)
   let mappings: array<module(Mapping)> = [module(TestEPMapping1)]

package/tests/components/extensionpoint/ExtensionPointTest.res

@@ -29,8 +29,9 @@ describe("ExtensionPoint (in-memory)", () => {
     async () => {
       // Build the full command body: {id, meta, command}
       let forwardCmdJson =
-        TestEPSpec.Forward({targetId: "target-1"})
-        ->Reventless.Util_Sury.toJson(TestEPSpec.commandSchema)
+        TestEPSpec.Forward({targetId: "target-1"})->Reventless.Util_Sury.toJson(
+          TestEPSpec.commandSchema,
+        )
       let body = JSON.Encode.object(
         Dict.fromArray([
           ("id", JSON.Encode.string("ep-id-1")),

package/tests/components/heartbeat/HeartbeatFixtures.res

@@ -38,11 +38,10 @@ let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
 let resolvedHandler: ref<option<(unit, unit) => promise<unit>>> = ref(None)
 
 let _ = beforeAllAsync(async () => {
-  let h =
-    await HeartbeatMaker.makeHandler(
-      ~id="hb-id-1",
-      ~timeout=1,
-      ~publishToPluginExtensionPoint=mockPublish,
-    )->TestRunner.resolve
+  let h = await HeartbeatMaker.makeHandler(
+    ~id="hb-id-1",
+    ~timeout=1,
+    ~publishToPluginExtensionPoint=mockPublish,
+  )->TestRunner.resolve
   resolvedHandler := Some(h)
 })

package/tests/components/heartbeat/HeartbeatTest.res

@@ -12,56 +12,65 @@ describe("Heartbeat_Builder.Make:", () => {
   })
 
   describe("makeHandler + connect:", () => {
-    testPromise("handler fires once after 1-minute interval", async () => {
-      let handler = resolvedHandler.contents->Option.getUnsafe
-      let heartbeat = HeartbeatMaker.make(~name="hb-test-1")
-      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
-        Deferred.make()->Effect.runSync
-      Deferred.succeed(handlerDeferred, Obj.magic(handler))->Effect.runSync->ignore
-      let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
-        parts: {
-          handlerDeferred,
-          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
-        },
-        resources: [],
-      }
-      HeartbeatMaker.connect(~runtime, ~remoteChannel=Obj.magic(()), ~timeout=1, heartbeat)
-      jest->advanceTimersByTime(1 * 60 * 1000)
-      // Give the Effect.runPromise microtask one tick to complete
-      let _ = await Promise.resolve()
-      expect(capturedCount.contents)->toBe(1)
-      LocalHeartbeatRunner.reset()
-    })
+    testPromise(
+      "handler fires once after 1-minute interval",
+      async () => {
+        let handler = resolvedHandler.contents->Option.getUnsafe
+        let heartbeat = HeartbeatMaker.make(~name="hb-test-1")
+        let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+          Deferred.make()->Effect.runSync
+        Deferred.succeed(handlerDeferred, Obj.magic(handler))->Effect.runSync->ignore
+        let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
+          parts: {
+            handlerDeferred,
+            subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+          },
+          resources: [],
+        }
+        HeartbeatMaker.connect(~runtime, ~remoteChannel=Obj.magic(), ~timeout=1, heartbeat)
+        jest->advanceTimersByTime(1 * 60 * 1000)
+        // Give the Effect.runPromise microtask one tick to complete
+        let _ = await Promise.resolve()
+        expect(capturedCount.contents)->toBe(1)
+        LocalHeartbeatRunner.reset()
+      },
+    )
 
-    testPromise("handler fires twice after two interval advances", async () => {
-      let handler = resolvedHandler.contents->Option.getUnsafe
-      let heartbeat = HeartbeatMaker.make(~name="hb-test-2")
-      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
-        Deferred.make()->Effect.runSync
-      Deferred.succeed(handlerDeferred, Obj.magic(handler))->Effect.runSync->ignore
-      let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
-        parts: {
-          handlerDeferred,
-          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
-        },
-        resources: [],
-      }
-      HeartbeatMaker.connect(~runtime, ~remoteChannel=Obj.magic(()), ~timeout=1, heartbeat)
-      jest->advanceTimersByTime(1 * 60 * 1000)
-      let _ = await Promise.resolve()
-      jest->advanceTimersByTime(1 * 60 * 1000)
-      let _ = await Promise.resolve()
-      expect(capturedCount.contents)->toBe(2)
-      LocalHeartbeatRunner.reset()
-    })
+    testPromise(
+      "handler fires twice after two interval advances",
+      async () => {
+        let handler = resolvedHandler.contents->Option.getUnsafe
+        let heartbeat = HeartbeatMaker.make(~name="hb-test-2")
+        let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+          Deferred.make()->Effect.runSync
+        Deferred.succeed(handlerDeferred, Obj.magic(handler))->Effect.runSync->ignore
+        let runtime: ReventlessCore.Runtime.environment<LocalHeartbeatRunner.runtimeParts> = {
+          parts: {
+            handlerDeferred,
+            subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+          },
+          resources: [],
+        }
+        HeartbeatMaker.connect(~runtime, ~remoteChannel=Obj.magic(), ~timeout=1, heartbeat)
+        jest->advanceTimersByTime(1 * 60 * 1000)
+        let _ = await Promise.resolve()
+        jest->advanceTimersByTime(1 * 60 * 1000)
+        let _ = await Promise.resolve()
+        expect(capturedCount.contents)->toBe(2)
+        LocalHeartbeatRunner.reset()
+      },
+    )
   })
 
   describe("make:", () => {
-    testPromise("creates a heartbeat component without throwing", async () => {
-      let heartbeat = HeartbeatMaker.make(~name="hb-make-smoke")
-      // Just verify component creation succeeds
-      let _ = heartbeat
-      expect(true)->toBe(true)
-    })
+    testPromise(
+      "creates a heartbeat component without throwing",
+      async () => {
+        let heartbeat = HeartbeatMaker.make(~name="hb-make-smoke")
+        // Just verify component creation succeeds
+        let _ = heartbeat
+        expect(true)->toBe(true)
+      },
+    )
   })
 })