@reventlessdev/reventless-postgres 3.0.0-alpha.5 → 3.0.0-alpha.7

package/lib/ocaml/QueryEnginePostgres.res

@@ -297,6 +297,90 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     }
   }
 
+  // Sub-id connection push-down: the `{single}Items(id, filter, first/after/
+  // last/before)` query. Keyset over `sub_key` WITHIN one partition — a page
+  // reads only what it returns. Reproduces QueryDbResolvers_GraphQL's items
+  // resolver (SortKey_Filter + forward/backward keyset), entirely in SQL since
+  // sub_key IS the sort key. Cursor = base64 of the sub_key value; comparisons
+  // use COLLATE "C" (byte order) to match JS string `<`. Unlike the main list
+  // there is no declined-shape fallback — every items shape maps to SQL.
+  let itemsPage = async (
+    ~readModelName,
+    ~subIdField as _: string,
+    ~id: string,
+    ~argsDict: dict<JSON.t>,
+  ): JSON.t => {
+    let table = QueryDbStorage_Postgres.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 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
+
+    let sk = `sub_key COLLATE "C"`
+    let b = {params: []}
+    let where = [`partition_key = ${b->param(JSON.Encode.string(id))}`, notExpired]
+    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("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)))}`)
+    | (true, _, Some(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 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))}`
+    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)
+    // Backward fetched in reverse-logical order → flip back to logical.
+    let logical = isBackward ? taken->Array.toReversed : taken
+    let pageItems = logical->Array.map(decodeRow(~withId=false, ...))
+    // Cursor = the row's sub_key (== the item's subIdField value).
+    let subKeyOf = (row: dict<JSON.t>) =>
+      switch row->Dict.get("sub_key") {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+    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 startCursor =
+      cursors->Array.get(0)->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
+    let endCursor =
+      cursors->Array.get(cursors->Array.length - 1)->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
+    Obj.magic({
+      "edges": edges,
+      "pageInfo": {
+        "hasNextPage": !isBackward && hasMore,
+        "hasPreviousPage": isBackward && hasMore,
+        "startCursor": startCursor->Nullable.fromOption,
+        "endCursor": endCursor->Nullable.fromOption,
+      },
+    })
+  }
+
   let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
     Pulumi.Output.make({QueryEngine.scan, query})
 }

package/lib/ocaml/QueryEnginePostgresListPageTest.res

@@ -233,4 +233,80 @@ switch processEnv->Dict.get("PG_URL") {
       expect(items->Array.length)->toBe(0)
     })
   })
+
+  // ── itemsPage (sub-id connection) ─────────────────────────────────────────
+  // A sub-id read model: partition "order-1" holds 5 lines keyed by `seq`.
+  let itemsName = "itemsparity"
+  let mkLine = seq => {
+    let o = Dict.make()
+    o->Dict.set("id", JSON.Encode.string("order-1"))
+    o->Dict.set("seq", JSON.Encode.string(seq))
+    JSON.Encode.object(o)
+  }
+  let seqs = ["a", "b", "c", "d", "e"]
+  beforeAllAsync(async () => {
+    let ops = QueryDbStorage_Postgres.makeOperations(
+      ~pool,
+      ~name=itemsName,
+      ~indexes=[],
+      ~subIdField=Some("seq"),
+    )
+    for i in 0 to seqs->Array.length - 1 {
+      let _ = await ops.save("order-1", mkLine(seqs->Array.getUnsafe(i)), QueryDb.Any, None)
+    }
+  })
+
+  // Extract node `seq` values in edge order.
+  let itemSeqs = (conn: JSON.t) =>
+    conn
+    ->field("edges")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.getOr([])
+    ->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)
+
+  let itemsPage = 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 () => {
+      let r = await itemsPage([])
+      expect(r->itemSeqs)->toEqual(["a", "b", "c", "d", "e"])
+      expect(pageInfoBool(r, "hasNextPage"))->toBe(false)
+    })
+    testPromise("first:2 → [a,b], hasNextPage", async () => {
+      let r = await itemsPage([("first", JSON.Encode.int(2))])
+      expect(r->itemSeqs)->toEqual(["a", "b"])
+      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")))])
+      expect(r->itemSeqs)->toEqual(["c", "d"])
+    })
+    testPromise("order DESC → [e..a]", async () => {
+      let r = await itemsPage([("filter", filterOf([("order", JSON.Encode.string("DESC"))]))])
+      expect(r->itemSeqs)->toEqual(["e", "d", "c", "b", "a"])
+    })
+    testPromise("filter eq c → [c]", async () => {
+      let r = await itemsPage([("filter", filterOf([("eq", JSON.Encode.string("c"))]))])
+      expect(r->itemSeqs)->toEqual(["c"])
+    })
+    testPromise("filter from b to d → [b,c,d]", async () => {
+      let r = await itemsPage([
+        ("filter", filterOf([("from", JSON.Encode.string("b")), ("to", JSON.Encode.string("d"))])),
+      ])
+      expect(r->itemSeqs)->toEqual(["b", "c", "d"])
+    })
+    testPromise("prefix c → [c]", async () => {
+      let r = await itemsPage([("filter", filterOf([("prefix", JSON.Encode.string("c"))]))])
+      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")))])
+      expect(r->itemSeqs)->toEqual(["b", "c"])
+      expect(pageInfoBool(r, "hasPreviousPage"))->toBe(true)
+    })
+  })
 }

package/lib/ocaml/ReventlessPostgres.mlmap

@@ -1,11 +1,14 @@
 randjbuildsystem
 DcbEventLogStorage_Postgres
+DcbEventLogStorage_Postgres_Ops
 EventLogChangeFeed
 EventLogStorage_Postgres
+EventLogStorage_Postgres_Ops
 PgChangeFeed
 PgDriver
 PgSchema
 PostgresIntegrationTest
 QueryDbStorage_Postgres
+QueryDbStorage_Postgres_Ops
 QueryEnginePostgres
 QueryEnginePostgresListPageTest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-postgres",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.7",
   "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": {
@@ -23,8 +23,8 @@
     "pg": "^8.13.1",
     "sury": "11.0.0-alpha.4",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/reventless-core": "3.0.0-alpha.143",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.89",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.67"

package/src/DcbEventLogStorage_Postgres.res

@@ -1,352 +1,37 @@
-// Postgres-backed DCB event log storage — the exact-semantics backend.
+// Deploy/local wrapper over the runtime-pure DcbEventLogStorage_Postgres_Ops.
 //
-// Unlike DynamoDB (which emulates the append condition with per-(tag,type) fence
-// sentinel rows), Postgres evaluates the actual DcbTag.query atomically inside
-// `dcb_append` (PgSchema.res): scoped advisory locks + exact check + insert, one
-// round trip, transaction-scoped. See docs/plans/postgres-storage-adapter.md §B.
-//
-// Reads apply the xmin read barrier so returned head positions are stable
-// forever (an event committed late — lower position, later commit — can never be
-// skipped by a checkpointing reader). Positions are the opaque cursor
-// `<xid8>:<position>` (both zero-padded to 20 digits → string sort == numeric
-// sort); the append condition's `after` decodes to the same two-column
-// comparison, making read → decide → conditional-append exact end to end.
+// The runtime ops, `lockStrategy`, `countAll`, and all query helpers live in
+// DcbEventLogStorage_Postgres_Ops, which imports NO `@pulumi/pulumi` so the
+// deployed Lambda import graph stays clean (the DCB command entry point pulls the
+// ops in unconditionally at cold start — a deploy-time dep here would fail
+// resolution on real Lambda). This module `include`s that pure module (so every
+// 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).
 
 open ReventlessCore
-open Reventless
-
-// Lock strategy for concurrent appends (B4). Advisory (default) is safe under
-// PgBouncer transaction mode; RowLocks avoids advisory-lock connection pinning
-// on RDS Proxy at the cost of a companion `dcb_scope` table.
-type lockStrategy = [#AdvisoryLocks | #RowLocks]
-let strategyParam = s =>
-  switch s {
-  | #AdvisoryLocks => "advisory"
-  | #RowLocks => "rows"
-  }
-
-// Injected by reventless-local to feed the projection-checkpoint low-watermark
-// (ProjectionPending, Dcb axis). Standalone/deploy use passes nothing.
-type onAppended = array<(string, int)> => unit
-let noTracking: onAppended = _ => ()
-
-// SELECT list shared by read and readStream. `data`/`meta` are jsonb (returned
-// already parsed); `tags` is text[] (a JS array); the cursor and recorded_at are
-// computed in SQL so the row maps straight to a rawSequencedEvent.
-let selectColumns = "
-  lpad(transaction_id::text, 20, '0') || ':' || lpad(position::text, 20, '0') AS cursor,
-  event_type,
-  tags,
-  data,
-  meta,
-  to_char(recorded_at AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"') AS recorded_at
-"
-
-// Decode a 'key=value' tag string (split on the first '=') back to a DcbTag.tag.
-let decodeTag = (s: string): DcbTag.tag =>
-  switch s->String.indexOf("=") {
-  | -1 => {key: s, value: ""}
-  | i => {
-      key: s->String.slice(~start=0, ~end=i),
-      value: s->String.slice(~start=i + 1, ~end=s->String.length),
-    }
-  }
-
-let decodeTags = (v: option<JSON.t>): array<DcbTag.tag> =>
-  switch v {
-  | Some(JSON.Array(arr)) =>
-    arr->Array.filterMap(x =>
-      switch x {
-      | JSON.String(s) => Some(decodeTag(s))
-      | _ => None
-      }
-    )
-  | _ => []
-  }
-
-let rowToEvent = (row: dict<JSON.t>): DcbEventLog_Adapter.rawSequencedEvent => {
-  let str = key =>
-    switch row->Dict.get(key) {
-    | Some(JSON.String(s)) => s
-    | _ => ""
-    }
-  let meta = switch row->Dict.get("meta") {
-  | Some(metaJson) => metaJson->S.parseJsonOrThrow(Reventless.Message.metaSchema)
-  | None => JsError.throwWithMessage("missing meta column in dcb_event row")
-  }
-  {
-    DcbEventLog_Adapter.position: str("cursor"),
-    eventType: str("event_type"),
-    data: row->Dict.get("data")->Option.getOr(JSON.Encode.null),
-    tags: decodeTags(row->Dict.get("tags")),
-    meta,
-    recordedAt: str("recorded_at"),
-  }
-}
-
-// A tiny positional-parameter builder. Postgres uses `$1, $2, …` (not `?`), so we
-// accumulate params and mint tokens as we build the WHERE. A token may be reused
-// (same `$N`) to reference one param twice — used for the `after` cursor columns.
-type paramBuilder = {mutable params: array<JSON.t>}
-let mkBuilder = () => {params: []}
-let param = (b: paramBuilder, v: JSON.t): string => {
-  b.params->Array.push(v)
-  "$" ++ Int.toString(b.params->Array.length)
-}
-
-// Build the read WHERE + params for a query. `applyFence` gates the xmin read
-// barrier (true for consumer reads, so cursors are stable). `after` is the
-// decoded (tx, pos) cursor pair as numeric strings.
-let buildReadWhere = (
-  b: paramBuilder,
-  ~name: string,
-  ~query: DcbTag.query,
-  ~after: option<(string, string)>,
-  ~applyFence: bool,
-): string => {
-  let parts = [`log_name = ${b->param(JSON.Encode.string(name))}`]
-  if applyFence {
-    parts->Array.push("transaction_id < pg_snapshot_xmin(pg_current_snapshot())")
-  }
-  switch after {
-  | Some((tx, pos)) =>
-    let txP = b->param(JSON.Encode.string(tx))
-    let posP = b->param(JSON.Encode.string(pos))
-    parts->Array.push(
-      `(transaction_id > ${txP}::xid8 OR (transaction_id = ${txP}::xid8 AND position > ${posP}::bigint))`,
-    )
-  | None => ()
-  }
-
-  if query->Array.length > 0 {
-    let clauseSqls = query->Array.map(clause => {
-      let clauseParts = []
-      switch clause.eventTypes {
-      | Some(types) if types->Array.length > 0 =>
-        let ph = types->Array.map(t => b->param(JSON.Encode.string(t)))->Array.join(",")
-        clauseParts->Array.push(`event_type IN (${ph})`)
-      | _ => ()
-      }
-      switch clause.tags {
-      | Some(tags) if tags->Array.length > 0 =>
-        let arr =
-          tags
-          ->Array.map(t => b->param(JSON.Encode.string(t.key ++ "=" ++ t.value)))
-          ->Array.join(",")
-        clauseParts->Array.push(`tags @> ARRAY[${arr}]::text[]`)
-      | _ => ()
-      }
-      clauseParts->Array.length == 0 ? "TRUE" : "(" ++ clauseParts->Array.join(" AND ") ++ ")"
-    })
-    parts->Array.push("(" ++ clauseSqls->Array.join(" OR ") ++ ")")
-  }
-
-  parts->Array.join(" AND ")
-}
-
-// 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+/"), "")
-  t == "" ? "0" : t
-}
-
-// Split a '<xid8>:<position>' cursor into its two numeric-string columns.
-let decodeCursor = (pos: DcbTag.sequencePosition): option<(string, string)> =>
-  switch pos->String.split(":") {
-  | [tx, p] => Some((stripZeros(tx), stripZeros(p)))
-  | _ => None
-  }
-
-// Rows-per-page for readStream keyset pagination.
-let pageSize = 500
-
-let isConflict = (exn: exn): bool => {
-  let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("")
-  msg->String.includes("dcb_conflict") ||
-  msg->String.includes("duplicate key") ||
-  msg->String.includes("23505")
-}
-
-let countAll = async (pool: PgDriver.pool): int =>
-  switch await pool->PgDriver.queryOne("SELECT COUNT(*)::bigint AS c FROM dcb_event", []) {
-  | Some(row) =>
-    switch row->Dict.get("c") {
-    | Some(JSON.String(s)) => s->Int.fromString->Option.getOr(0)
-    | Some(JSON.Number(n)) => Float.toInt(n)
-    | _ => 0
-    }
-  | None => 0
-  }
+include DcbEventLogStorage_Postgres_Ops
 
 let makeStorage = (
   ~pool: PgDriver.pool,
   ~name: string,
-  ~indexes as _,
-  ~partitionTag as _,
-  ~crossPartitionTagKeys as _=?,
-  ~opts as _,
+  ~indexes,
+  ~partitionTag,
+  ~crossPartitionTagKeys=?,
+  ~opts,
   ~lockStrategy: lockStrategy=#AdvisoryLocks,
   ~onAppended=noTracking,
 ) => {
-  // Fenced head cursor: the highest (transaction_id, position) visible under the
-  // xmin barrier. Stable across reads, so it is a safe consistency marker.
-  let currentHead = async (): option<string> =>
-    switch await pool->PgDriver.queryOne(
-      "SELECT lpad(transaction_id::text, 20, '0') || ':' || lpad(position::text, 20, '0') AS head
-         FROM dcb_event
-        WHERE log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
-        ORDER BY transaction_id DESC, position DESC
-        LIMIT 1",
-      [JSON.Encode.string(name)],
-    ) {
-    | Some(row) =>
-      switch row->Dict.get("head") {
-      | Some(JSON.String(s)) => Some(s)
-      | _ => None
-      }
-    | None => None
-    }
-
-  let runQuery = async (~query, ~after): array<DcbEventLog_Adapter.rawSequencedEvent> => {
-    let b = mkBuilder()
-    let where = buildReadWhere(b, ~name, ~query, ~after, ~applyFence=true)
-    let sql = `SELECT ${selectColumns} FROM dcb_event WHERE ${where} ORDER BY transaction_id ASC, position ASC`
-    (await pool->PgDriver.query(sql, b.params))->Array.map(rowToEvent)
-  }
-
-  let read = async (~query: DcbTag.query, ~after=?): DcbEventLog_Adapter.rawReadResult => {
-    let afterCols = after->Option.flatMap(decodeCursor)
-    let events = await runQuery(~query, ~after=afterCols)
-    switch await currentHead() {
-    | Some(head) => {DcbEventLog_Adapter.events, headPosition: head}
-    | None => ({DcbEventLog_Adapter.events: events}: DcbEventLog_Adapter.rawReadResult)
-    }
-  }
-
-  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(
-          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->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 {
-      | Some(a) => fields->Array.push(("after", JSON.Encode.string(a)))
-      | None => ()
-      }
-      JSON.Encode.string(JSON.stringify(JSON.Object(Dict.fromArray(fields))))
-    | None => JSON.Encode.null
-    }
-
-    try {
-      let rows = await pool->PgDriver.query(
-        "SELECT dcb_append($1, $2::jsonb, $3::jsonb, $4) AS pos",
-        [
-          JSON.Encode.string(name),
-          JSON.Encode.string(JSON.stringify(eventsJson)),
-          conditionParam,
-          JSON.Encode.string(strategyParam(lockStrategy)),
-        ],
-      )
-      switch rows->Array.get(0)->Option.flatMap(r => r->Dict.get("pos")) {
-      | Some(JSON.String(cursor)) =>
-        // Feed the projection checkpoint (Dcb axis): (msgId, numeric position).
-        onAppended(
-          newEvents->Array.filterMap(ev =>
-            switch decodeCursor(cursor) {
-            | Some((_, pos)) =>
-              pos->Int.fromString->Option.map(p => (ev.meta.Reventless.Message.msgId, p))
-            | None => None
-            }
-          ),
-        )
-        Ok(cursor)
-      | _ => Error(ReventlessInfra.DcbEventLog.StorageFailure("dcb_append returned no position"))
-      }
-    } catch {
-    | exn =>
-      isConflict(exn)
-        ? Error(ReventlessInfra.DcbEventLog.Conflict)
-        : Error(
-            ReventlessInfra.DcbEventLog.StorageFailure(
-              exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("storage error"),
-            ),
-          )
-    }
-  }
-
-  // ~strongConsistency is a genuine no-op here: every read applies the xmin
-  // barrier, so it is always safely consistent (at the cost of a few ms lag).
-  //
-  // Keyset pagination on (transaction_id, position): one ordered SQL source, no
-  // per-clause fan-out / k-way merge / dedup (the DynamoDB runtime's layers have
-  // no Postgres counterpart). Each page reads strictly after the previous page's
-  // last row; a short page ends the stream.
-  let readStream = (~query: DcbTag.query, ~after=?, ~strongConsistency as _=?) =>
-    Stream.paginateEffect(after->Option.flatMap(decodeCursor), cursor =>
-      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)}`
-        pool->PgDriver.query(sql, b.params)
-      })->Effect.map(rows => {
-        let events = rows->Array.map(rowToEvent)
-        // Continue only on a full page; the next `after` is this page's last row.
-        let next = if rows->Array.length < pageSize {
-          None
-        } else {
-          switch rows->Array.get(rows->Array.length - 1) {
-          | Some(lastRow) =>
-            switch (lastRow->Dict.get("tx_raw"), lastRow->Dict.get("pos_raw")) {
-            | (Some(JSON.String(tx)), Some(JSON.String(p))) => Some(Some((tx, p)))
-            | _ => None
-            }
-          | None => None
-          }
-        }
-        (events, next)
-      })
-    )
-
-  let ops: DcbEventLog_Adapter.operations = {read, append, readStream}
+  let (name, ops) = makeOps(
+    ~pool,
+    ~name,
+    ~indexes,
+    ~partitionTag,
+    ~crossPartitionTagKeys?,
+    ~opts,
+    ~lockStrategy,
+    ~onAppended,
+  )
   (name, ops, {DcbEventLog_Adapter.resources: [], operations: Pulumi.Output.make(ops)})
 }