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

package/src/PgSchema.res.mjs

@@ -5,6 +5,9 @@ import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
 let tableStatements = [
   "CREATE TABLE IF NOT EXISTS event_log (\n     log_name      text   NOT NULL,\n     aggregate_id  text   NOT NULL,\n     seq_nr        bigint NOT NULL,\n     payload       jsonb  NOT NULL,\n     msg_id        text,\n     global_seq    bigint GENERATED ALWAYS AS IDENTITY,\n     PRIMARY KEY (log_name, aggregate_id, seq_nr)\n   )",
   "CREATE TABLE IF NOT EXISTS snapshot (\n     log_name      text   NOT NULL,\n     aggregate_id  text   NOT NULL,\n     seq_nr        bigint NOT NULL,\n     state         jsonb  NOT NULL,\n     schema_hash   text   NOT NULL,\n     PRIMARY KEY (log_name, aggregate_id)\n   )",
+  "ALTER TABLE event_log ADD COLUMN IF NOT EXISTS transaction_id xid8 NOT NULL DEFAULT pg_current_xact_id()",
+  "CREATE INDEX IF NOT EXISTS event_log_tx_gseq ON event_log (log_name, transaction_id, global_seq)",
+  "CREATE TABLE IF NOT EXISTS event_log_subscription (\n     subscriber      text   PRIMARY KEY,\n     last_tx         xid8   NOT NULL DEFAULT '0'::xid8,\n     last_global_seq bigint NOT NULL DEFAULT 0\n   )",
   "CREATE TABLE IF NOT EXISTS dcb_event (\n     log_name        text        NOT NULL,\n     position        bigint      GENERATED ALWAYS AS IDENTITY,\n     transaction_id  xid8        NOT NULL DEFAULT pg_current_xact_id(),\n     event_type      text        NOT NULL,\n     tags            text[]      NOT NULL DEFAULT '{}',\n     data            jsonb       NOT NULL,\n     meta            jsonb       NOT NULL,\n     recorded_at     timestamptz NOT NULL DEFAULT now(),\n     PRIMARY KEY (log_name, position)\n   )",
   "CREATE INDEX IF NOT EXISTS dcb_event_tags_gin ON dcb_event USING gin (tags)",
   "CREATE INDEX IF NOT EXISTS dcb_event_type_pos ON dcb_event (log_name, event_type, position)",
@@ -17,9 +20,12 @@ let dcbConditionWhereFn = "\nCREATE OR REPLACE FUNCTION dcb_after_frag(p_tx xid8
 
 let dcbAppendFn = "\nCREATE OR REPLACE FUNCTION dcb_append(\n  p_log_name      text,\n  p_events        jsonb,\n  p_condition     jsonb DEFAULT NULL,\n  p_lock_strategy text  DEFAULT 'advisory'\n) RETURNS text\nLANGUAGE plpgsql AS $fn$\nDECLARE\n  v_lock_keys bigint[];\n  v_after_raw text;\n  v_after_tx  xid8;\n  v_after_pos bigint;\n  v_where     text;\n  v_conflict  boolean;\n  v_last_pos  bigint;\n  v_key       bigint;\nBEGIN\n  -- 1. Lock keys: every tag in written events UNION every tag in the condition.\n  SELECT array_agg(DISTINCT k ORDER BY k) INTO v_lock_keys\n  FROM (\n    SELECT hashtextextended(p_log_name || '=' || tag, 0) AS k\n      FROM jsonb_array_elements(p_events) ev,\n           jsonb_array_elements_text(ev->'tags') tag\n    UNION\n    SELECT hashtextextended(p_log_name || '=' || tag, 0) AS k\n      FROM jsonb_array_elements(COALESCE(p_condition->'query', '[]'::jsonb)) qi,\n           jsonb_array_elements_text(COALESCE(qi->'tags', '[]'::jsonb)) tag\n  ) s;\n\n  -- 2. Acquire in sorted order.\n  IF v_lock_keys IS NOT NULL THEN\n    IF p_lock_strategy = 'rows' THEN\n      INSERT INTO dcb_scope(log_name, scope_hash)\n        SELECT p_log_name, k FROM unnest(v_lock_keys) k\n        ON CONFLICT DO NOTHING;\n      PERFORM 1 FROM dcb_scope\n        WHERE log_name = p_log_name AND scope_hash = ANY(v_lock_keys)\n        ORDER BY scope_hash\n        FOR UPDATE;\n    ELSE\n      FOREACH v_key IN ARRAY v_lock_keys LOOP\n        PERFORM pg_advisory_xact_lock(v_key);\n      END LOOP;\n    END IF;\n  END IF;\n\n  -- 3. Exact condition check under the held locks (READ COMMITTED is race-free\n  --    here: a conflicting concurrent writer is either committed+visible or\n  --    blocked on our lock).\n  IF p_condition IS NOT NULL THEN\n    v_after_raw := NULLIF(p_condition->>'after', '');\n    IF v_after_raw IS NOT NULL THEN\n      -- Cursor is '<xid8>:<position>', each zero-padded to 20 digits. Strip the\n      -- padding before casting (bigint tolerates leading zeros; be explicit for\n      -- xid8, guarding the all-zeros case).\n      v_after_tx  := COALESCE(NULLIF(ltrim(split_part(v_after_raw, ':', 1), '0'), ''), '0')::xid8;\n      v_after_pos := split_part(v_after_raw, ':', 2)::bigint;\n    END IF;\n    v_where := dcb_condition_where(p_log_name, p_condition->'query', v_after_tx, v_after_pos);\n    EXECUTE 'SELECT EXISTS (SELECT 1 FROM dcb_event WHERE ' || v_where || ')'\n      INTO v_conflict;\n    IF v_conflict THEN\n      RAISE EXCEPTION 'dcb_conflict' USING ERRCODE = 'P0001';\n    END IF;\n  END IF;\n\n  -- 4. Insert every event in array order; positions come from the IDENTITY seq.\n  WITH ins AS (\n    INSERT INTO dcb_event(log_name, event_type, tags, data, meta)\n    SELECT p_log_name,\n           ev->>'event_type',\n           ARRAY(SELECT jsonb_array_elements_text(ev->'tags')),\n           ev->'data',\n           ev->'meta'\n      FROM jsonb_array_elements(p_events) WITH ORDINALITY AS t(ev, ord)\n     ORDER BY ord\n    RETURNING position\n  )\n  SELECT max(position) INTO v_last_pos FROM ins;\n\n  -- 5. Wake the change feed (Phase D). No-op if nobody is LISTENing.\n  PERFORM pg_notify('dcb_' || p_log_name, v_last_pos::text);\n\n  RETURN lpad(pg_current_xact_id()::text, 20, '0') || ':' || lpad(v_last_pos::text, 20, '0');\nEND;\n$fn$;\n";
 
+let eventLogNotifyFn = "\nCREATE OR REPLACE FUNCTION event_log_notify() RETURNS trigger\nLANGUAGE plpgsql AS $fn$\nBEGIN\n  PERFORM pg_notify('evlog_' || log_name, '')\n    FROM (SELECT DISTINCT log_name FROM new_rows) s;\n  RETURN NULL;\nEND;\n$fn$;\n\nCREATE OR REPLACE TRIGGER event_log_notify_trg\n  AFTER INSERT ON event_log\n  REFERENCING NEW TABLE AS new_rows\n  FOR EACH STATEMENT EXECUTE FUNCTION event_log_notify();\n";
+
 let functionStatements = [
   dcbConditionWhereFn,
-  dcbAppendFn
+  dcbAppendFn,
+  eventLogNotifyFn
 ];
 
 async function ensureSchema(pool) {
@@ -32,13 +38,14 @@ async function ensureSchema(pool) {
 }
 
 async function truncateAll(pool) {
-  return await PgDriver$ReventlessPostgres.exec(pool, "TRUNCATE event_log, snapshot, dcb_event, dcb_scope, dcb_subscription RESTART IDENTITY");
+  return await PgDriver$ReventlessPostgres.exec(pool, "TRUNCATE event_log, snapshot, dcb_event, dcb_scope, dcb_subscription, event_log_subscription RESTART IDENTITY");
 }
 
 export {
   tableStatements,
   dcbConditionWhereFn,
   dcbAppendFn,
+  eventLogNotifyFn,
   functionStatements,
   ensureSchema,
   truncateAll,

package/src/QueryDbStorage_Postgres.res

@@ -97,23 +97,36 @@ let withId = (item: JSON.t, partitionKey: string): JSON.t =>
   | _ => item
   }
 
-let makeStorage = (
+// Plain operation set for a read model's qdb table. Exposed separately from
+// `makeStorage` so the deployed-Lambda runtime (reventless-aws) can bind ops
+// without touching the Pulumi-shaped `storage` record.
+let makeOperations = (
   ~pool: PgDriver.pool,
   ~name: string,
   ~indexes: array<indexConfig>,
   ~subIdField: option<string>,
-): QueryDb_Adapter.storage => {
+): QueryDb_Adapter.operations => {
   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))
-  }
+  // Schema setup is async and LAZY: kicked off by the first operation, not at
+  // construction. A deploy-time caller may build the ops on a machine that
+  // cannot reach the database (VPC-private RDS) — only the runtime, which
+  // actually calls an operation, may open a connection. Subsequent operations
+  // await the same promise (table + index creation runs exactly once).
+  let readyRef: ref<option<promise<unit>>> = ref(None)
+  let ready = () =>
+    switch readyRef.contents {
+    | Some(p) => p
+    | None =>
+      let p = {
+        open Promise
+        ensureTable(~pool, ~table)->then(() => ensureIndexes(~pool, ~table, ~indexes))
+      }
+      readyRef := Some(p)
+      p
+    }
 
   let rowsFor = async (id: string): array<JSON.t> => {
-    await ready
+    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)],
@@ -121,7 +134,7 @@ let makeStorage = (
   }
 
   let saveOne = async (id: string, state: JSON.t, ttl: option<int>) => {
-    await ready
+    await ready()
     let subKey = computeSubKey(state, subIdField)
     let expiresAt = switch ttl {
     | Some(t) => JSON.Encode.int(t)
@@ -167,7 +180,7 @@ let makeStorage = (
   // 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
+    await ready()
     let existing = (await rowsFor(id))->Array.get(0)->Option.flatMap(JSON.Decode.object)
     let current =
       existing
@@ -186,7 +199,7 @@ let makeStorage = (
   }
 
   let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
-    await ready
+    await ready()
     let _ = switch subIdOpt {
     | None =>
       await pool->PgDriver.query(
@@ -219,11 +232,19 @@ let makeStorage = (
     delete,
     deleteBatch,
   }
+  ops
+}
 
+let makeStorage = (
+  ~pool: PgDriver.pool,
+  ~name: string,
+  ~indexes: array<indexConfig>,
+  ~subIdField: option<string>,
+): QueryDb_Adapter.storage => {
   {
     QueryDb_Adapter.resources: [],
     dataSourceName: ""->Pulumi.Output.make,
-    operations: Pulumi.Output.make(ops),
+    operations: Pulumi.Output.make(makeOperations(~pool, ~name, ~indexes, ~subIdField)),
   }
 }
 

package/src/QueryDbStorage_Postgres.res.mjs

@@ -102,15 +102,26 @@ function withId(item, partitionKey) {
   return copy;
 }
 
-function makeStorage(pool, name, indexes, subIdField) {
+function makeOperations(pool, name, indexes, subIdField) {
   let table = tableName(name);
-  let ready = ensureTable(pool, table).then(() => ensureIndexes(pool, table, indexes));
+  let readyRef = {
+    contents: undefined
+  };
+  let ready = () => {
+    let p = readyRef.contents;
+    if (p !== undefined) {
+      return p;
+    }
+    let p$1 = ensureTable(pool, table).then(() => ensureIndexes(pool, table, indexes));
+    readyRef.contents = p$1;
+    return p$1;
+  };
   let rowsFor = async id => {
-    await ready;
+    await ready();
     return (await PgDriver$ReventlessPostgres.query(pool, `SELECT item FROM ` + table + ` WHERE partition_key = $1 AND ` + notExpiredClause + ` ORDER BY sub_key ASC`, [id])).map(decodeItem);
   };
   let saveOne = async (id, state, ttl) => {
-    await ready;
+    await ready();
     let subKey = computeSubKey(state, subIdField);
     let expiresAt = ttl !== undefined ? ttl : null;
     await PgDriver$ReventlessPostgres.query(pool, `INSERT INTO ` + table + `(partition_key, sub_key, item, expires_at)
@@ -146,7 +157,7 @@ function makeStorage(pool, name, indexes, subIdField) {
     };
   };
   let count = async (id, fieldName, inc) => {
-    await ready;
+    await ready();
     let existing = Stdlib_Option.flatMap((await rowsFor(id))[0], Stdlib_JSON.Decode.object);
     let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
     let next = current + inc | 0;
@@ -160,7 +171,7 @@ function makeStorage(pool, name, indexes, subIdField) {
     };
   };
   let $$delete = async (id, subIdOpt) => {
-    await ready;
+    await ready();
     if (subIdOpt !== undefined) {
       await PgDriver$ReventlessPostgres.query(pool, `DELETE FROM ` + table + ` WHERE partition_key = $1 AND sub_key = $2`, [
         id,
@@ -184,7 +195,7 @@ function makeStorage(pool, name, indexes, subIdField) {
       _0: undefined
     };
   };
-  let ops = {
+  return {
     load: load,
     loadStream: loadStream,
     save: save,
@@ -193,10 +204,13 @@ function makeStorage(pool, name, indexes, subIdField) {
     delete: $$delete,
     deleteBatch: deleteBatch
   };
+}
+
+function makeStorage(pool, name, indexes, subIdField) {
   return {
     resources: [],
     dataSourceName: Pulumi.output(""),
-    operations: Pulumi.output(ops)
+    operations: Pulumi.output(makeOperations(pool, name, indexes, subIdField))
   };
 }
 
@@ -219,6 +233,7 @@ export {
   decodeItem,
   computeSubKey,
   withId,
+  makeOperations,
   makeStorage,
   Make,
 }

package/src/QueryEnginePostgres.res

@@ -122,6 +122,181 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
   }
 
+  // ---------------------------------------------------------------------------
+  // GraphQL resolver push-downs (B3.2). The Postgres resolver Lambda dispatches
+  // these; they parallel the SQLite backend's `lookupByField` / `listPage` (the
+  // ones registered on LocalBus). All return `id`-carrying items (COALESCE from
+  // partition_key), matching the shape `QueryDbListQuery.run` operates over so
+  // the connection helpers agree.
+  //
+  // Text comparisons use `COLLATE "C"` (byte order — memcmp), the Postgres
+  // analogue of SQLite's BINARY collation, so cursor/order comparisons match
+  // JS string `<` for the ASCII id/status/name fields used as sort/filter keys.
+  // ---------------------------------------------------------------------------
+
+  // Equality lookup on an indexed JSON field — rides the expression index
+  // (`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 b = {params: []}
+    let sql = `SELECT partition_key, item FROM ${table} WHERE ${col(field)} = ${b->param(
+        JSON.Encode.string(value),
+      )} AND ${notExpired}`
+    (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+  }
+
+  // Batched-by-ids lookup: BatchGetItem analogue over the projection's own
+  // table. Single-key projections only (partition_key = the id). Missing ids
+  // drop out of the response (no cardinality preservation), matching
+  // BatchGetItem semantics.
+  let byIds = async (~readModelName, ids: array<string>): array<JSON.t> => {
+    if ids->Array.length == 0 {
+      []
+    } else {
+      let table = QueryDbStorage_Postgres.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(
+          idsJson,
+        )}::text[]) AND ${notExpired}`
+      (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+    }
+  }
+
+  // COALESCE(item->>'id', partition_key) — the effective id, byte-ordered.
+  let idExprC = `COALESCE(item->>'id', partition_key) COLLATE "C"`
+  let jsonTextC = (field: string): string => `${col(field)} COLLATE "C"`
+
+  // 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
+  // exactly for the shapes it handles; returns `None` (→ the resolver Lambda
+  // falls back to `scan` + the shared spec) for shapes not bit-exact in SQL:
+  // case-insensitive search/searchPrefix, Relay-global-id `ids`, and backward
+  // pagination (last/before). Cursor values, edges, and pageInfo are built by
+  // the SAME `QueryDbListQuery` helpers the fallback uses, so only the
+  // WHERE/ORDER/LIMIT needs to match — the parity harness asserts it does
+  // (SQLite ≡ Postgres ≡ spec). Mirrors QueryDbStorage_Sqlite.listPage.
+  let listPage = async (
+    ~readModelName,
+    ~argsDict: dict<JSON.t>,
+    ~capability: GraphQL_FragmentGenerator.serverCapability,
+    ~labelField as _,
+  ): option<JSON.t> => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let filterDict =
+      argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+    let strNonEmpty = k =>
+      filterDict
+      ->Dict.get(k)
+      ->Option.flatMap(JSON.Decode.string)
+      ->Option.mapOr(false, s => s->String.length > 0)
+    let hasIds =
+      filterDict
+      ->Dict.get("ids")
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.mapOr(false, a => a->Array.length > 0)
+    let last = argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)
+    let before = argsDict->Dict.get("before")->Option.flatMap(JSON.Decode.string)
+    if (
+      strNonEmpty("search") ||
+      strNonEmpty("searchPrefix") ||
+      hasIds ||
+      last->Option.isSome ||
+      before->Option.isSome
+    ) {
+      None
+    } else {
+      let b = {params: []}
+      let whereParts = [notExpired]
+      let valString = v =>
+        switch v->JSON.Decode.string {
+        | Some(s) => Some(s)
+        | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))
+        }
+      capability.filterFields->Array.forEach(f => {
+        switch filterDict->Dict.get(f.name ++ "Eq") {
+        | Some(v) when v != JSON.Encode.null =>
+          whereParts->Array.push(
+            `${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 =>
+            whereParts->Array.push(
+              `${jsonTextC(f.name)} >= ${b->param(
+                  JSON.Encode.string(valString(v)->Option.getOr("")),
+                )}`,
+            )
+          | _ => ()
+          }
+          switch filterDict->Dict.get(f.name ++ "To") {
+          | Some(v) when v != JSON.Encode.null =>
+            whereParts->Array.push(
+              `${jsonTextC(f.name)} <= ${b->param(
+                  JSON.Encode.string(valString(v)->Option.getOr("")),
+                )}`,
+            )
+          | _ => ()
+          }
+        }
+      })
+      let orderByDict = argsDict->Dict.get("orderBy")->Option.flatMap(JSON.Decode.object)
+      let orderByField =
+        orderByDict->Option.flatMap(ob => ob->Dict.get("field"))->Option.flatMap(JSON.Decode.string)
+      let isDesc =
+        orderByDict
+        ->Option.flatMap(ob => ob->Dict.get("direction"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.getOr("ASC") == "DESC"
+      let cursorExpr = switch orderByField {
+      | Some(f) => jsonTextC(f)
+      | None => idExprC
+      }
+      switch argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string) {
+      | Some(c) =>
+        whereParts->Array.push(
+          `${cursorExpr} ${isDesc ? "<" : ">"} ${b->param(
+              JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)),
+            )}`,
+        )
+      | None => ()
+      }
+      let orderClause = switch orderByField {
+      | Some(f) => `${jsonTextC(f)} ${isDesc ? "DESC" : "ASC"}, ${idExprC} ASC`
+      | None => `${idExprC} ASC`
+      }
+      let pageSize =
+        argsDict
+        ->Dict.get("first")
+        ->Option.flatMap(JSON.Decode.float)
+        ->Option.map(Float.toInt)
+        ->Option.getOr(ReventlessCore.QueryDbListQuery.defaultListPageSize)
+      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 hasMore = rows->Array.length > pageSize
+      let pageItems = rows->Array.slice(~start=0, ~end=pageSize)
+      let cursorField = orderByField->Option.getOr("id")
+      let cursorValueOf = item =>
+        ReventlessCore.QueryDbListQuery.getFieldString(item, cursorField)->Option.getOr(
+          ReventlessCore.QueryDbListQuery.getId(item),
+        )
+      Some(
+        ReventlessCore.QueryDbListQuery.buildConnection(
+          ~pageItems,
+          ~hasNextPage=hasMore,
+          ~hasPreviousPage=false,
+          ~cursorValueOf,
+        ),
+      )
+    }
+  }
+
   let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
     Pulumi.Output.make({QueryEngine.scan, query})
 }

package/src/QueryEnginePostgres.res.mjs

@@ -1,8 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
 import * as QueryDbStorage_Postgres$ReventlessPostgres from "./QueryDbStorage_Postgres.res.mjs";
 
 function valueToText(v) {
@@ -145,6 +147,90 @@ function Make(P) {
     let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + where.join(" AND ") + ` ORDER BY partition_key, sub_key LIMIT ` + param(b, limit);
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
   };
+  let indexLookup = async (readModelName, field, value) => {
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let b = {
+      params: []
+    };
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + col(field) + ` = ` + param(b, value) + ` AND ` + QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+    return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+  };
+  let byIds = async (readModelName, ids) => {
+    if (ids.length === 0) {
+      return [];
+    }
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let b = {
+      params: []
+    };
+    let idsJson = ids.map(prim => prim);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE partition_key = ANY(` + param(b, idsJson) + `::text[]) AND ` + QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+    return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+  };
+  let idExprC = `COALESCE(item->>'id', partition_key) COLLATE "C"`;
+  let jsonTextC = field => col(field) + ` COLLATE "C"`;
+  let listPage = async (readModelName, argsDict, capability, param$1) => {
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
+    let strNonEmpty = k => Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string), false, s => s.length > 0);
+    let hasIds = Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), false, a => a.length !== 0);
+    let last = Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float);
+    let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+    if (strNonEmpty("search") || strNonEmpty("searchPrefix") || hasIds || Stdlib_Option.isSome(last) || Stdlib_Option.isSome(before)) {
+      return;
+    }
+    let b = {
+      params: []
+    };
+    let whereParts = [QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause];
+    let valString = v => {
+      let s = Stdlib_JSON.Decode.string(v);
+      if (s !== undefined) {
+        return s;
+      } else {
+        return Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString());
+      }
+    };
+    capability.filterFields.forEach(f => {
+      let v = filterDict[f.name + "Eq"];
+      if (v !== undefined && v !== null) {
+        whereParts.push(jsonTextC(f.name) + ` = ` + param(b, Stdlib_Option.getOr(valString(v), "")));
+      }
+      if (!f.range) {
+        return;
+      }
+      let v$1 = filterDict[f.name + "From"];
+      if (v$1 !== undefined && v$1 !== null) {
+        whereParts.push(jsonTextC(f.name) + ` >= ` + param(b, Stdlib_Option.getOr(valString(v$1), "")));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        whereParts.push(jsonTextC(f.name) + ` <= ` + param(b, Stdlib_Option.getOr(valString(v$2), "")));
+        return;
+      }
+    });
+    let orderByDict = Stdlib_Option.flatMap(argsDict["orderBy"], Stdlib_JSON.Decode.object);
+    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) {
+      whereParts.push(cursorExpr + ` ` + (
+        isDesc ? "<" : ">"
+      ) + ` ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(c)));
+    }
+    let orderClause = orderByField !== undefined ? jsonTextC(orderByField) + ` ` + (
+        isDesc ? "DESC" : "ASC"
+      ) + `, ` + idExprC + ` ASC` : idExprC + ` ASC`;
+    let pageSize = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0), QueryDbListQuery$ReventlessCore.defaultListPageSize);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + whereParts.join(" AND ") + ` ORDER BY ` + orderClause + ` LIMIT ` + param(b, pageSize + 1 | 0);
+    let rows = (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+    let hasMore = rows.length > pageSize;
+    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);
+  };
   let make = _allQueryDbs => Pulumi.output({
     scan: scan,
     query: query
@@ -152,6 +238,11 @@ function Make(P) {
   return {
     query: query,
     scan: scan,
+    indexLookup: indexLookup,
+    byIds: byIds,
+    idExprC: idExprC,
+    jsonTextC: jsonTextC,
+    listPage: listPage,
     make: make
   };
 }

package/tests/PostgresIntegrationTest.res

@@ -233,4 +233,72 @@ switch processEnv->Dict.get("PG_URL") {
       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)])
+
+      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"))
+
+      // 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)
+
+      // 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)])
+        )
+      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)
+    })
+  })
 }

package/tests/PostgresIntegrationTest.res.mjs

@@ -6,6 +6,7 @@ import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Mess
 import * as PgDriver$ReventlessPostgres from "../src/PgDriver.res.mjs";
 import * as PgSchema$ReventlessPostgres from "../src/PgSchema.res.mjs";
 import * as PgChangeFeed$ReventlessPostgres from "../src/PgChangeFeed.res.mjs";
+import * as EventLogChangeFeed$ReventlessPostgres from "../src/EventLogChangeFeed.res.mjs";
 import * as EventLogStorage_Postgres$ReventlessPostgres from "../src/EventLogStorage_Postgres.res.mjs";
 import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "../src/DcbEventLogStorage_Postgres.res.mjs";
 
@@ -313,6 +314,54 @@ if (url !== undefined) {
       globalThis.expect(again).toBe(0);
     });
   });
+  globalThis.describe("classic change feed (event_log, B2.5)", () => {
+    globalThis.test("drains classic events in commit order, with fields, then checkpoints", async () => {
+      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "cf-orders", opts, undefined);
+      let ops = match[1];
+      await ops.append(0, "agg-1", [
+        evJson("m0", 1),
+        evJson("m1", 2)
+      ]);
+      await ops.append(0, "agg-2", [evJson("m2", 3)]);
+      let collected = {
+        contents: []
+      };
+      let processed = await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-orders", "cf-sub", undefined, async evs => {
+        collected.contents = collected.contents.concat(evs);
+      });
+      globalThis.expect(processed).toBe(3);
+      globalThis.expect(collected.contents.length).toBe(3);
+      let first = collected.contents[0];
+      globalThis.expect(first.aggregateId).toBe("agg-1");
+      globalThis.expect(first.seqNr).toBe(0);
+      globalThis.expect(first.msgId).toEqual("m0");
+      let cursors = collected.contents.map(e => e.cursor);
+      let increasing = true;
+      for (let i = 1, i_finish = cursors.length; i < i_finish; ++i) {
+        if (cursors[i] <= cursors[i - 1 | 0]) {
+          increasing = false;
+        }
+      }
+      globalThis.expect(increasing).toBe(true);
+      let again = await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-orders", "cf-sub", undefined, async param => {});
+      globalThis.expect(again).toBe(0);
+    });
+    globalThis.test("concurrent appends across aggregates: every event drained exactly once", async () => {
+      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "cf-concurrent", opts, undefined);
+      let ops = match[1];
+      let promises = Stdlib_Array.make(20, 0).map((param, i) => ops.append(0, "agg-" + i.toString(), [evJson("m" + i.toString(), i)]));
+      await Promise.all(promises);
+      let collected = {
+        contents: []
+      };
+      await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-concurrent", "cf-conc-sub", undefined, async evs => {
+        collected.contents = collected.contents.concat(evs);
+      });
+      globalThis.expect(collected.contents.length).toBe(20);
+      let distinctCursors = new Set(collected.contents.map(e => e.cursor));
+      globalThis.expect(distinctCursors.size).toBe(20);
+    });
+  });
 } else {
   globalThis.test("Postgres integration (skipped — set PG_URL to run)", () => {
     globalThis.expect(true).toBe(true);