@reventlessdev/reventless-postgres 3.0.0-alpha.1

package/lib/ocaml/PostgresIntegrationTest.res

@@ -0,0 +1,236 @@
+// Live-Postgres integration + concurrency suite (Phase F2).
+//
+// Skipped unless PG_URL is set, so the default `pnpm test` stays dependency-free.
+// Run against a real database with e.g.:
+//   PG_URL=postgres://postgres:postgres@localhost:5432/postgres pnpm test
+//
+// Covers the concurrency-critical core that nothing else in the repo has:
+//   - classic OCC append (success, gap/stale → Conflict, replay)
+//   - DCB append + xmin-fenced read + conditional-append conflict
+//   - write-skew: two genuinely concurrent conditional appends on one boundary —
+//     exactly one commits, the other conflicts cleanly (the anomaly the advisory
+//     locks close)
+//   - both #AdvisoryLocks and #RowLocks strategies
+
+open JestGlobals
+open ReventlessCore
+open Reventless
+
+@val external processEnv: dict<string> = "process.env"
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let jsonObj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+let stored = (eventType, tags, data): DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data,
+  tags,
+  meta: ReventlessCore.Message.generateMeta(~service="pg-test"),
+}
+
+let evJson = (msgId, v) =>
+  jsonObj([("msgId", JSON.Encode.string(msgId)), ("v", JSON.Encode.int(v))])
+
+switch processEnv->Dict.get("PG_URL") {
+| None =>
+  testSync("Postgres integration (skipped — set PG_URL to run)", () => expect(true)->toBe(true))
+| Some(url) =>
+  let pool = PgDriver.makePool({connectionString: url})
+
+  beforeAllAsync(async () => {
+    await PgSchema.ensureSchema(pool)
+    await PgSchema.truncateAll(pool)
+  })
+  afterAll(() => {
+    let _ = pool->PgDriver.endPool
+  })
+
+  describe("classic OCC event log", () => {
+    testPromise("append, replay, and conflict on wrong seq", async () => {
+      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="ct-orders", ~opts)
+
+      let r0 = await ops.append(0, "agg-1", [evJson("m0", 1), evJson("m1", 2)])
+      switch r0 {
+      | Ok() => expect(true)->toBe(true)
+      | Error(_) => expect("append")->toBe("ok")
+      }
+
+      // Stale seq (0 again) → Conflict.
+      let rStale = await ops.append(0, "agg-1", [evJson("m2", 3)])
+      switch rStale {
+      | Error(EventLog.Conflict) => expect(true)->toBe(true)
+      | _ => expect("stale")->toBe("conflict")
+      }
+
+      // Gap seq (5) → Conflict.
+      let rGap = await ops.append(5, "agg-1", [evJson("m3", 4)])
+      switch rGap {
+      | Error(EventLog.Conflict) => expect(true)->toBe(true)
+      | _ => expect("gap")->toBe("conflict")
+      }
+
+      // Correct next seq (2) → Ok.
+      let rNext = await ops.append(2, "agg-1", [evJson("m4", 5)])
+      switch rNext {
+      | Ok() => expect(true)->toBe(true)
+      | Error(_) => expect("next")->toBe("ok")
+      }
+
+      let evs = await ops.replay("agg-1")
+      expect(evs->Array.length)->toBe(3)
+
+      // Empty append is a no-op, never a conflict.
+      let rEmpty = await ops.append(3, "agg-1", [])
+      switch rEmpty {
+      | Ok() => expect(true)->toBe(true)
+      | Error(_) => expect("empty")->toBe("ok")
+      }
+    })
+  })
+
+  describe("DCB event log", () => {
+    let makeLog = name =>
+      DcbEventLogStorage_Postgres.makeStorage(
+        ~pool,
+        ~name,
+        ~indexes=[],
+        ~partitionTag=DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+
+    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 r = await ops.append([e1])
+      switch r {
+      | Ok(_) => expect(true)->toBe(true)
+      | Error(m) => expect(m)->toBe("ok")
+      }
+      let read = await ops.read(~query=[])
+      expect(read.events->Array.length)->toBe(1)
+      let first = read.events->Array.getUnsafe(0)
+      expect(first.eventType)->toBe("ItemAdded")
+      expect((first.tags->Array.getUnsafe(0)).key)->toBe("itemId")
+      expect((first.tags->Array.getUnsafe(0)).value)->toBe("x1")
+    })
+
+    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 r1 = await ops.append([mk("a")])
+      switch r1 {
+      | Ok(_) => expect(true)->toBe(true)
+      | Error(_) => expect("first")->toBe("ok")
+      }
+      // Assert "no Reserved for s1 yet" — must now conflict.
+      let cond: DcbTag.appendCondition = {
+        query: [{eventTypes: ["Reserved"], tags: [{key: "seatId", value: "s1"}]}],
+      }
+      let r2 = await ops.append([mk("b")], ~condition=cond)
+      switch r2 {
+      | Error(ReventlessInfra.DcbEventLog.Conflict) => expect(true)->toBe(true)
+      | _ => expect("second")->toBe("conflict")
+      }
+    })
+
+    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)
+      })
+
+    writeSkew(#AdvisoryLocks, "dcb-skew-advisory")
+    writeSkew(#RowLocks, "dcb-skew-rows")
+
+    testPromise("hot tag: N concurrent conditional appends, exactly one wins", async () => {
+      let (_n, ops, _s) = makeLog("dcb-hot")
+      let cond: DcbTag.appendCondition = {
+        query: [{eventTypes: ["Claimed"], tags: [{key: "prizeId", value: "p1"}]}],
+      }
+      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 results = await Promise.all(promises)
+      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"}]}])
+      expect(read.events->Array.length)->toBe(1)
+    })
+
+    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 _ = await ops.append([mk(0)])
+      let mid = switch await ops.append([mk(1)]) {
+      | Ok(pos) => pos
+      | Error(_) => ""
+      }
+      let _ = await ops.append([mk(2)])
+      // Reading after `mid` returns only the events strictly after it.
+      let read = await ops.read(~query=[{tags: [{key: "streamId", value: "c1"}]}], ~after=mid)
+      expect(read.events->Array.length)->toBe(1)
+      expect((read.events->Array.getUnsafe(0)).eventType)->toBe("Tick")
+    })
+  })
+
+  describe("change feed", () => {
+    testPromise("drains all events and checkpoints", async () => {
+      let (_n, ops, _s) = DcbEventLogStorage_Postgres.makeStorage(
+        ~pool,
+        ~name="feed-log",
+        ~indexes=[],
+        ~partitionTag=DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let mk = i => stored("Fed", [{key: "id", value: "f"}], jsonObj([("i", JSON.Encode.int(i))]))
+      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
+      })
+      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 _ => ())
+      expect(again)->toBe(0)
+    })
+  })
+}

package/lib/ocaml/QueryDbStorage_Postgres.res

@@ -0,0 +1,244 @@
+// Postgres-backed QueryDb storage — JSONB document tables, one per read model.
+//
+// Implements the clean QueryDb_Adapter.storageMaker (the shape
+// QueryDbStorage_DynamoDb implements): no in-process bus. The reventless-local
+// bridge that publishes state-changes to live GraphQL subscriptions wraps this
+// at integration time (Phase E), the way QueryDbStorage_Sqlite wraps its data
+// access today.
+//
+// Table `qdb_<name>`: partition_key text, sub_key text, item jsonb, expires_at
+// double precision (unix epoch seconds; null = never), PRIMARY KEY
+// (partition_key, sub_key). `item jsonb` returns already parsed. TTL is lazy —
+// every read carries `(expires_at IS NULL OR expires_at > epoch_now)`.
+//
+// GSI: each declared indexConfig becomes an expression index on `item->>'field'`
+// (composite keys concatenated with the configured separator). projectionType is
+// irrelevant in a relational store (every column is on the same row).
+
+open ReventlessCore
+open Reventless.ReadModel
+
+let tableName = (name: string): string => "qdb_" ++ name->String.replaceAll("-", "_")
+
+// Collapse anything outside [A-Za-z0-9_] to _ — predictable, injection-safe idents.
+let sanitizeIdent = (s: string): string =>
+  s->String.replaceRegExp(%re("/[^A-Za-z0-9_]/g"), "_")
+
+let notExpiredClause = "(expires_at IS NULL OR expires_at > extract(epoch from now()))"
+
+// JSONB text extraction for a single top-level field.
+let jsonField = (field: string): string =>
+  `(item->>'${field->String.replaceAll("'", "''")}')`
+
+let compositeExpr = (fields: array<string>, sep: string): string => {
+  let escapedSep = sep->String.replaceAll("'", "''")
+  fields->Array.map(jsonField)->Array.join(` || '${escapedSep}' || `)
+}
+
+let indexExpressions = (idx: indexConfig): (string, option<string>) => {
+  let pkExpr = switch idx.pkFields {
+  | Some(fields) if fields->Array.length > 0 => compositeExpr(fields, idx.pkSep->Option.getOr("/"))
+  | _ =>
+    switch idx.idField {
+    | Some(field) => jsonField(field)
+    | None => jsonField(idx.index)
+    }
+  }
+  let skExpr = switch idx.skFields {
+  | Some(fields) if fields->Array.length > 0 =>
+    Some(compositeExpr(fields, idx.skSep->Option.getOr("/")))
+  | _ =>
+    switch idx.subIdField {
+    | Some(field) => Some(jsonField(field))
+    | None => None
+    }
+  }
+  (pkExpr, skExpr)
+}
+
+let ensureTable = async (~pool, ~table) => {
+  await pool->PgDriver.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (partition_key text NOT NULL, sub_key text NOT NULL DEFAULT '', item jsonb NOT NULL, expires_at double precision, PRIMARY KEY (partition_key, sub_key))`,
+  )
+}
+
+let ensureIndexes = async (~pool, ~table, ~indexes: array<indexConfig>) => {
+  for i in 0 to indexes->Array.length - 1 {
+    let idx = indexes->Array.getUnsafe(i)
+    let (pkExpr, skExprOpt) = indexExpressions(idx)
+    let indexName = `idx_${table}_${sanitizeIdent(idx.index)}`
+    let cols = switch skExprOpt {
+    | Some(skExpr) => `${pkExpr}, ${skExpr}`
+    | None => pkExpr
+    }
+    await pool->PgDriver.exec(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${table} (${cols})`)
+  }
+}
+
+let decodeItem = (row: dict<JSON.t>): JSON.t =>
+  row->Dict.get("item")->Option.getOr(JSON.Encode.null)
+
+let computeSubKey = (item: JSON.t, subIdField: option<string>): string =>
+  switch subIdField {
+  | None => ""
+  | Some(field) =>
+    switch item->JSON.Decode.object->Option.flatMap(o => o->Dict.get(field)) {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+  }
+
+let withId = (item: JSON.t, partitionKey: string): JSON.t =>
+  switch item->JSON.Decode.object {
+  | Some(obj) if obj->Dict.get("id")->Option.isNone =>
+    let copy = Dict.copy(obj)
+    copy->Dict.set("id", JSON.Encode.string(partitionKey))
+    JSON.Encode.object(copy)
+  | _ => item
+  }
+
+let makeStorage = (
+  ~pool: PgDriver.pool,
+  ~name: string,
+  ~indexes: array<indexConfig>,
+  ~subIdField: option<string>,
+): QueryDb_Adapter.storage => {
+  let table = tableName(name)
+  // Schema setup is async but makeStorage is synchronous; gate every operation on
+  // this promise so the first access waits for table + index creation exactly
+  // once (subsequent awaits resolve immediately).
+  let ready = {
+    open Promise
+    ensureTable(~pool, ~table)->then(() => ensureIndexes(~pool, ~table, ~indexes))
+  }
+
+  let rowsFor = async (id: string): array<JSON.t> => {
+    await ready
+    (await pool->PgDriver.query(
+      `SELECT item FROM ${table} WHERE partition_key = $1 AND ${notExpiredClause} ORDER BY sub_key ASC`,
+      [JSON.Encode.string(id)],
+    ))->Array.map(decodeItem)
+  }
+
+  let saveOne = async (id: string, state: JSON.t, ttl: option<int>) => {
+    await ready
+    let subKey = computeSubKey(state, subIdField)
+    let expiresAt = switch ttl {
+    | Some(t) => JSON.Encode.int(t)
+    | None => JSON.Encode.null
+    }
+    let _ = await pool->PgDriver.query(
+      `INSERT INTO ${table}(partition_key, sub_key, item, expires_at)
+       VALUES ($1, $2, $3::jsonb, $4)
+       ON CONFLICT (partition_key, sub_key)
+       DO UPDATE SET item = EXCLUDED.item, expires_at = EXCLUDED.expires_at`,
+      [
+        JSON.Encode.string(id),
+        JSON.Encode.string(subKey),
+        JSON.Encode.string(JSON.stringify(state)),
+        expiresAt,
+      ],
+    )
+  }
+
+  let load: QueryDb.load<string, JSON.t> = async id => Ok(await rowsFor(id))
+
+  let loadStream: QueryDb.loadStream<string, JSON.t> =
+    id =>
+      Effect.promise(() => rowsFor(id))
+      ->Stream.fromEffect
+      ->Stream.flatMap(arr => Stream.fromIterable(arr))
+
+  let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, ttl) => {
+    await saveOne(id, state, ttl)
+    Ok()
+  }
+
+  let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
+    // pg has no synchronous multi-statement transaction helper here; the upserts
+    // are independent (distinct keys) so a sequential apply is equivalent.
+    for i in 0 to batch->Array.length - 1 {
+      let (id, state, ttl) = batch->Array.getUnsafe(i)
+      await saveOne(id, state, ttl)
+    }
+    Ok()
+  }
+
+  // Mirror DynamoDB's `ADD #field :inc`: read the counter on the partition item
+  // (counters are single-state, sub_key=""), add inc, upsert, return NEW total.
+  let count: QueryDb.count<string> = async (id, fieldName, inc) => {
+    await ready
+    let existing = (await rowsFor(id))->Array.get(0)->Option.flatMap(JSON.Decode.object)
+    let current =
+      existing
+      ->Option.flatMap(o => o->Dict.get(fieldName))
+      ->Option.flatMap(JSON.Decode.float)
+      ->Option.mapOr(0, Float.toInt)
+    let next = current + inc
+    let obj = switch existing {
+    | Some(o) => Dict.copy(o)
+    | None => Dict.make()
+    }
+    obj->Dict.set("id", JSON.Encode.string(id))
+    obj->Dict.set(fieldName, JSON.Encode.int(next))
+    await saveOne(id, JSON.Encode.object(obj), None)
+    Ok(next)
+  }
+
+  let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
+    await ready
+    let _ = switch subIdOpt {
+    | None =>
+      await pool->PgDriver.query(
+        `DELETE FROM ${table} WHERE partition_key = $1`,
+        [JSON.Encode.string(id)],
+      )
+    | Some((_, subValue)) =>
+      await pool->PgDriver.query(
+        `DELETE FROM ${table} WHERE partition_key = $1 AND sub_key = $2`,
+        [JSON.Encode.string(id), JSON.Encode.string(subValue)],
+      )
+    }
+    Ok()
+  }
+
+  let deleteBatch: QueryDb.deleteBatch<string> = async ids => {
+    for i in 0 to ids->Array.length - 1 {
+      let (id, subIdOpt) = ids->Array.getUnsafe(i)
+      let _ = await delete(id, subIdOpt)
+    }
+    Ok()
+  }
+
+  let ops: QueryDb_Adapter.operations = {
+    load,
+    loadStream,
+    save,
+    saveBatch,
+    count,
+    delete,
+    deleteBatch,
+  }
+
+  {
+    QueryDb_Adapter.resources: [],
+    dataSourceName: ""->Pulumi.Output.make,
+    operations: Pulumi.Output.make(ops),
+  }
+}
+
+// Standalone/deploy storage: inject the pool via a provider module.
+module Make = (P: {let pool: PgDriver.pool}) => {
+  type api = unit
+  type role = unit
+
+  let make: QueryDb_Adapter.storageMaker<unit, unit> = (
+    ~name,
+    ~indexes,
+    ~subIdField=?,
+    ~ttl as _=?,
+    ~api as _,
+    ~apiRole as _,
+    ~opts as _,
+  ) => makeStorage(~pool=P.pool, ~name, ~indexes, ~subIdField)
+}

package/lib/ocaml/QueryEnginePostgres.res

@@ -0,0 +1,127 @@
+// Postgres QueryEngine — compiles the QueryEngine query/scan AST to SQL over the
+// `qdb_<name>` JSONB tables (QueryDbStorage_Postgres). The reventless-local
+// LocalQueryEngine reads from in-process bus registries and ignores filters; this
+// one pushes filters down to SQL, the way a production engine must.
+
+open ReventlessCore
+open Reventless
+
+let valueToText = (v: QueryEngine.value): string =>
+  switch v {
+  | QueryEngine.String(s) => s
+  | QueryEngine.Int(i) => i->Int.toString
+  | QueryEngine.Bool(b) => b ? "true" : "false"
+  }
+
+let isNumeric = (v: QueryEngine.value): bool =>
+  switch v {
+  | QueryEngine.Int(_) => true
+  | _ => false
+  }
+
+type paramBuilder = {mutable params: array<JSON.t>}
+let param = (b: paramBuilder, v: JSON.t): string => {
+  b.params->Array.push(v)
+  "$" ++ Int.toString(b.params->Array.length)
+}
+
+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 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()}`
+  switch cmp {
+  | QueryEngine.Filter.Equal => cmpSql("=")
+  | Unequal => cmpSql("<>")
+  | LessOrEqual => cmpSql("<=")
+  | Less => cmpSql("<")
+  | GreaterOrEqual => cmpSql(">=")
+  | Greater => cmpSql(">")
+  | Exists => `(item ? '${field->String.replaceAll("'", "''")}')`
+  | NotExists => `NOT (item ? '${field->String.replaceAll("'", "''")}')`
+  | Contains => `strpos(${c}, ${bind()}) > 0`
+  | NotContains => `(${c} IS NULL OR strpos(${c}, ${bind()}) = 0)`
+  | BeginsWith => `starts_with(${c}, ${bind()})`
+  }
+}
+
+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()}`
+  switch cmp {
+  | QueryEngine.SubId.Equal => cmpSql("=")
+  | Unequal => cmpSql("<>")
+  | LessOrEqual => cmpSql("<=")
+  | Less => cmpSql("<")
+  | GreaterOrEqual => cmpSql(">=")
+  | Greater => cmpSql(">")
+  | BeginsWith => `starts_with(${c}, ${bind()})`
+  }
+}
+
+let notExpired = QueryDbStorage_Postgres.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)
+  if withId {
+    let pk = switch row->Dict.get("partition_key") {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+    QueryDbStorage_Postgres.withId(item, pk)
+  } else {
+    item
+  }
+}
+
+module Make = (P: {let pool: PgDriver.pool}) => {
+  let query = async (
+    ~readModelName,
+    ~key=?,
+    ~id: QueryEngine.value,
+    ~subIdConfig=?,
+    ~filterConfigs=?,
+    ~ascending=?,
+    ~limit=?,
+  ): array<JSON.t> => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let keyStr = switch key {
+    | Some(k) => k
+    | None => valueToText(id)
+    }
+    let b = {params: []}
+    let where = [`partition_key = ${b->param(JSON.Encode.string(keyStr))}`, notExpired]
+    switch subIdConfig {
+    | Some((field, cmp, v)) => where->Array.push(subIdSql(b, field, cmp, v))
+    | None => ()
+    }
+    filterConfigs
+    ->Option.getOr([])
+    ->Array.forEach(((field, cmp, v)) => where->Array.push(filterSql(b, field, cmp, v)))
+    let dir = ascending->Option.getOr(true) ? "ASC" : "DESC"
+    let limitClause = switch limit {
+    | 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}`
+    (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 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))}`
+    (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+  }
+
+  let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
+    Pulumi.Output.make({QueryEngine.scan, query})
+}

package/lib/ocaml/ReventlessPostgres.mlmap

@@ -0,0 +1,9 @@
+randjbuildsystem
+DcbEventLogStorage_Postgres
+EventLogStorage_Postgres
+PgChangeFeed
+PgDriver
+PgSchema
+PostgresIntegrationTest
+QueryDbStorage_Postgres
+QueryEnginePostgres