@reventlessdev/reventless-postgres 3.0.0-alpha.124 → 3.0.0-alpha.125

package/lib/bs/src/QueryEnginePostgres.res

@@ -28,7 +28,12 @@ let param = (b: paramBuilder, v: JSON.t): string => {
 let col = (field: string): string => `(item->>'${field->String.replaceAll("'", "''")}')`
 
 // One Filter.config → SQL predicate, appending any bound params.
-let filterSql = (b: paramBuilder, field: string, cmp: QueryEngine.Filter.comparator, v: QueryEngine.value): string => {
+let filterSql = (
+  b: paramBuilder,
+  field: string,
+  cmp: QueryEngine.Filter.comparator,
+  v: QueryEngine.value,
+): string => {
   let c = col(field)
   let bind = () => b->param(JSON.Encode.string(valueToText(v)))
   let cmpSql = op =>
@@ -48,10 +53,16 @@ let filterSql = (b: paramBuilder, field: string, cmp: QueryEngine.Filter.compara
   }
 }
 
-let subIdSql = (b: paramBuilder, field: string, cmp: QueryEngine.SubId.comparator, v: QueryEngine.value): string => {
+let subIdSql = (
+  b: paramBuilder,
+  field: string,
+  cmp: QueryEngine.SubId.comparator,
+  v: QueryEngine.value,
+): string => {
   let c = col(field)
   let bind = () => b->param(JSON.Encode.string(valueToText(v)))
-  let cmpSql = op => isNumeric(v) ? `${c}::numeric ${op} ${bind()}::numeric` : `${c} ${op} ${bind()}`
+  let cmpSql = op =>
+    isNumeric(v) ? `${c}::numeric ${op} ${bind()}::numeric` : `${c} ${op} ${bind()}`
   switch cmp {
   | QueryEngine.SubId.Equal => cmpSql("=")
   | Unequal => cmpSql("<>")
@@ -80,7 +91,11 @@ let decodeRow = (~withId, row: dict<JSON.t>): JSON.t => {
   }
 }
 
-module Make = (P: {let pool: PgDriver.pool}) => {
+module Make = (
+  P: {
+    let pool: PgDriver.pool
+  },
+) => {
   let query = async (
     ~readModelName,
     ~key=?,
@@ -109,7 +124,9 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     | Some(n) => ` LIMIT ${b->param(JSON.Encode.int(n))}`
     | None => ""
     }
-    let sql = `SELECT partition_key, item FROM ${table} WHERE ${where->Array.join(" AND ")} ORDER BY sub_key ${dir}${limitClause}`
+    let sql = `SELECT partition_key, item FROM ${table} WHERE ${where->Array.join(
+        " AND ",
+      )} ORDER BY sub_key ${dir}${limitClause}`
     (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=false, ...))
   }
 
@@ -117,8 +134,12 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let b = {params: []}
     let where = [notExpired]
-    filterConfigs->Array.forEach(((field, cmp, v)) => where->Array.push(filterSql(b, field, cmp, v)))
-    let sql = `SELECT partition_key, item FROM ${table} WHERE ${where->Array.join(" AND ")} ORDER BY partition_key, sub_key LIMIT ${b->param(JSON.Encode.int(limit))}`
+    filterConfigs->Array.forEach(((field, cmp, v)) =>
+      where->Array.push(filterSql(b, field, cmp, v))
+    )
+    let sql = `SELECT partition_key, item FROM ${table} WHERE ${where->Array.join(
+        " AND ",
+      )} ORDER BY partition_key, sub_key LIMIT ${b->param(JSON.Encode.int(limit))}`
     (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
   }
 
@@ -265,15 +286,17 @@ module Make = (P: {let pool: PgDriver.pool}) => {
         }
       capability.filterFields->Array.forEach(f => {
         switch filterDict->Dict.get(f.name ++ "Eq") {
-        | Some(v) when v != JSON.Encode.null =>
+        | Some(v) if v != JSON.Encode.null =>
           whereParts->Array.push(
-            `${jsonTextC(f.name)} = ${b->param(JSON.Encode.string(valString(v)->Option.getOr("")))}`,
+            `${jsonTextC(f.name)} = ${b->param(
+                JSON.Encode.string(valString(v)->Option.getOr("")),
+              )}`,
           )
         | _ => ()
         }
         if f.range {
           switch filterDict->Dict.get(f.name ++ "From") {
-          | Some(v) when v != JSON.Encode.null =>
+          | Some(v) if v != JSON.Encode.null =>
             whereParts->Array.push(
               `${jsonTextC(f.name)} >= ${b->param(
                   JSON.Encode.string(valString(v)->Option.getOr("")),
@@ -282,7 +305,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
           | _ => ()
           }
           switch filterDict->Dict.get(f.name ++ "To") {
-          | Some(v) when v != JSON.Encode.null =>
+          | Some(v) if v != JSON.Encode.null =>
             whereParts->Array.push(
               `${jsonTextC(f.name)} <= ${b->param(
                   JSON.Encode.string(valString(v)->Option.getOr("")),
@@ -304,7 +327,8 @@ module Make = (P: {let pool: PgDriver.pool}) => {
       | Some(f) => jsonTextC(f)
       | None => idExprC
       }
-      switch argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string) {
+      let afterCursor = argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string)
+      switch afterCursor {
       | Some(c) =>
         whereParts->Array.push(
           `${cursorExpr} ${isDesc ? "<" : ">"} ${b->param(
@@ -326,7 +350,8 @@ module Make = (P: {let pool: PgDriver.pool}) => {
       let sql = `SELECT partition_key, item FROM ${table} WHERE ${whereParts->Array.join(
           " AND ",
         )} ORDER BY ${orderClause} LIMIT ${b->param(JSON.Encode.int(pageSize + 1))}`
-      let rows = (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+      let rows =
+        (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
       let hasMore = rows->Array.length > pageSize
       let pageItems = rows->Array.slice(~start=0, ~end=pageSize)
       let cursorField = orderByField->Option.getOr("id")
@@ -338,7 +363,10 @@ module Make = (P: {let pool: PgDriver.pool}) => {
         ReventlessCore.QueryDbListQuery.buildConnection(
           ~pageItems,
           ~hasNextPage=hasMore,
-          ~hasPreviousPage=false,
+          // Same rule the spec uses, because the parity suite compares them: a
+          // forward page reached by a cursor has one behind it. Hardcoding false
+          // made Prev disappear on exactly the pages that have a previous one.
+          ~hasPreviousPage=afterCursor->Option.isSome,
           ~cursorValueOf,
         ),
       )
@@ -365,8 +393,10 @@ module Make = (P: {let pool: PgDriver.pool}) => {
       argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
     let fstr = k => filterDict->Dict.get(k)->Option.flatMap(JSON.Decode.string)
     let orderDesc = fstr("order")->Option.mapOr(false, o => o == "DESC")
-    let last = argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
-    let first = argsDict->Dict.get("first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+    let last =
+      argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+    let first =
+      argsDict->Dict.get("first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
     let after = argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string)
     let before = argsDict->Dict.get("before")->Option.flatMap(JSON.Decode.string)
     let isBackward = last->Option.isSome
@@ -387,25 +417,36 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     fstr("prefix")->Option.forEach(p =>
       where->Array.push(`starts_with(sub_key, ${b->param(JSON.Encode.string(p))})`)
     )
-    fstr("from")->Option.forEach(f => where->Array.push(`${sk} >= ${b->param(JSON.Encode.string(f))}`))
-    fstr("to")->Option.forEach(t => where->Array.push(`${sk} <= ${b->param(JSON.Encode.string(t))}`))
+    fstr("from")->Option.forEach(f =>
+      where->Array.push(`${sk} >= ${b->param(JSON.Encode.string(f))}`)
+    )
+    fstr("to")->Option.forEach(t =>
+      where->Array.push(`${sk} <= ${b->param(JSON.Encode.string(t))}`)
+    )
     fstr("eq")->Option.forEach(e => where->Array.push(`${sk} = ${b->param(JSON.Encode.string(e))}`))
     // Keyset: forward excludes ≤ after; backward excludes ≥ before.
     switch (isBackward, after, before) {
     | (false, Some(c), _) =>
-      where->Array.push(`${sk} > ${b->param(JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)))}`)
+      where->Array.push(
+        `${sk} > ${b->param(JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)))}`,
+      )
     | (true, _, Some(c)) =>
-      where->Array.push(`${sk} < ${b->param(JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)))}`)
+      where->Array.push(
+        `${sk} < ${b->param(JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)))}`,
+      )
     | _ => ()
     }
     // Page-fetch direction is the LOGICAL order forward, and its OPPOSITE
     // backward (take the N nearest `before`, then reverse to logical) — mirrors
     // the resolver's `reverse = isBackward ? !orderDesc : orderDesc`.
     let fetchDesc = isBackward ? !orderDesc : orderDesc
-    let pageSize = (isBackward ? last : first)->Option.getOr(ReventlessCore.QueryDbListQuery.defaultListPageSize)
+    let pageSize =
+      (isBackward ? last : first)->Option.getOr(ReventlessCore.QueryDbListQuery.defaultListPageSize)
     let sql = `SELECT partition_key, sub_key, item FROM ${table} WHERE ${where->Array.join(
         " AND ",
-      )} ORDER BY ${sk} ${fetchDesc ? "DESC" : "ASC"} LIMIT ${b->param(JSON.Encode.int(pageSize + 1))}`
+      )} ORDER BY ${sk} ${fetchDesc ? "DESC" : "ASC"} LIMIT ${b->param(
+        JSON.Encode.int(pageSize + 1),
+      )}`
     let rows = await P.pool->PgDriver.query(sql, b.params)
     let hasMore = rows->Array.length > pageSize
     let taken = rows->Array.slice(~start=0, ~end=pageSize)
@@ -419,17 +460,18 @@ module Make = (P: {let pool: PgDriver.pool}) => {
       | _ => ""
       }
     let cursors = logical->Array.map(subKeyOf)
-    let edges =
-      pageItems->Array.mapWithIndex((item, i) =>
-        Obj.magic({
-          "node": item,
-          "cursor": ReventlessCore.QueryDbListQuery.encodeCursor(cursors->Array.getUnsafe(i)),
-        })
-      )
+    let edges = pageItems->Array.mapWithIndex((item, i) =>
+      Obj.magic({
+        "node": item,
+        "cursor": ReventlessCore.QueryDbListQuery.encodeCursor(cursors->Array.getUnsafe(i)),
+      })
+    )
     let startCursor =
       cursors->Array.get(0)->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
     let endCursor =
-      cursors->Array.get(cursors->Array.length - 1)->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
+      cursors
+      ->Array.get(cursors->Array.length - 1)
+      ->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
     Obj.magic({
       "edges": edges,
       "pageInfo": {

package/lib/bs/src/QueryEnginePostgres.res.mjs

@@ -235,11 +235,11 @@ function Make(P) {
     let orderByField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["field"]), Stdlib_JSON.Decode.string);
     let isDesc = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["direction"]), Stdlib_JSON.Decode.string), "ASC") === "DESC";
     let cursorExpr = orderByField !== undefined ? jsonTextC(orderByField) : idExprC;
-    let c = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
-    if (c !== undefined) {
+    let afterCursor = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    if (afterCursor !== undefined) {
       whereParts.push(cursorExpr + ` ` + (
         isDesc ? "<" : ">"
-      ) + ` ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(c)));
+      ) + ` ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(afterCursor)));
     }
     let orderClause = orderByField !== undefined ? jsonTextC(orderByField) + ` ` + (
         isDesc ? "DESC" : "ASC"
@@ -251,7 +251,7 @@ function Make(P) {
     let pageItems = rows.slice(0, pageSize);
     let cursorField = Stdlib_Option.getOr(orderByField, "id");
     let cursorValueOf = item => Stdlib_Option.getOr(QueryDbListQuery$ReventlessCore.getFieldString(item, cursorField), QueryDbListQuery$ReventlessCore.getId(item));
-    return QueryDbListQuery$ReventlessCore.buildConnection(pageItems, hasMore, false, cursorValueOf);
+    return QueryDbListQuery$ReventlessCore.buildConnection(pageItems, hasMore, Stdlib_Option.isSome(afterCursor), cursorValueOf);
   };
   let itemsPage = async (readModelName, param$1, id, argsDict, ownerScope, retiredScope) => {
     let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);

package/lib/bs/tests/PostgresIntegrationTest.res

@@ -100,7 +100,11 @@ switch processEnv->Dict.get("PG_URL") {
 
     testPromise("append + read round-trips events with tags", async () => {
       let (_n, ops, _s) = makeLog("dcb-rt")
-      let e1 = stored("ItemAdded", [{key: "itemId", value: "x1"}], jsonObj([("n", JSON.Encode.string("w"))]))
+      let e1 = stored(
+        "ItemAdded",
+        [{key: "itemId", value: "x1"}],
+        jsonObj([("n", JSON.Encode.string("w"))]),
+      )
       let r = await ops.append([e1])
       switch r {
       | Ok(_) => expect(true)->toBe(true)
@@ -116,7 +120,12 @@ switch processEnv->Dict.get("PG_URL") {
 
     testPromise("conditional append conflicts when the boundary already has an event", async () => {
       let (_n, ops, _s) = makeLog("dcb-cond")
-      let mk = who => stored("Reserved", [{key: "seatId", value: "s1"}], jsonObj([("who", JSON.Encode.string(who))]))
+      let mk = who =>
+        stored(
+          "Reserved",
+          [{key: "seatId", value: "s1"}],
+          jsonObj([("who", JSON.Encode.string(who))]),
+        )
       let r1 = await ops.append([mk("a")])
       switch r1 {
       | Ok(_) => expect(true)->toBe(true)
@@ -134,37 +143,46 @@ switch processEnv->Dict.get("PG_URL") {
     })
 
     let writeSkew = (strategy, logName) =>
-      testPromise(`write-skew: exactly one of two concurrent appends wins (${logName})`, async () => {
-        let (_n, ops, _s) = DcbEventLogStorage_Postgres.makeStorage(
-          ~pool,
-          ~name=logName,
-          ~indexes=[],
-          ~partitionTag=DcbTag.Simple({key: "k"}),
-          ~opts,
-          ~lockStrategy=strategy,
-        )
-        let cond: DcbTag.appendCondition = {
-          query: [{eventTypes: ["Reserved"], tags: [{key: "seatId", value: "hot"}]}],
-        }
-        let mk = who => stored("Reserved", [{key: "seatId", value: "hot"}], jsonObj([("who", JSON.Encode.string(who))]))
-        // Dispatch BOTH before awaiting either — genuinely concurrent on the pool.
-        let p1 = ops.append([mk("a")], ~condition=cond)
-        let p2 = ops.append([mk("b")], ~condition=cond)
-        let r1 = await p1
-        let r2 = await p2
-        let isOk = r => switch r {
-        | Ok(_) => true
-        | _ => false
-        }
-        let isConflict = r => r == Error(ReventlessInfra.DcbEventLog.Conflict)
-        let oks = [r1, r2]->Array.filter(isOk)->Array.length
-        let conflicts = [r1, r2]->Array.filter(isConflict)->Array.length
-        expect(oks)->toBe(1)
-        expect(conflicts)->toBe(1)
-        // And only one event actually landed on the boundary.
-        let read = await ops.read(~query=[{tags: [{key: "seatId", value: "hot"}]}])
-        expect(read.events->Array.length)->toBe(1)
-      })
+      testPromise(
+        `write-skew: exactly one of two concurrent appends wins (${logName})`,
+        async () => {
+          let (_n, ops, _s) = DcbEventLogStorage_Postgres.makeStorage(
+            ~pool,
+            ~name=logName,
+            ~indexes=[],
+            ~partitionTag=DcbTag.Simple({key: "k"}),
+            ~opts,
+            ~lockStrategy=strategy,
+          )
+          let cond: DcbTag.appendCondition = {
+            query: [{eventTypes: ["Reserved"], tags: [{key: "seatId", value: "hot"}]}],
+          }
+          let mk = who =>
+            stored(
+              "Reserved",
+              [{key: "seatId", value: "hot"}],
+              jsonObj([("who", JSON.Encode.string(who))]),
+            )
+          // Dispatch BOTH before awaiting either — genuinely concurrent on the pool.
+          let p1 = ops.append([mk("a")], ~condition=cond)
+          let p2 = ops.append([mk("b")], ~condition=cond)
+          let r1 = await p1
+          let r2 = await p2
+          let isOk = r =>
+            switch r {
+            | Ok(_) => true
+            | _ => false
+            }
+          let isConflict = r => r == Error(ReventlessInfra.DcbEventLog.Conflict)
+          let oks = [r1, r2]->Array.filter(isOk)->Array.length
+          let conflicts = [r1, r2]->Array.filter(isConflict)->Array.length
+          expect(oks)->toBe(1)
+          expect(conflicts)->toBe(1)
+          // And only one event actually landed on the boundary.
+          let read = await ops.read(~query=[{tags: [{key: "seatId", value: "hot"}]}])
+          expect(read.events->Array.length)->toBe(1)
+        },
+      )
 
     writeSkew(#AdvisoryLocks, "dcb-skew-advisory")
     writeSkew(#RowLocks, "dcb-skew-rows")
@@ -176,17 +194,31 @@ switch processEnv->Dict.get("PG_URL") {
       }
       let n = 12
       // Dispatch all N before awaiting any — genuinely concurrent on the pool.
-      let promises = Array.make(~length=n, 0)->Array.mapWithIndex((_, i) =>
-        ops.append(
-          [stored("Claimed", [{key: "prizeId", value: "p1"}], jsonObj([("who", JSON.Encode.int(i))]))],
-          ~condition=cond,
+      let promises =
+        Array.make(~length=n, 0)->Array.mapWithIndex(
+          (_, i) =>
+            ops.append(
+              [
+                stored(
+                  "Claimed",
+                  [{key: "prizeId", value: "p1"}],
+                  jsonObj([("who", JSON.Encode.int(i))]),
+                ),
+              ],
+              ~condition=cond,
+            ),
         )
-      )
       let results = await Promise.all(promises)
-      let oks = results->Array.filter(r => switch r {
-      | Ok(_) => true
-      | _ => false
-      })->Array.length
+      let oks =
+        results
+        ->Array.filter(
+          r =>
+            switch r {
+            | Ok(_) => true
+            | _ => false
+            },
+        )
+        ->Array.length
       expect(oks)->toBe(1)
       // No lost updates: exactly one Claimed landed on the boundary.
       let read = await ops.read(~query=[{tags: [{key: "prizeId", value: "p1"}]}])
@@ -195,7 +227,8 @@ switch processEnv->Dict.get("PG_URL") {
 
     testPromise("cursors are monotonic and usable as `after`", async () => {
       let (_n, ops, _s) = makeLog("dcb-cursor")
-      let mk = i => stored("Tick", [{key: "streamId", value: "c1"}], jsonObj([("i", JSON.Encode.int(i))]))
+      let mk = i =>
+        stored("Tick", [{key: "streamId", value: "c1"}], jsonObj([("i", JSON.Encode.int(i))]))
       let _ = await ops.append([mk(0)])
       let mid = switch await ops.append([mk(1)]) {
       | Ok(pos) => pos
@@ -222,83 +255,103 @@ switch processEnv->Dict.get("PG_URL") {
       let _ = await ops.append([mk(0), mk(1), mk(2)])
 
       let collected = ref(0)
-      let processed = await PgChangeFeed.drain(pool, ~logName="feed-log", ~subscriber="sub-1", ~handle=async evs => {
-        collected := collected.contents + evs->Array.length
-      })
+      let processed = await PgChangeFeed.drain(
+        pool,
+        ~logName="feed-log",
+        ~subscriber="sub-1",
+        ~handle=async evs => {
+          collected := collected.contents + evs->Array.length
+        },
+      )
       expect(processed)->toBe(3)
       expect(collected.contents)->toBe(3)
 
       // A second drain from the saved checkpoint sees nothing new.
-      let again = await PgChangeFeed.drain(pool, ~logName="feed-log", ~subscriber="sub-1", ~handle=async _ => ())
+      let again = await PgChangeFeed.drain(
+        pool,
+        ~logName="feed-log",
+        ~subscriber="sub-1",
+        ~handle=async _ => (),
+      )
       expect(again)->toBe(0)
     })
   })
 
   describe("classic change feed (event_log, B2.5)", () => {
-    testPromise("drains classic events in commit order, with fields, then checkpoints", async () => {
-      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-orders", ~opts)
-      let _ = await ops.append(0, "agg-1", [evJson("m0", 1), evJson("m1", 2)])
-      let _ = await ops.append(0, "agg-2", [evJson("m2", 3)])
+    testPromise(
+      "drains classic events in commit order, with fields, then checkpoints",
+      async () => {
+        let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-orders", ~opts)
+        let _ = await ops.append(0, "agg-1", [evJson("m0", 1), evJson("m1", 2)])
+        let _ = await ops.append(0, "agg-2", [evJson("m2", 3)])
 
-      let collected = ref([])
-      let processed = await EventLogChangeFeed.drain(
-        pool,
-        ~logName="cf-orders",
-        ~subscriber="cf-sub",
-        ~handle=async evs => collected := collected.contents->Array.concat(evs),
-      )
-      expect(processed)->toBe(3)
-      expect(collected.contents->Array.length)->toBe(3)
+        let collected = ref([])
+        let processed = await EventLogChangeFeed.drain(
+          pool,
+          ~logName="cf-orders",
+          ~subscriber="cf-sub",
+          ~handle=async evs => collected := collected.contents->Array.concat(evs),
+        )
+        expect(processed)->toBe(3)
+        expect(collected.contents->Array.length)->toBe(3)
 
-      // Fields round-trip from the stored row.
-      let first = collected.contents->Array.getUnsafe(0)
-      expect(first.aggregateId)->toBe("agg-1")
-      expect(first.seqNr)->toBe(0)
-      expect(first.msgId)->toEqual(Some("m0"))
+        // Fields round-trip from the stored row.
+        let first = collected.contents->Array.getUnsafe(0)
+        expect(first.aggregateId)->toBe("agg-1")
+        expect(first.seqNr)->toBe(0)
+        expect(first.msgId)->toEqual(Some("m0"))
 
-      // Cursors are strictly increasing in drain order.
-      let cursors = collected.contents->Array.map(e => e.cursor)
-      let increasing = ref(true)
-      for i in 1 to cursors->Array.length - 1 {
-        if cursors->Array.getUnsafe(i) <= cursors->Array.getUnsafe(i - 1) {
-          increasing := false
+        // Cursors are strictly increasing in drain order.
+        let cursors = collected.contents->Array.map(e => e.cursor)
+        let increasing = ref(true)
+        for i in 1 to cursors->Array.length - 1 {
+          if cursors->Array.getUnsafe(i) <= cursors->Array.getUnsafe(i - 1) {
+            increasing := false
+          }
         }
-      }
-      expect(increasing.contents)->toBe(true)
+        expect(increasing.contents)->toBe(true)
 
-      // Second drain from the saved checkpoint sees nothing new.
-      let again = await EventLogChangeFeed.drain(
-        pool,
-        ~logName="cf-orders",
-        ~subscriber="cf-sub",
-        ~handle=async _ => (),
-      )
-      expect(again)->toBe(0)
-    })
+        // Second drain from the saved checkpoint sees nothing new.
+        let again = await EventLogChangeFeed.drain(
+          pool,
+          ~logName="cf-orders",
+          ~subscriber="cf-sub",
+          ~handle=async _ => (),
+        )
+        expect(again)->toBe(0)
+      },
+    )
 
-    testPromise("concurrent appends across aggregates: every event drained exactly once", async () => {
-      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-concurrent", ~opts)
-      let n = 20
-      // One event per aggregate, all dispatched before awaiting — genuinely
-      // concurrent on the pool, so global_seq is assigned in interleaved/undefined
-      // commit order. The xmin fence must still drain every event exactly once.
-      let promises =
-        Array.make(~length=n, 0)->Array.mapWithIndex((_, i) =>
-          ops.append(0, "agg-" ++ Int.toString(i), [evJson("m" ++ Int.toString(i), i)])
+    testPromise(
+      "concurrent appends across aggregates: every event drained exactly once",
+      async () => {
+        let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(
+          ~pool,
+          ~name="cf-concurrent",
+          ~opts,
         )
-      let _ = await Promise.all(promises)
+        let n = 20
+        // One event per aggregate, all dispatched before awaiting — genuinely
+        // concurrent on the pool, so global_seq is assigned in interleaved/undefined
+        // commit order. The xmin fence must still drain every event exactly once.
+        let promises =
+          Array.make(~length=n, 0)->Array.mapWithIndex(
+            (_, i) => ops.append(0, "agg-" ++ Int.toString(i), [evJson("m" ++ Int.toString(i), i)]),
+          )
+        let _ = await Promise.all(promises)
 
-      let collected = ref([])
-      let _ = await EventLogChangeFeed.drain(
-        pool,
-        ~logName="cf-concurrent",
-        ~subscriber="cf-conc-sub",
-        ~handle=async evs => collected := collected.contents->Array.concat(evs),
-      )
-      // No skips: all N events present. No dupes: N distinct cursors.
-      expect(collected.contents->Array.length)->toBe(n)
-      let distinctCursors = collected.contents->Array.map(e => e.cursor)->Set.fromArray
-      expect(distinctCursors->Set.size)->toBe(n)
-    })
+        let collected = ref([])
+        let _ = await EventLogChangeFeed.drain(
+          pool,
+          ~logName="cf-concurrent",
+          ~subscriber="cf-conc-sub",
+          ~handle=async evs => collected := collected.contents->Array.concat(evs),
+        )
+        // No skips: all N events present. No dupes: N distinct cursors.
+        expect(collected.contents->Array.length)->toBe(n)
+        let distinctCursors = collected.contents->Array.map(e => e.cursor)->Set.fromArray
+        expect(distinctCursors->Set.size)->toBe(n)
+      },
+    )
   })
 }

package/lib/bs/tests/QueryEnginePostgresListPageTest.res

@@ -135,7 +135,12 @@ switch processEnv->Dict.get("PG_URL") {
 
   // Assert the push-down declines this shape (resolver falls back to the spec).
   let checkFallback = async args => {
-    let r = await Eng.listPage(~readModelName=name, ~argsDict=argsOf(args), ~capability, ~labelField="name")
+    let r = await Eng.listPage(
+      ~readModelName=name,
+      ~argsDict=argsOf(args),
+      ~capability,
+      ~labelField="name",
+    )
     expect(r->Option.isSome)->toBe(false)
   }
 
@@ -204,7 +209,9 @@ switch processEnv->Dict.get("PG_URL") {
       checkFallback([("filter", filterOf([("searchPrefix", JSON.Encode.string("A"))]))])
     )
     testPromise("ids → fallback", () =>
-      checkFallback([("filter", filterOf([("ids", JSON.Encode.array([JSON.Encode.string("p-1")]))]))])
+      checkFallback([
+        ("filter", filterOf([("ids", JSON.Encode.array([JSON.Encode.string("p-1")]))])),
+      ])
     )
     testPromise("backward (last/before) → fallback", () =>
       checkFallback([("last", JSON.Encode.int(2)), ("before", JSON.Encode.string(cur("p-4")))])
@@ -265,10 +272,20 @@ switch processEnv->Dict.get("PG_URL") {
     ->Array.filterMap(e => e->field("node")->Option.flatMap(n => n->str("seq")))
 
   let pageInfoBool = (conn, key) =>
-    conn->field("pageInfo")->Option.getOr(JSON.Encode.null)->field(key)->Option.flatMap(JSON.Decode.bool)->Option.getOr(false)
+    conn
+    ->field("pageInfo")
+    ->Option.getOr(JSON.Encode.null)
+    ->field(key)
+    ->Option.flatMap(JSON.Decode.bool)
+    ->Option.getOr(false)
 
   let itemsPage = args =>
-    Eng.itemsPage(~readModelName=itemsName, ~subIdField="seq", ~id="order-1", ~argsDict=argsOf(args))
+    Eng.itemsPage(
+      ~readModelName=itemsName,
+      ~subIdField="seq",
+      ~id="order-1",
+      ~argsDict=argsOf(args),
+    )
 
   describe("QueryEnginePostgres itemsPage (sub-id keyset)", () => {
     testPromise("bare → all lines ASC, no next page", async () => {
@@ -282,7 +299,10 @@ switch processEnv->Dict.get("PG_URL") {
       expect(pageInfoBool(r, "hasNextPage"))->toBe(true)
     })
     testPromise("first:2 after b → [c,d]", async () => {
-      let r = await itemsPage([("first", JSON.Encode.int(2)), ("after", JSON.Encode.string(cur("b")))])
+      let r = await itemsPage([
+        ("first", JSON.Encode.int(2)),
+        ("after", JSON.Encode.string(cur("b"))),
+      ])
       expect(r->itemSeqs)->toEqual(["c", "d"])
     })
     testPromise("order DESC → [e..a]", async () => {
@@ -304,7 +324,10 @@ switch processEnv->Dict.get("PG_URL") {
       expect(r->itemSeqs)->toEqual(["c"])
     })
     testPromise("backward last:2 before d → [b,c] (logical ASC)", async () => {
-      let r = await itemsPage([("last", JSON.Encode.int(2)), ("before", JSON.Encode.string(cur("d")))])
+      let r = await itemsPage([
+        ("last", JSON.Encode.int(2)),
+        ("before", JSON.Encode.string(cur("d"))),
+      ])
       expect(r->itemSeqs)->toEqual(["b", "c"])
       expect(pageInfoBool(r, "hasPreviousPage"))->toBe(true)
     })

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1788869313185)
-#Done(1788869318964)
+#Start(1788992674550)
+#Done(1788992682364)