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

package/tests/aggregate/AggregateRejectionTest.res

@@ -34,109 +34,126 @@ let uninstallChannels = () => {
 
 describe("Aggregate decide-rejection propagation:", () => {
   describe("single rejected command", () => {
-    testPromise("Create on existing aggregate reports Rejected with errorCode", async () => {
-      // Seed: aggregate already created → second Create rejects with AlreadyExists.
-      let _ =
-        await Stream.fromIterable([
+    testPromise(
+      "Create on existing aggregate reports Rejected with errorCode",
+      async () => {
+        // Seed: aggregate already created → second Create rejects with AlreadyExists.
+        let _ = await Stream.fromIterable([
           makeTopicItem("ref-seed", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
 
-      installChannels()
-      let results =
-        await Stream.fromIterable([
+        installChannels()
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      uninstallChannels()
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        uninstallChannels()
 
-      // Producer sees Rejected on the channel; SQS sees Ok (delete — don't redeliver).
-      expect(results)->toEqual([Ok("ref-1")])
-      expect(capturedRejections.contents->Array.length)->toBe(1)
-      let (ref, info) = capturedRejections.contents->Array.getUnsafe(0)
-      expect(ref)->toEqual("ref-1")
-      expect(info.errorCode)->toEqual("AlreadyExists")
-      // No event was appended.
-      expect(mock.getAll()->Array.length)->toBe(1)
-    })
+        // Producer sees Rejected on the channel; SQS sees Ok (delete — don't redeliver).
+        expect(results)->toEqual([Ok("ref-1")])
+        expect(capturedRejections.contents->Array.length)->toBe(1)
+        let (ref, info) = capturedRejections.contents->Array.getUnsafe(0)
+        expect(ref)->toEqual("ref-1")
+        expect(info.errorCode)->toEqual("AlreadyExists")
+        // No event was appended.
+        expect(mock.getAll()->Array.length)->toBe(1)
+      },
+    )
   })
 
   describe("mixed batch", () => {
-    testPromise("rejected command does not cancel surviving commands", async () => {
-      // Seed.
-      let _ =
-        await Stream.fromIterable([
+    testPromise(
+      "rejected command does not cancel surviving commands",
+      async () => {
+        // Seed.
+        let _ = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-1", "ref-seed", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
 
-      installChannels()
-      // Batch on the same aggregate: Rename (ok) → Create (rejects) → Rename (ok)
-      let results =
-        await Stream.fromIterable([
+        installChannels()
+        // Batch on the same aggregate: Rename (ok) → Create (rejects) → Rename (ok)
+        let results = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-1", "ref-1", AggSpec.Rename({newName: "First"})),
           makeTopicItem(~aggId="agg-1", "ref-2", AggSpec.Create({name: "Boom"})),
           makeTopicItem(~aggId="agg-1", "ref-3", AggSpec.Rename({newName: "Last"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      uninstallChannels()
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        uninstallChannels()
 
-      // All three references map to Ok (rejected ones still Ok — SQS deletes).
-      expect(results->Array.length)->toBe(3)
-      results->Array.forEach(r =>
-        switch r {
-        | Ok(_) => ()
-        | Error(_) => expect("expected all Ok")->toEqual("got Error")
-        }
-      )
-      // Two Renamed events appended (the rejected Create produced none).
-      // Seed = 1, plus 2 Renamed = 3 stored.
-      expect(mock.getAll()->Array.length)->toBe(3)
-      // ref-2 reported as Rejected with AlreadyExists.
-      let rejected = capturedRejections.contents
-      expect(rejected->Array.length)->toBe(1)
-      let (rRef, rInfo) = rejected->Array.getUnsafe(0)
-      expect(rRef)->toEqual("ref-2")
-      expect(rInfo.errorCode)->toEqual("AlreadyExists")
-      // ref-1 and ref-3 reported as Accepted (eventCount > 0 against the appended batch).
-      let accepted = capturedAccepts.contents
-      expect(accepted->Array.length)->toBe(2)
-    })
+        // All three references map to Ok (rejected ones still Ok — SQS deletes).
+        expect(results->Array.length)->toBe(3)
+        results->Array.forEach(
+          r =>
+            switch r {
+            | Ok(_) => ()
+            | Error(_) => expect("expected all Ok")->toEqual("got Error")
+            },
+        )
+        // Two Renamed events appended (the rejected Create produced none).
+        // Seed = 1, plus 2 Renamed = 3 stored.
+        expect(mock.getAll()->Array.length)->toBe(3)
+        // ref-2 reported as Rejected with AlreadyExists.
+        let rejected = capturedRejections.contents
+        expect(rejected->Array.length)->toBe(1)
+        let (rRef, rInfo) = rejected->Array.getUnsafe(0)
+        expect(rRef)->toEqual("ref-2")
+        expect(rInfo.errorCode)->toEqual("AlreadyExists")
+        // ref-1 and ref-3 reported as Accepted (eventCount > 0 against the appended batch).
+        let accepted = capturedAccepts.contents
+        expect(accepted->Array.length)->toBe(2)
+      },
+    )
   })
 
   describe("all-reject batch", () => {
-    testPromise("3 rejecting commands → no append, all reported Rejected, no Accepted", async () => {
-      // No seed → empty history. Rename on a NotCreated aggregate rejects with NotFound.
-      installChannels()
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "3 rejecting commands → no append, all reported Rejected, no Accepted",
+      async () => {
+        // No seed → empty history. Rename on a NotCreated aggregate rejects with NotFound.
+        installChannels()
+        let results = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-x", "ref-1", AggSpec.Rename({newName: "A"})),
           makeTopicItem(~aggId="agg-x", "ref-2", AggSpec.Rename({newName: "B"})),
           makeTopicItem(~aggId="agg-x", "ref-3", AggSpec.Rename({newName: "C"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      uninstallChannels()
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        uninstallChannels()
 
-      expect(results)->toEqual([Ok("ref-1"), Ok("ref-2"), Ok("ref-3")])
-      // No events appended.
-      expect(mock.getAll()->Array.length)->toBe(0)
-      // All three reported as Rejected.
-      expect(capturedRejections.contents->Array.length)->toBe(3)
-      capturedRejections.contents->Array.forEach(((_ref, info)) =>
-        expect(info.errorCode)->toEqual("NotFound")
-      )
-      // No Accepted callbacks fired (when nothing is appended and nothing is OK).
-      expect(capturedAccepts.contents->Array.length)->toBe(0)
-    })
+        expect(results)->toEqual([Ok("ref-1"), Ok("ref-2"), Ok("ref-3")])
+        // No events appended.
+        expect(mock.getAll()->Array.length)->toBe(0)
+        // All three reported as Rejected.
+        expect(capturedRejections.contents->Array.length)->toBe(3)
+        capturedRejections.contents->Array.forEach(
+          ((_ref, info)) => expect(info.errorCode)->toEqual("NotFound"),
+        )
+        // No Accepted callbacks fired (when nothing is appended and nothing is OK).
+        expect(capturedAccepts.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("payload-less variant errors", () => {
-    testPromise("errorDetail is empty string for unit-payload variants", async () => {
-      // AggSpec.error variants are all payload-less (NotFound | AlreadyExists).
-      installChannels()
-      let _ =
-        await Stream.fromIterable([
-          makeTopicItem("ref-1", AggSpec.Rename({newName: "X"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      uninstallChannels()
+    testPromise(
+      "errorDetail is empty string for unit-payload variants",
+      async () => {
+        // AggSpec.error variants are all payload-less (NotFound | AlreadyExists).
+        installChannels()
+        let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Rename({newName: "X"}))])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        uninstallChannels()
 
-      let (_ref, info) = capturedRejections.contents->Array.getUnsafe(0)
-      expect(info.errorDetail)->toEqual("")
-    })
+        let (_ref, info) = capturedRejections.contents->Array.getUnsafe(0)
+        expect(info.errorDetail)->toEqual("")
+      },
+    )
   })
 })

package/tests/aggregate/AggregateSnapshotTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-
 module AggSpec = {
   module Id = Reventless.Id.StringPure
   let name = "SnapshotTestAggregate"
@@ -24,7 +23,7 @@ module AggSpec = {
   type event = Added({item: string})
 
   @schema
-  type error = | Never
+  type error = Never
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -161,7 +160,11 @@ let mock = makeMockEL()
 
 module OuterEventLog = EventLog
 
-module MakeOps = (B: {let name: string}) => {
+module MakeOps = (
+  B: {
+    let name: string
+  },
+) => {
   module Spec = AggSpec
   module EventLog = {
     module Spec = {
@@ -178,11 +181,11 @@ module MakeOps = (B: {let name: string}) => {
       ) => 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>>,
     }
@@ -199,7 +202,9 @@ module MakeOps = (B: {let name: string}) => {
   }
 }
 
-module TestOps = MakeOps({let name = "SnapshotMockEventLog"})
+module TestOps = MakeOps({
+  let name = "SnapshotMockEventLog"
+})
 module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
 
 // A second behavior with snapshots DISABLED, sharing the same mock, to prove
@@ -225,7 +230,9 @@ module PlainBehavior = {
     }
 }
 
-module PlainOps = MakeOps({let name = "PlainMockEventLog"})
+module PlainOps = MakeOps({
+  let name = "PlainMockEventLog"
+})
 module PlainHandler = Aggregate_Callback.Make(AggSpec, PlainBehavior, PlainOps)
 
 let makeItem = (~id="agg-1", reference, command): CommandTopic.topicItem<
@@ -253,7 +260,10 @@ describe("Aggregate_Callback — snapshots:", () => {
   testPromise("writes a snapshot each time an interval boundary is crossed", async () => {
     // 25 single-event commands → boundaries at 10 and 20 (not 25).
     for i in 1 to 25 {
-      let _ = await run(~handler=TestHandler.handleCommands, AggSpec.Add({item: `i${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=TestHandler.handleCommands,
+        AggSpec.Add({item: `i${i->Int.toString}`}),
+      )
     }
     let _ = await tick()
     expect(mock.snapshotWriteCount.contents)->toBe(2)
@@ -266,7 +276,10 @@ describe("Aggregate_Callback — snapshots:", () => {
 
   testPromise("cold replay seeds from the snapshot and reads only the delta", async () => {
     for i in 1 to 12 {
-      let _ = await run(~handler=TestHandler.handleCommands, AggSpec.Add({item: `i${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=TestHandler.handleCommands,
+        AggSpec.Add({item: `i${i->Int.toString}`}),
+      )
     }
     let _ = await tick()
     // A snapshot exists at seq 10. Evict the in-process cache to force a cold read.
@@ -282,7 +295,10 @@ describe("Aggregate_Callback — snapshots:", () => {
 
   testPromise("state seeded from snapshot equals a full-replay fold", async () => {
     for i in 1 to 15 {
-      let _ = await run(~handler=TestHandler.handleCommands, AggSpec.Add({item: `x${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=TestHandler.handleCommands,
+        AggSpec.Add({item: `x${i->Int.toString}`}),
+      )
     }
     let _ = await tick()
     // Snapshot-seeded cold read (snapshot at seq 10, delta 10..15).
@@ -292,7 +308,10 @@ describe("Aggregate_Callback — snapshots:", () => {
     // Force a boundary to capture the seeded state as a fresh snapshot: add up to
     // seq 20 and compare its item count to the true event count.
     for i in 16 to 20 {
-      let _ = await run(~handler=TestHandler.handleCommands, AggSpec.Add({item: `x${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=TestHandler.handleCommands,
+        AggSpec.Add({item: `x${i->Int.toString}`}),
+      )
     }
     let _ = await tick()
     switch mock.getSnapshot("agg-1") {
@@ -312,7 +331,10 @@ describe("Aggregate_Callback — snapshots:", () => {
 
   testPromise("schema-drift snapshot is ignored → full replay from 0", async () => {
     for i in 1 to 12 {
-      let _ = await run(~handler=TestHandler.handleCommands, AggSpec.Add({item: `i${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=TestHandler.handleCommands,
+        AggSpec.Add({item: `i${i->Int.toString}`}),
+      )
     }
     let _ = await tick()
     // Corrupt the stored snapshot's hash to simulate a state-shape change.
@@ -329,7 +351,10 @@ describe("Aggregate_Callback — snapshots:", () => {
 
   testPromise("snapshot write failure does not fail the command", async () => {
     for i in 1 to 9 {
-      let _ = await run(~handler=TestHandler.handleCommands, AggSpec.Add({item: `i${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=TestHandler.handleCommands,
+        AggSpec.Add({item: `i${i->Int.toString}`}),
+      )
     }
     // The 10th append crosses the boundary; make its snapshot write fail.
     mock.failNextWrite := true
@@ -344,7 +369,10 @@ describe("Aggregate_Callback — snapshots:", () => {
 
   testPromise("disabled aggregate does zero snapshot reads and writes", async () => {
     for i in 1 to 12 {
-      let _ = await run(~handler=PlainHandler.handleCommands, AggSpec.Add({item: `i${i->Int.toString}`}))
+      let _ = await run(
+        ~handler=PlainHandler.handleCommands,
+        AggSpec.Add({item: `i${i->Int.toString}`}),
+      )
     }
     let _ = await tick()
     PlainHandler.resetCache()

package/tests/api/Api_IdsTest.res

@@ -40,8 +40,9 @@ describe("Api_Ids.encode / decode", () => {
 
 describe("Api_Ids.alternateKey — the fallback a door tries on a miss", () => {
   testSync("a global id offers the storage key inside it", () =>
-    expect(Api_Ids.alternateKey(Api_Ids.encode(~typeName="Catalog_Product", ~localId="p-1")))
-    ->toEqual(Some("p-1"))
+    expect(
+      Api_Ids.alternateKey(Api_Ids.encode(~typeName="Catalog_Product", ~localId="p-1")),
+    )->toEqual(Some("p-1"))
   )
 
   testSync("a plain key offers nothing, so the lookup is never retried", () =>
@@ -83,8 +84,13 @@ describe("stamping an id onto a row leaves the stored row alone", () => {
       JSON.Encode.object(obj)
     }
     let idOf = j =>
-      j->JSON.Decode.object->Option.flatMap(d => d->Dict.get("id"))->Option.flatMap(JSON.Decode.string)
-    expect(idOf(stamped))->toEqual(Some(Api_Ids.encode(~typeName="Ordering_Customer", ~localId="cust-42")))
+      j
+      ->JSON.Decode.object
+      ->Option.flatMap(d => d->Dict.get("id"))
+      ->Option.flatMap(JSON.Decode.string)
+    expect(idOf(stamped))->toEqual(
+      Some(Api_Ids.encode(~typeName="Ordering_Customer", ~localId="cust-42")),
+    )
     // The stored row still carries its storage key.
     expect(idOf(row))->toEqual(Some("cust-42"))
   })

package/tests/api/BrandedMarkerCompositionTest.res

@@ -21,54 +21,66 @@ describe("a field marker on a branded semantic:", () => {
     }
 
   describe("@owner on an Email field:", () => {
-    testSync("marks the field as the owner", () =>
-      expect(fieldOf("email")->Option.mapOr(false, Reventless.Owner.isFieldOwner))->toBe(true)
+    testSync(
+      "marks the field as the owner",
+      () =>
+        expect(fieldOf("email")->Option.mapOr(false, Reventless.Owner.isFieldOwner))->toBe(true),
     )
 
-    testSync("keeps the email semantic", () =>
-      expect(
-        fieldOf("email")
-        ->Option.flatMap(Reventless.Semantic.getFrom)
-        ->Option.map(s => s.id),
-      )->toEqual(Some("email"))
+    testSync(
+      "keeps the email semantic",
+      () =>
+        expect(
+          fieldOf("email")
+          ->Option.flatMap(Reventless.Semantic.getFrom)
+          ->Option.map(s => s.id),
+        )->toEqual(Some("email")),
     )
 
     // The regression a substituting fix would land, and it lands in silence:
     // the row still scopes to its owner, and the field accepts anything.
-    testSync("still rejects what is not an address", () => {
-      let parses = raw =>
-        switch fieldOf("email") {
-        | Some(schema) =>
-          switch raw->JSON.Encode.string->S.parseOrThrow(~to=schema) {
-          | _ => true
-          | exception _ => false
+    testSync(
+      "still rejects what is not an address",
+      () => {
+        let parses = raw =>
+          switch fieldOf("email") {
+          | Some(schema) =>
+            switch raw->JSON.Encode.string->S.parseOrThrow(~to=schema) {
+            | _ => true
+            | exception _ => false
+            }
+          | None => false
           }
-        | None => false
-        }
-      expect((parses("buyer@example.com"), parses("buyer")))->toEqual((true, false))
-    })
+        expect((parses("buyer@example.com"), parses("buyer")))->toEqual((true, false))
+      },
+    )
   })
 
   describe("@displayName on a DateTime field:", () => {
-    testSync("names the row by it", () =>
-      expect(
-        S.Metadata.get(stateSchema, ~id=Reventless.DisplayName.displayNameId)->Option.map(d =>
-          d.fields
-        ),
-      )->toEqual(Some(["openedAt"]))
+    testSync(
+      "names the row by it",
+      () =>
+        expect(
+          S.Metadata.get(stateSchema, ~id=Reventless.DisplayName.displayNameId)->Option.map(
+            d => d.fields,
+          ),
+        )->toEqual(Some(["openedAt"])),
     )
 
-    testSync("and the instant grammar survives", () => {
-      let parses = raw =>
-        switch fieldOf("openedAt") {
-        | Some(schema) =>
-          switch raw->JSON.Encode.string->S.parseOrThrow(~to=schema) {
-          | _ => true
-          | exception _ => false
+    testSync(
+      "and the instant grammar survives",
+      () => {
+        let parses = raw =>
+          switch fieldOf("openedAt") {
+          | Some(schema) =>
+            switch raw->JSON.Encode.string->S.parseOrThrow(~to=schema) {
+            | _ => true
+            | exception _ => false
+            }
+          | None => false
           }
-        | None => false
-        }
-      expect((parses("2026-03-02T09:00:00Z"), parses("tomorrow")))->toEqual((true, false))
-    })
+        expect((parses("2026-03-02T09:00:00Z"), parses("tomorrow")))->toEqual((true, false))
+      },
+    )
   })
 })

package/tests/api/GeolocationSemanticTest.res

@@ -101,8 +101,8 @@ describe("the Geolocation semantic emits its three member types", () => {
   })
 
   testSync("the field is typed as the union", () => {
-    expect(typeDefFor("type SemanticGeoCustomer")->String.includes("geolocation: Geolocation"))->toBe(
-      true,
-    )
+    expect(
+      typeDefFor("type SemanticGeoCustomer")->String.includes("geolocation: Geolocation"),
+    )->toBe(true)
   })
 })