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

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.5 (2026-07-06)
+
+### Features
+
+* **reventless-aws:** classic EventLog Postgres deploy-time wiring + relay (B1 vertical) ([8235ba4](https://github.com/ReventlessDev/reventless-core/commit/8235ba44e506f7094d17251405c6a05c39789805))
+* **reventless-aws:** Postgres QueryDb storage vertical (B3.1) ([51a7993](https://github.com/ReventlessDev/reventless-core/commit/51a79934c1d9f59bb6f61233a90651d5eadf9f4e))
+* **reventless-postgres:** QueryEnginePostgres list/index/byIds resolver push-downs (B3.2a-1) ([8cb09e4](https://github.com/ReventlessDev/reventless-core/commit/8cb09e40cffa9698a251f1ee3fb17b016c4f8b07))
+
+
+# 3.0.0-alpha.4 (2026-07-05)
+
+### Features
+
+* **reventless-postgres:** classic event_log change feed (B2.5) ([59529c7](https://github.com/ReventlessDev/reventless-core/commit/59529c795395f37d29e935ba2d6bd5a3e7e8b5c0))
+
+
 # 3.0.0-alpha.3 (2026-07-05)
 
 **Note:** Version bump only for package @reventlessdev/reventless-postgres

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1783258950748)
-#Done(1783258952632)
+#Start(1783298008858)
+#Done(1783298010813)

package/lib/bs/ReventlessPostgres.mlmap

@@ -1,5 +1,6 @@
 randjbuildsystem
 DcbEventLogStorage_Postgres
+EventLogChangeFeed
 EventLogStorage_Postgres
 PgChangeFeed
 PgDriver
@@ -7,3 +8,4 @@ PgSchema
 PostgresIntegrationTest
 QueryDbStorage_Postgres
 QueryEnginePostgres
+QueryEnginePostgresListPageTest

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "48ea15db3d741cf15a2ff49dd0b47d86badf2b548ecb3859a896faf1e3a82a15",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1783258952640"
+  "generated_at": "1783298010821"
 }

package/lib/bs/src/EventLogChangeFeed.res

@@ -0,0 +1,184 @@
+// Classic `event_log` change feed (B2.5) — the aggregate-path analogue of
+// `PgChangeFeed` (which serves the DCB `dcb_event` log).
+//
+// Like the DCB feed this is NOT logical decoding: classic events are already
+// durably queryable in-table, so the feed is an xmin-fenced read over `event_log`
+// plus an `event_log_subscription` checkpoint. A statement-level AFTER INSERT
+// trigger (`event_log_notify`, see PgSchema) issues `pg_notify('evlog_<log>')`,
+// turning polling into near-real-time wakeup; a low-frequency fallback tick in the
+// consumer covers missed notifications.
+//
+// Cursor semantics mirror the DCB feed exactly: the opaque `<xid8>:<global_seq>`
+// string (zero-padded so string order == numeric order). Reads apply the xmin
+// barrier (`transaction_id < pg_snapshot_xmin(pg_current_snapshot())`), so a
+// returned cursor is stable forever — an event committed late (lower global_seq,
+// later commit) is never skipped by a checkpointing reader. `global_seq` alone,
+// being an IDENTITY assigned at INSERT, could NOT provide that guarantee.
+
+// Reuse the shared `<a>:<b>` cursor codec from the DCB storage — identical format.
+module Dcb = DcbEventLogStorage_Postgres
+
+// One classic event as the feed surfaces it. `payload` is the stored event JSON
+// verbatim; a bus/topic relay transforms it into its target shape (e.g. the AWS
+// EventCollector `{id, meta, event}` body) — that transform is not this package's
+// concern.
+type classicEvent = {
+  cursor: string,
+  aggregateId: string,
+  seqNr: int,
+  payload: JSON.t,
+  msgId: option<string>,
+}
+
+// One page of the feed. `events` are in (transaction_id, global_seq) order;
+// `cursor` is the checkpoint to persist and to pass as the next `after` (None when
+// the page was empty — nothing new).
+type batch = {
+  events: array<classicEvent>,
+  cursor: option<string>,
+}
+
+let selectColumns = "
+  lpad(transaction_id::text, 20, '0') || ':' || lpad(global_seq::text, 20, '0') AS cursor,
+  aggregate_id,
+  seq_nr,
+  payload,
+  msg_id
+"
+
+let coerceInt = (v: JSON.t): int =>
+  switch v {
+  | JSON.Number(n) => Float.toInt(n)
+  | JSON.String(s) => s->Int.fromString->Option.getOr(0)
+  | _ => 0
+  }
+
+let rowToEvent = (row: dict<JSON.t>): classicEvent => {
+  let str = key =>
+    switch row->Dict.get(key) {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+  {
+    cursor: str("cursor"),
+    aggregateId: str("aggregate_id"),
+    seqNr: row->Dict.get("seq_nr")->Option.map(coerceInt)->Option.getOr(0),
+    payload: row->Dict.get("payload")->Option.getOr(JSON.Encode.null),
+    msgId: switch row->Dict.get("msg_id") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    },
+  }
+}
+
+// Read up to `limit` events after `after` (the xmin-fenced feed query — whole log).
+// Returns the events and the cursor of the last one.
+let readBatch = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~after: option<string>=?,
+  ~limit: int=500,
+): batch => {
+  let params = [JSON.Encode.string(logName)]
+  let where = ref("log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())")
+  switch after->Option.flatMap(Dcb.decodeCursor) {
+  | Some((tx, pos)) =>
+    // $2 = tx (referenced twice), $3 = global_seq.
+    params->Array.push(JSON.Encode.string(tx))
+    params->Array.push(JSON.Encode.string(pos))
+    where :=
+      where.contents ++
+      " AND (transaction_id > $2::xid8 OR (transaction_id = $2::xid8 AND global_seq > $3::bigint))"
+  | None => ()
+  }
+  let sql = `SELECT ${selectColumns} FROM event_log WHERE ${where.contents} ORDER BY transaction_id ASC, global_seq ASC LIMIT ${Int.toString(limit)}`
+  let rows = await pool->PgDriver.query(sql, params)
+  let events = rows->Array.map(rowToEvent)
+  let cursor = switch events->Array.get(events->Array.length - 1) {
+  | Some(last) => Some(last.cursor)
+  | None => None
+  }
+  {events, cursor}
+}
+
+// --- Checkpoint contract (event_log_subscription) ---
+
+// The persisted checkpoint for `subscriber`, encoded as a cursor, or None if the
+// subscriber has never committed (→ replay from the beginning).
+let loadCheckpoint = async (pool: PgDriver.pool, ~subscriber: string): option<string> =>
+  switch await pool->PgDriver.queryOne(
+    "SELECT lpad(last_tx::text, 20, '0') || ':' || lpad(last_global_seq::text, 20, '0') AS cursor
+       FROM event_log_subscription WHERE subscriber = $1 AND last_global_seq > 0",
+    [JSON.Encode.string(subscriber)],
+  ) {
+  | Some(row) =>
+    switch row->Dict.get("cursor") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    }
+  | None => None
+  }
+
+// Persist the checkpoint. Idempotent upsert; decodes the cursor to its two columns
+// so a later `loadCheckpoint` round-trips exactly.
+let saveCheckpoint = async (pool: PgDriver.pool, ~subscriber: string, ~cursor: string): unit =>
+  switch Dcb.decodeCursor(cursor) {
+  | Some((tx, pos)) =>
+    let _ = await pool->PgDriver.query(
+      "INSERT INTO event_log_subscription(subscriber, last_tx, last_global_seq)
+       VALUES ($1, $2::xid8, $3::bigint)
+       ON CONFLICT (subscriber)
+       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_global_seq = EXCLUDED.last_global_seq",
+      [JSON.Encode.string(subscriber), JSON.Encode.string(tx), JSON.Encode.string(pos)],
+    )
+  | None => ()
+  }
+
+// --- Wakeup ---
+
+// LISTEN on `evlog_<logName>`; `onWake` fires on every notification. Returns the
+// dedicated client (caller owns it — release via unlisten). Pair with a
+// low-frequency fallback tick so a missed NOTIFY only adds latency, never a stall.
+let listen = (pool: PgDriver.pool, ~logName: string, ~onWake: unit => unit): promise<
+  PgDriver.client,
+> => pool->PgDriver.listen(~channel="evlog_" ++ logName, ~onNotify=_ => onWake())
+
+let unlisten = (client: PgDriver.client, ~logName: string): promise<unit> =>
+  client->PgDriver.unlisten(~channel="evlog_" ++ logName)
+
+// --- Reference consumer driver ---
+
+// Drain the feed for `subscriber` from its checkpoint: repeatedly readBatch →
+// `handle` the events → saveCheckpoint, until a short page. `handle` must be
+// idempotent (a crash between handle and checkpoint replays the last batch).
+// Returns the number of events processed.
+let drain = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~subscriber: string,
+  ~limit: int=500,
+  ~handle: array<classicEvent> => promise<unit>,
+): int => {
+  let processed = ref(0)
+  let cursor = ref(await loadCheckpoint(pool, ~subscriber))
+  let continue = ref(true)
+  while continue.contents {
+    let {events, cursor: newCursor} = await readBatch(pool, ~logName, ~after=?cursor.contents, ~limit)
+    if events->Array.length == 0 {
+      continue := false
+    } else {
+      await handle(events)
+      switch newCursor {
+      | Some(c) =>
+        await saveCheckpoint(pool, ~subscriber, ~cursor=c)
+        cursor := Some(c)
+      | None => ()
+      }
+      processed := processed.contents + events->Array.length
+      if events->Array.length < limit {
+        continue := false
+      }
+    }
+  }
+  processed.contents
+}

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

@@ -0,0 +1,134 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "./DcbEventLogStorage_Postgres.res.mjs";
+
+let selectColumns = "\n  lpad(transaction_id::text, 20, '0') || ':' || lpad(global_seq::text, 20, '0') AS cursor,\n  aggregate_id,\n  seq_nr,\n  payload,\n  msg_id\n";
+
+function coerceInt(v) {
+  switch (typeof v) {
+    case "string" :
+      return Stdlib_Option.getOr(Stdlib_Int.fromString(v, undefined), 0);
+    case "number" :
+      return v | 0;
+    default:
+      return 0;
+  }
+}
+
+function rowToEvent(row) {
+  let str = key => {
+    let match = row[key];
+    if (typeof match === "string") {
+      return match;
+    } else {
+      return "";
+    }
+  };
+  let match = row["msg_id"];
+  let tmp;
+  tmp = typeof match === "string" ? match : undefined;
+  return {
+    cursor: str("cursor"),
+    aggregateId: str("aggregate_id"),
+    seqNr: Stdlib_Option.getOr(Stdlib_Option.map(row["seq_nr"], coerceInt), 0),
+    payload: Stdlib_Option.getOr(row["payload"], null),
+    msgId: tmp
+  };
+}
+
+async function readBatch(pool, logName, after, limitOpt) {
+  let limit = limitOpt !== undefined ? limitOpt : 500;
+  let params = [logName];
+  let where = "log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())";
+  let match = Stdlib_Option.flatMap(after, DcbEventLogStorage_Postgres$ReventlessPostgres.decodeCursor);
+  if (match !== undefined) {
+    params.push(match[0]);
+    params.push(match[1]);
+    where = where + " AND (transaction_id > $2::xid8 OR (transaction_id = $2::xid8 AND global_seq > $3::bigint))";
+  }
+  let sql = `SELECT ` + selectColumns + ` FROM event_log WHERE ` + where + ` ORDER BY transaction_id ASC, global_seq ASC LIMIT ` + limit.toString();
+  let rows = await PgDriver$ReventlessPostgres.query(pool, sql, params);
+  let events = rows.map(rowToEvent);
+  let last = events[events.length - 1 | 0];
+  let cursor = last !== undefined ? last.cursor : undefined;
+  return {
+    events: events,
+    cursor: cursor
+  };
+}
+
+async function loadCheckpoint(pool, subscriber) {
+  let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT lpad(last_tx::text, 20, '0') || ':' || lpad(last_global_seq::text, 20, '0') AS cursor\n       FROM event_log_subscription WHERE subscriber = $1 AND last_global_seq > 0", [subscriber]);
+  if (row === undefined) {
+    return;
+  }
+  let match = row["cursor"];
+  if (typeof match === "string") {
+    return match;
+  }
+}
+
+async function saveCheckpoint(pool, subscriber, cursor) {
+  let match = DcbEventLogStorage_Postgres$ReventlessPostgres.decodeCursor(cursor);
+  if (match !== undefined) {
+    await PgDriver$ReventlessPostgres.query(pool, "INSERT INTO event_log_subscription(subscriber, last_tx, last_global_seq)\n       VALUES ($1, $2::xid8, $3::bigint)\n       ON CONFLICT (subscriber)\n       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_global_seq = EXCLUDED.last_global_seq", [
+      subscriber,
+      match[0],
+      match[1]
+    ]);
+    return;
+  }
+}
+
+function listen(pool, logName, onWake) {
+  return PgDriver$ReventlessPostgres.listen(pool, "evlog_" + logName, param => onWake());
+}
+
+function unlisten(client, logName) {
+  return PgDriver$ReventlessPostgres.unlisten(client, "evlog_" + logName);
+}
+
+async function drain(pool, logName, subscriber, limitOpt, handle) {
+  let limit = limitOpt !== undefined ? limitOpt : 500;
+  let processed = 0;
+  let cursor = await loadCheckpoint(pool, subscriber);
+  let $$continue = true;
+  while ($$continue) {
+    let match = await readBatch(pool, logName, cursor, limit);
+    let events = match.events;
+    if (events.length === 0) {
+      $$continue = false;
+    } else {
+      let newCursor = match.cursor;
+      await handle(events);
+      if (newCursor !== undefined) {
+        await saveCheckpoint(pool, subscriber, newCursor);
+        cursor = newCursor;
+      }
+      processed = processed + events.length | 0;
+      if (events.length < limit) {
+        $$continue = false;
+      }
+    }
+  };
+  return processed;
+}
+
+let Dcb;
+
+export {
+  Dcb,
+  selectColumns,
+  coerceInt,
+  rowToEvent,
+  readBatch,
+  loadCheckpoint,
+  saveCheckpoint,
+  listen,
+  unlisten,
+  drain,
+}
+/* PgDriver-ReventlessPostgres Not a pure module */

package/lib/bs/src/PgSchema.res

@@ -36,6 +36,19 @@ let tableStatements = [
      schema_hash   text   NOT NULL,
      PRIMARY KEY (log_name, aggregate_id)
    )",
+  // --- Classic change feed (B2.5) ---
+  // Stamp every classic event with its committing xid8 so the feed can apply the
+  // same xmin read barrier the DCB feed uses — global_seq (an IDENTITY assigned at
+  // INSERT, before commit) is unsafe as a feed cursor on its own (a late-committing
+  // lower global_seq would be skipped). Idempotent; the volatile default auto-stamps
+  // every future insert with no change to EventLogStorage_Postgres.append.
+  "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 (
+     subscriber      text   PRIMARY KEY,
+     last_tx         xid8   NOT NULL DEFAULT '0'::xid8,
+     last_global_seq bigint NOT NULL DEFAULT 0
+   )",
   // --- DCB event log (Phase B) ---
   "CREATE TABLE IF NOT EXISTS dcb_event (
      log_name        text        NOT NULL,
@@ -236,7 +249,28 @@ END;
 $fn$;
 "
 
-let functionStatements = [dcbConditionWhereFn, dcbAppendFn]
+// Classic change-feed wakeup (B2.5). A statement-level AFTER INSERT trigger fires
+// one pg_notify per distinct log_name touched by the statement, so the classic feed
+// gets the same near-real-time wakeup the DCB append's inline pg_notify provides —
+// without touching EventLogStorage_Postgres.append. No-op if nobody is LISTENing; a
+// low-frequency fallback tick in the consumer covers missed notifications.
+let eventLogNotifyFn = "
+CREATE OR REPLACE FUNCTION event_log_notify() RETURNS trigger
+LANGUAGE plpgsql AS $fn$
+BEGIN
+  PERFORM pg_notify('evlog_' || log_name, '')
+    FROM (SELECT DISTINCT log_name FROM new_rows) s;
+  RETURN NULL;
+END;
+$fn$;
+
+CREATE OR REPLACE TRIGGER event_log_notify_trg
+  AFTER INSERT ON event_log
+  REFERENCING NEW TABLE AS new_rows
+  FOR EACH STATEMENT EXECUTE FUNCTION event_log_notify();
+"
+
+let functionStatements = [dcbConditionWhereFn, dcbAppendFn, eventLogNotifyFn]
 
 let ensureSchema = async (pool: PgDriver.pool): unit => {
   for i in 0 to tableStatements->Array.length - 1 {
@@ -251,6 +285,6 @@ let ensureSchema = async (pool: PgDriver.pool): unit => {
 // Mirrors the reventless-local contract that reset wipes data, not structure.
 let truncateAll = async (pool: PgDriver.pool): unit => {
   await pool->PgDriver.exec(
-    "TRUNCATE event_log, snapshot, dcb_event, dcb_scope, dcb_subscription RESTART IDENTITY",
+    "TRUNCATE event_log, snapshot, dcb_event, dcb_scope, dcb_subscription, event_log_subscription RESTART IDENTITY",
   )
 }

package/lib/bs/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/lib/bs/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)),
   }
 }