@reventlessdev/reventless-postgres 3.0.0-alpha.14 → 3.0.0-alpha.141

package/lib/ocaml/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("<>")
@@ -63,24 +74,28 @@ let subIdSql = (b: paramBuilder, field: string, cmp: QueryEngine.SubId.comparato
   }
 }
 
-let notExpired = QueryDbStorage_Postgres.notExpiredClause
+let notExpired = QueryDbStorage_Postgres_Ops.notExpiredClause
 
 // Add `id` (from partition_key) when absent — matches allRows/scan in the SQLite
 // engine; partition-key queries return items as stored.
 let decodeRow = (~withId, row: dict<JSON.t>): JSON.t => {
-  let item = QueryDbStorage_Postgres.decodeItem(row)
+  let item = QueryDbStorage_Postgres_Ops.decodeItem(row)
   if withId {
     let pk = switch row->Dict.get("partition_key") {
     | Some(JSON.String(s)) => s
     | _ => ""
     }
-    QueryDbStorage_Postgres.withId(item, pk)
+    QueryDbStorage_Postgres_Ops.withId(item, pk)
   } else {
     item
   }
 }
 
-module Make = (P: {let pool: PgDriver.pool}) => {
+module Make = (
+  P: {
+    let pool: PgDriver.pool
+  },
+) => {
   let query = async (
     ~readModelName,
     ~key=?,
@@ -90,7 +105,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~ascending=?,
     ~limit=?,
   ): array<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let keyStr = switch key {
     | Some(k) => k
     | None => valueToText(id)
@@ -109,16 +124,22 @@ 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, ...))
   }
 
   let scan = async (~readModelName, ~filterConfigs, ~limit): array<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    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, ...))
   }
 
@@ -138,7 +159,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
   // (`ensureIndexes`) instead of scanning. String comparison mirrors the
   // resolver's JS path (which only matched string-typed fields).
   let indexLookup = async (~readModelName, field: string, value: string): array<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let b = {params: []}
     let sql = `SELECT partition_key, item FROM ${table} WHERE ${col(field)} = ${b->param(
         JSON.Encode.string(value),
@@ -154,7 +175,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     if ids->Array.length == 0 {
       []
     } else {
-      let table = QueryDbStorage_Postgres.tableName(readModelName)
+      let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
       let b = {params: []}
       let idsJson = JSON.Encode.array(ids->Array.map(JSON.Encode.string))
       let sql = `SELECT partition_key, item FROM ${table} WHERE partition_key = ANY(${b->param(
@@ -168,6 +189,39 @@ module Make = (P: {let pool: PgDriver.pool}) => {
   let idExprC = `COALESCE(item->>'id', partition_key) COLLATE "C"`
   let jsonTextC = (field: string): string => `${col(field)} COLLATE "C"`
 
+  // "not retired", as jsonb rather than text. `->` keeps the value typed, so a
+  // JSON boolean true is distinguishable from the JSON string "true"; `->>`
+  // would render both as 'true' and hide a row the shared spec keeps, since that
+  // spec decodes strictly and reads a non-boolean as "no flag". `IS DISTINCT
+  // FROM` rather than `<>` so an absent key — NULL — keeps the row instead of
+  // making the whole predicate NULL and dropping it.
+  //
+  // The state form compares against JSON strings instead of `true`, one
+  // `IS DISTINCT FROM` per state, ANDed. Not `NOT IN`: that is ordinary
+  // equality, so an absent key makes the predicate NULL and drops a row this
+  // spec keeps. Same shape and same index behaviour as the single-state form —
+  // a handful of equality predicates over an enum-valued attribute cost what one
+  // over a boolean does — so the `@index` guidance carries over unchanged.
+  //
+  // A set naming no states withdraws nothing, so the predicate is vacuously
+  // true, matching what `isRetiredValue` answers for it.
+  let notRetiredC = (scope: Reventless.OwnerScope.retiredScope): string => {
+    let key = scope.field->String.replaceAll("'", "''")
+    let distinctFrom = lit => `(item->'${key}') IS DISTINCT FROM ${lit}`
+    switch scope.values {
+    | None => distinctFrom("'true'::jsonb")
+    | Some([]) => "TRUE"
+    | Some(states) =>
+      // Parenthesised though every caller ANDs these together already: a clause
+      // that is safe only because of where it is spliced is a clause that breaks
+      // the first time it is spliced somewhere else.
+      "(" ++
+      states
+      ->Array.map(state => distinctFrom(`'"${state->String.replaceAll("'", "''")}"'::jsonb`))
+      ->Array.join(" AND ") ++ ")"
+    }
+  }
+
   // Connection-list push-down. Builds `item->>'field'` predicates + keyset
   // WHERE + `ORDER BY … LIMIT pageSize+1` so a page reads only what it returns
   // rather than the whole read model. Reproduces `QueryDbListQuery` semantics
@@ -183,8 +237,10 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~argsDict: dict<JSON.t>,
     ~capability: GraphQL_FragmentGenerator.serverCapability,
     ~labelField as _,
+    ~ownerScope: option<(string, string)>=?,
+    ~retiredScope: option<Reventless.OwnerScope.retiredScope>=?,
   ): option<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let filterDict =
       argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
     let strNonEmpty = k =>
@@ -210,6 +266,19 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     } else {
       let b = {params: []}
       let whereParts = [notExpired]
+      // Into the SQL, before the LIMIT — narrowing the returned page instead
+      // would hand back fewer rows than asked for while still claiming a next
+      // page. Mirrors the SQLite push-down; the parity harness holds the two
+      // and the shared spec to the same answer.
+      switch ownerScope {
+      | Some((field, required)) =>
+        whereParts->Array.push(`${jsonTextC(field)} = ${b->param(JSON.Encode.string(required))}`)
+      | None => ()
+      }
+      switch retiredScope {
+      | Some(scope) => whereParts->Array.push(notRetiredC(scope))
+      | None => ()
+      }
       let valString = v =>
         switch v->JSON.Decode.string {
         | Some(s) => Some(s)
@@ -217,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("")),
@@ -234,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("")),
@@ -256,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(
@@ -278,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")
@@ -290,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,
         ),
       )
@@ -309,14 +385,18 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~subIdField as _: string,
     ~id: string,
     ~argsDict: dict<JSON.t>,
+    ~ownerScope: option<(string, string)>=?,
+    ~retiredScope: option<Reventless.OwnerScope.retiredScope>=?,
   ): JSON.t => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let filterDict =
       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
@@ -324,28 +404,49 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     let sk = `sub_key COLLATE "C"`
     let b = {params: []}
     let where = [`partition_key = ${b->param(JSON.Encode.string(id))}`, notExpired]
+    // Before the keyset window and the LIMIT, for the same reason as `listPage`.
+    switch ownerScope {
+    | Some((field, required)) =>
+      where->Array.push(`${jsonTextC(field)} = ${b->param(JSON.Encode.string(required))}`)
+    | None => ()
+    }
+    switch retiredScope {
+    | Some(scope) => where->Array.push(notRetiredC(scope))
+    | None => ()
+    }
     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)
@@ -359,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": {
@@ -380,7 +482,4 @@ module Make = (P: {let pool: PgDriver.pool}) => {
       },
     })
   }
-
-  let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
-    Pulumi.Output.make({QueryEngine.scan, query})
 }

package/lib/ocaml/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-postgres",
-  "version": "3.0.0-alpha.14",
+  "version": "3.0.0-alpha.141",
   "description": "Postgres storage backend for Reventless (classic + DCB event logs, query DB, change feed). Connection-string only — RDS/Aurora, any managed provider, or a local container.",
   "license": "Apache-2.0",
   "jest": {
@@ -21,22 +21,22 @@
   },
   "dependencies": {
     "pg": "^8.13.1",
-    "sury": "11.0.0-alpha.4",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.150",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.92",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.70"
+    "sury": "11.0.0",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.22",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.277",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.177",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.149"
   },
   "devDependencies": {
     "@types/pg": "^8.11.10",
-    "rescript": "^12.3.0",
-    "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.52"
+    "rescript": "12.3.1",
+    "sury-ppx": "11.0.0",
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.94"
   },
   "peerDependencies": {
-    "rescript": "^12.3.0"
+    "rescript": "^12.3.1"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -44,7 +44,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ReventlessDev/reventless-core.git",
-    "directory": "reventless/reventless-postgres"
+    "directory": "reventless/postgres"
   },
   "scripts": {
     "build": "rescript build",

package/rescript.json

@@ -19,7 +19,8 @@
     },
     {
       "dir": "tests",
-      "subdirs": true
+      "subdirs": true,
+      "type": "dev"
     }
   ],
   "dependencies": [

package/src/DcbEventLogStorage_Postgres.res

@@ -8,7 +8,7 @@
 // existing `DcbEventLogStorage_Postgres.*` reference keeps working) and adds only
 // the deploy-time `DcbEventLog_Adapter` shape, keeping the historic `makeStorage`
 // 3-tuple `(name, ops, adapter)` API unchanged.
-// See docs/plans/deployed-lambda-esm-self-containment.md (Rung-3 finding).
+// See docs/plans/done/deployed-lambda-esm-self-containment.md (Rung-3 finding).
 
 open ReventlessCore
 include DcbEventLogStorage_Postgres_Ops

package/src/DcbEventLogStorage_Postgres_Ops.res

@@ -6,7 +6,7 @@
 // would leak into the Lambda import graph and fail resolution on real Lambda. The
 // thin `DcbEventLogStorage_Postgres` wrapper `include`s this and adds the
 // deploy-time `Pulumi.Output`-shaped adapter for local/deploy consumers.
-// See docs/plans/deployed-lambda-esm-self-containment.md (Rung-3 finding).
+// See docs/plans/done/deployed-lambda-esm-self-containment.md (Rung-3 finding).
 
 open ReventlessCore
 open Reventless
@@ -67,7 +67,7 @@ let rowToEvent = (row: dict<JSON.t>): DcbEventLog_Adapter.rawSequencedEvent => {
     | _ => ""
     }
   let meta = switch row->Dict.get("meta") {
-  | Some(metaJson) => metaJson->S.parseJsonOrThrow(Reventless.Message.metaSchema)
+  | Some(metaJson) => metaJson->Reventless.Util_Sury.fromJson(Reventless.Message.metaSchema)
   | None => JsError.throwWithMessage("missing meta column in dcb_event row")
   }
   {
@@ -143,7 +143,7 @@ let buildReadWhere = (
 // Strip the zero-padding a cursor carries for string-sortability, leaving a
 // plain decimal both `::xid8` and `::bigint` parse unambiguously ("0" if empty).
 let stripZeros = (s: string): string => {
-  let t = s->String.replaceRegExp(%re("/^0+/"), "")
+  let t = s->String.replaceRegExp(/^0+/, "")
   t == "" ? "0" : t
 }
 
@@ -222,49 +222,45 @@ let makeOps = (
     }
   }
 
-  let append = async (
-    newEvents: array<DcbEventLog_Adapter.rawStoredEvent>,
-    ~condition=?,
-  ): result<DcbTag.sequencePosition, ReventlessInfra.DcbEventLog.appendError> => {
+  let append = async (newEvents: array<DcbEventLog_Adapter.rawStoredEvent>, ~condition=?): result<
+    DcbTag.sequencePosition,
+    ReventlessInfra.DcbEventLog.appendError,
+  > => {
     let eventsJson = JSON.Array(
-      newEvents->Array.map(ev =>
-        JSON.Object(
+      newEvents->Array.map(ev => JSON.Object(
+        Dict.fromArray([
+          ("event_type", JSON.Encode.string(ev.eventType)),
+          (
+            "tags",
+            JSON.Array(ev.tags->Array.map(t => JSON.Encode.string(t.key ++ "=" ++ t.value))),
+          ),
+          ("data", ev.data),
+          ("meta", ev.meta->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema)),
+        ]),
+      )),
+    )
+    let conditionParam = switch condition {
+    | Some(cond: DcbTag.appendCondition) =>
+      let queryJson = JSON.Array(
+        cond.query->Array.map(clause => JSON.Object(
           Dict.fromArray([
-            ("event_type", JSON.Encode.string(ev.eventType)),
+            (
+              "eventTypes",
+              switch clause.eventTypes {
+              | Some(types) => JSON.Array(types->Array.map(JSON.Encode.string))
+              | None => JSON.Encode.null
+              },
+            ),
             (
               "tags",
-              JSON.Array(ev.tags->Array.map(t => JSON.Encode.string(t.key ++ "=" ++ t.value))),
+              switch clause.tags {
+              | Some(tags) =>
+                JSON.Array(tags->Array.map(t => JSON.Encode.string(t.key ++ "=" ++ t.value)))
+              | None => JSON.Encode.null
+              },
             ),
-            ("data", ev.data),
-            ("meta", ev.meta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema)),
           ]),
-        )
-      ),
-    )
-    let conditionParam = switch condition {
-    | Some(cond: DcbTag.appendCondition) =>
-      let queryJson = JSON.Array(
-        cond.query->Array.map(clause =>
-          JSON.Object(
-            Dict.fromArray([
-              (
-                "eventTypes",
-                switch clause.eventTypes {
-                | Some(types) => JSON.Array(types->Array.map(JSON.Encode.string))
-                | None => JSON.Encode.null
-                },
-              ),
-              (
-                "tags",
-                switch clause.tags {
-                | Some(tags) =>
-                  JSON.Array(tags->Array.map(t => JSON.Encode.string(t.key ++ "=" ++ t.value)))
-                | None => JSON.Encode.null
-                },
-              ),
-            ]),
-          )
-        ),
+        )),
       )
       let fields = [("query", queryJson)]
       switch cond.after {
@@ -306,7 +302,10 @@ let makeOps = (
         ? Error(ReventlessInfra.DcbEventLog.Conflict)
         : Error(
             ReventlessInfra.DcbEventLog.StorageFailure(
-              exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("storage error"),
+              exn
+              ->JsExn.fromException
+              ->Option.flatMap(JsExn.message)
+              ->Option.getOr("storage error"),
             ),
           )
     }
@@ -324,7 +323,9 @@ let makeOps = (
       Effect.promise(() => {
         let b = mkBuilder()
         let where = buildReadWhere(b, ~name, ~query, ~after=cursor, ~applyFence=true)
-        let sql = `SELECT ${selectColumns}, transaction_id::text AS tx_raw, position::text AS pos_raw FROM dcb_event WHERE ${where} ORDER BY transaction_id ASC, position ASC LIMIT ${Int.toString(pageSize)}`
+        let sql = `SELECT ${selectColumns}, transaction_id::text AS tx_raw, position::text AS pos_raw FROM dcb_event WHERE ${where} ORDER BY transaction_id ASC, position ASC LIMIT ${Int.toString(
+            pageSize,
+          )}`
         pool->PgDriver.query(sql, b.params)
       })->Effect.map(rows => {
         let events = rows->Array.map(rowToEvent)