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

package/tests/aggregate/AggregateCacheTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-
 module AggSpec = {
   module Id = Reventless.Id.StringPure
   let name = "CacheTestAggregate"
@@ -29,7 +28,7 @@ module AggSpec = {
     | CheckpointTaken({count: int})
 
   @schema
-  type error = | Never
+  type error = Never
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -103,7 +102,7 @@ let makeMockEL = (): mockEL => {
       Error(EventLog.Conflict)
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
-      Ok(())
+      Ok()
     }
   }
 
@@ -155,11 +154,11 @@ module TestOps = {
       ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
-      appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<
-        unit,
+      appendStream: (
+        int,
         string,
-        unit,
-      >,
+        Stream.t<AggSpec.event, string, unit>,
+      ) => Effect.t<unit, string, unit>,
       latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
@@ -223,14 +222,13 @@ describe("Aggregate_Callback — replay cache:", () => {
     let _ = await run(AggSpec.Checkpoint)
     expect(mock.replayCallCount.contents)->toBe(2)
     // Both checkpoints observed the same state — cached fold ≡ replayed fold.
-    let checkpoints =
-      mock.getAll()
-      ->Array.filterMap(e =>
+    let checkpoints = mock.getAll()->Array.filterMap(
+      e =>
         switch e.event {
         | CheckpointTaken({count}) => Some(count)
         | _ => None
-        }
-      )
+        },
+    )
     expect(checkpoints)->toEqual([3, 3])
   })
 

package/tests/aggregate/AggregateCallbackTest.res

@@ -8,77 +8,106 @@ let _ = beforeEach(() => {
 
 describe("Aggregate_Callback.handleCommands:", () => {
   describe("single command — new aggregate", () => {
-    testPromise("Create returns Ok(reference) and stores 1 event", async () => {
-      let results = await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 1))
-    })
+    testPromise(
+      "Create returns Ok(reference) and stores 1 event",
+      async () => {
+        let results = await Stream.fromIterable([
+          makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 1))
+      },
+    )
   })
 
   describe("command on existing aggregate", () => {
-    testPromise("Rename after Create replays history and appends new event", async () => {
-      let _ =
-        await Stream.fromIterable([
+    testPromise(
+      "Rename after Create replays history and appends new event",
+      async () => {
+        let _ = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      let results =
-        await Stream.fromIterable([
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-2", AggSpec.Rename({newName: "Gadget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-2")], 2))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-2")], 2))
+      },
+    )
   })
 
   describe("behavior returns no events", () => {
-    testPromise("Rename on new aggregate returns Ok with no event stored", async () => {
-      // Rename on empty history: Behavior.decide(NotCreated, Rename) returns Error(NotFound)
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "Rename on new aggregate returns Ok with no event stored",
+      async () => {
+        // Rename on empty history: Behavior.decide(NotCreated, Rename) returns Error(NotFound)
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Rename({newName: "Gadget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 0))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 0))
+      },
+    )
   })
 
   describe("append failure", () => {
-    testPromise("eventLog.append fails → reference returned Error", async () => {
-      mock.failNextAppend := true
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "eventLog.append fails → reference returned Error",
+      async () => {
+        mock.failNextAppend := true
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect(results)->toEqual([Error("ref-1")])
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect(results)->toEqual([Error("ref-1")])
+      },
+    )
   })
 
   describe("multiple commands for same aggregate ID", () => {
-    testPromise("Create then Rename in one batch accumulate state correctly", async () => {
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "Create then Rename in one batch accumulate state correctly",
+      async () => {
+        let results = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-1", "ref-1", AggSpec.Create({name: "Widget"})),
           makeTopicItem(~aggId="agg-1", "ref-2", AggSpec.Rename({newName: "Gadget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      // Both commands for same ID processed sequentially
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1"), Ok("ref-2")], 2))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        // Both commands for same ID processed sequentially
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1"), Ok("ref-2")], 2))
+      },
+    )
   })
 
   describe("commands for different aggregate IDs", () => {
-    testPromise("each ID processed independently", async () => {
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "each ID processed independently",
+      async () => {
+        let results = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-a", "ref-a", AggSpec.Create({name: "Alpha"})),
           makeTopicItem(~aggId="agg-b", "ref-b", AggSpec.Create({name: "Beta"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results->Array.length, mock.getAll()->Array.length))->toEqual((2, 2))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results->Array.length, mock.getAll()->Array.length))->toEqual((2, 2))
+      },
+    )
   })
 
   describe("empty batch", () => {
-    testPromise("returns empty array", async () => {
-      let results = await Stream.fromIterable([])->TestHandler.handleCommands->Effect.runPromise
-      expect(results)->toEqual([])
-    })
+    testPromise(
+      "returns empty array",
+      async () => {
+        let results = await Stream.fromIterable([])->TestHandler.handleCommands->Effect.runPromise
+        expect(results)->toEqual([])
+      },
+    )
   })
 })

package/tests/aggregate/AggregateCausationTest.res

@@ -15,37 +15,36 @@ let _ = beforeEach(() => {
 
 describe("Aggregate_Callback causation propagation:", () => {
   testPromise("event.meta.causationId = command.meta.msgId", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     let stored = mock.getAll()->Array.getUnsafe(0)
     expect(stored.meta.causationId)->toEqual(Some(testMeta.msgId))
   })
 
-  testPromise("event.meta.correlationId = command.meta.correlationId (chain root stable)", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
-    let stored = mock.getAll()->Array.getUnsafe(0)
-    expect(stored.meta.correlationId)->toBe(testMeta.correlationId)
-  })
+  testPromise(
+    "event.meta.correlationId = command.meta.correlationId (chain root stable)",
+    async () => {
+      let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+      ->TestHandler.handleCommands
+      ->Effect.runPromise
+      let stored = mock.getAll()->Array.getUnsafe(0)
+      expect(stored.meta.correlationId)->toBe(testMeta.correlationId)
+    },
+  )
 
   testPromise("event has a fresh msgId distinct from the command's msgId", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     let stored = mock.getAll()->Array.getUnsafe(0)
     expect(stored.meta.msgId == testMeta.msgId)->toBe(false)
   })
 
   testPromise("event inherits ip / user / service from the command's meta", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     let stored = mock.getAll()->Array.getUnsafe(0)
     expect(stored.meta.service)->toBe(testMeta.service)
   })

package/tests/aggregate/AggregateConflictTest.res

@@ -3,19 +3,18 @@
 
 open JestGlobals
 
-
 module AggSpec = {
   module Id = Reventless.Id.StringPure
   let name = "ConflictTestAggregate"
 
   @schema
-  type command = | Create({name: string})
+  type command = Create({name: string})
 
   @schema
-  type event = | Created({name: string})
+  type event = Created({name: string})
 
   @schema
-  type error = | AlreadyExists
+  type error = AlreadyExists
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -37,14 +36,21 @@ module TestBehavior = {
     | Created({name}) => {name: name}
     }
 
-  let decide = (_state: state, command: AggSpec.command): result<array<AggSpec.event>, AggSpec.error> =>
+  let decide = (_state: state, command: AggSpec.command): result<
+    array<AggSpec.event>,
+    AggSpec.error,
+  > =>
     switch command {
     | Create({name}) => Ok([AggSpec.Created({name: name})])
     }
 }
 
 type mockEL = {
-  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
+  appendFn: (
+    int,
+    string,
+    array<Message.event'<string, AggSpec.event>>,
+  ) => promise<result<unit, EventLog.appendError>>,
   replayFn: string => promise<array<AggSpec.event>>,
   replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
   getAll: unit => array<Message.event'<string, AggSpec.event>>,
@@ -67,7 +73,7 @@ let makeMockEL = (): mockEL => {
       Error(EventLog.Conflict)
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
-      Ok(())
+      Ok()
     }
   }
 
@@ -117,10 +123,18 @@ module TestOps = {
       type event = AggSpec.event
     }
     type operations = {
-      append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
+      append: (
+        int,
+        string,
+        array<Message.event'<string, AggSpec.event>>,
+      ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
-      appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+      appendStream: (
+        int,
+        string,
+        Stream.t<AggSpec.event, string, unit>,
+      ) => Effect.t<unit, string, unit>,
       latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
@@ -169,7 +183,9 @@ describe("Aggregate_Callback — conflict retry:", () => {
     mock.failNextAppendsWithConflict := 1
     let results = await Stream.fromIterable([
       makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-    ])->TestHandler.handleCommands->Effect.runPromise
+    ])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     expect(results)->toEqual([Ok("ref-1")])
     // 1 initial append (conflict) + 1 retry append (success) = 2
     expect(mock.appendCallCount.contents)->toBe(2)
@@ -177,9 +193,9 @@ describe("Aggregate_Callback — conflict retry:", () => {
 
   testPromise("conflict triggers re-replay", async () => {
     mock.failNextAppendsWithConflict := 1
-    let _ = await Stream.fromIterable([
-      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-    ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     // 1 initial replay + 1 retry replay = 2
     expect(mock.replayCallCount.contents)->toBe(2)
   })
@@ -188,7 +204,9 @@ describe("Aggregate_Callback — conflict retry:", () => {
     mock.failNextAppendsWithConflict := 2
     let results = await Stream.fromIterable([
       makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-    ])->TestHandler.handleCommands->Effect.runPromise
+    ])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     expect(results)->toEqual([Ok("ref-1")])
     expect(mock.appendCallCount.contents)->toBe(3)
   })
@@ -198,23 +216,27 @@ describe("Aggregate_Callback — conflict retry:", () => {
     mock.failNextAppendsWithConflict := 4
     let results = await Stream.fromIterable([
       makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-    ])->TestHandler.handleCommands->Effect.runPromise
+    ])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     expect(results)->toEqual([Error("concurrent modification (3 retries exhausted): conflict")])
     expect(mock.appendCallCount.contents)->toBe(4)
   })
 
   testPromise("successful append after conflict stores event", async () => {
     mock.failNextAppendsWithConflict := 1
-    let _ = await Stream.fromIterable([
-      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-    ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     expect(mock.getAll()->Array.length)->toBe(1)
   })
 
   testPromise("no conflict does not retry", async () => {
     let results = await Stream.fromIterable([
       makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-    ])->TestHandler.handleCommands->Effect.runPromise
+    ])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     expect(results)->toEqual([Ok("ref-1")])
     expect(mock.appendCallCount.contents)->toBe(1)
     expect(mock.replayCallCount.contents)->toBe(1)

package/tests/aggregate/AggregateFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Aggregate spec
 // ─────────────────────────────────────────────────────────────
@@ -49,7 +48,10 @@ module TestBehavior = {
     | AggSpec.Renamed({newName}) => Created({name: newName})
     }
 
-  let decide = (state: state, command: AggSpec.command): result<array<AggSpec.event>, AggSpec.error> =>
+  let decide = (state: state, command: AggSpec.command): result<
+    array<AggSpec.event>,
+    AggSpec.error,
+  > =>
     switch (state, command) {
     | (NotCreated, Create({name})) => Ok([AggSpec.Created({name: name})])
     | (NotCreated, Rename(_)) => Error(NotFound)
@@ -63,7 +65,11 @@ module TestBehavior = {
 // ─────────────────────────────────────────────────────────────
 
 type mockEL = {
-  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
+  appendFn: (
+    int,
+    string,
+    array<Message.event'<string, AggSpec.event>>,
+  ) => promise<result<unit, EventLog.appendError>>,
   replayFn: string => promise<array<AggSpec.event>>,
   replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
   getAll: unit => array<Message.event'<string, AggSpec.event>>,
@@ -81,7 +87,7 @@ let makeMockEL = (): mockEL => {
       Error(EventLog.StorageFailure("append failed"))
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
-      Ok(())
+      Ok()
     }
 
   let replayFn = async id =>
@@ -135,7 +141,11 @@ module TestOps = {
       ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
-      appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+      appendStream: (
+        int,
+        string,
+        Stream.t<AggSpec.event, string, unit>,
+      ) => Effect.t<unit, string, unit>,
       latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }