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

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>>,
     }

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"))
   })