@reventlessdev/reventless-postgres 3.0.0-alpha.1 → 3.0.0-alpha.100

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

@@ -0,0 +1,380 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+
+function strategyParam(s) {
+  if (s === "AdvisoryLocks") {
+    return "advisory";
+  } else {
+    return "rows";
+  }
+}
+
+function noTracking(param) {
+  
+}
+
+let selectColumns = "\n  lpad(transaction_id::text, 20, '0') || ':' || lpad(position::text, 20, '0') AS cursor,\n  event_type,\n  tags,\n  data,\n  meta,\n  to_char(recorded_at AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"') AS recorded_at\n";
+
+function decodeTag(s) {
+  let i = s.indexOf("=");
+  if (i !== -1) {
+    return {
+      key: s.slice(0, i),
+      value: s.slice(i + 1 | 0, s.length)
+    };
+  } else {
+    return {
+      key: s,
+      value: ""
+    };
+  }
+}
+
+function decodeTags(v) {
+  if (v !== undefined) {
+    if (Array.isArray(v)) {
+      return Stdlib_Array.filterMap(v, x => {
+        if (typeof x === "string") {
+          return decodeTag(x);
+        }
+      });
+    } else {
+      return [];
+    }
+  } else {
+    return [];
+  }
+}
+
+function rowToEvent(row) {
+  let str = key => {
+    let match = row[key];
+    if (typeof match === "string") {
+      return match;
+    } else {
+      return "";
+    }
+  };
+  let metaJson = row["meta"];
+  let meta = metaJson !== undefined ? S.parseJsonOrThrow(metaJson, Message$Reventless.metaSchema) : Stdlib_JsError.throwWithMessage("missing meta column in dcb_event row");
+  return {
+    position: str("cursor"),
+    eventType: str("event_type"),
+    data: Stdlib_Option.getOr(row["data"], null),
+    tags: decodeTags(row["tags"]),
+    meta: meta,
+    recordedAt: str("recorded_at")
+  };
+}
+
+function mkBuilder() {
+  return {
+    params: []
+  };
+}
+
+function param(b, v) {
+  b.params.push(v);
+  return "$" + b.params.length.toString();
+}
+
+function buildReadWhere(b, name, query, after, applyFence) {
+  let parts = [`log_name = ` + param(b, name)];
+  if (applyFence) {
+    parts.push("transaction_id < pg_snapshot_xmin(pg_current_snapshot())");
+  }
+  if (after !== undefined) {
+    let txP = param(b, after[0]);
+    let posP = param(b, after[1]);
+    parts.push(`(transaction_id > ` + txP + `::xid8 OR (transaction_id = ` + txP + `::xid8 AND position > ` + posP + `::bigint))`);
+  }
+  if (query.length !== 0) {
+    let clauseSqls = query.map(clause => {
+      let clauseParts = [];
+      let types = clause.eventTypes;
+      if (types !== undefined && types.length !== 0) {
+        let ph = types.map(t => param(b, t)).join(",");
+        clauseParts.push(`event_type IN (` + ph + `)`);
+      }
+      let tags = clause.tags;
+      if (tags !== undefined && tags.length !== 0) {
+        let arr = tags.map(t => param(b, t.key + "=" + t.value)).join(",");
+        clauseParts.push(`tags @> ARRAY[` + arr + `]::text[]`);
+      }
+      if (clauseParts.length === 0) {
+        return "TRUE";
+      } else {
+        return "(" + clauseParts.join(" AND ") + ")";
+      }
+    });
+    parts.push("(" + clauseSqls.join(" OR ") + ")");
+  }
+  return parts.join(" AND ");
+}
+
+function stripZeros(s) {
+  let t = s.replace(/^0+/, "");
+  if (t === "") {
+    return "0";
+  } else {
+    return t;
+  }
+}
+
+function decodeCursor(pos) {
+  let match = pos.split(":");
+  if (match.length !== 2) {
+    return;
+  }
+  let tx = match[0];
+  let p = match[1];
+  return [
+    stripZeros(tx),
+    stripZeros(p)
+  ];
+}
+
+function isConflict(exn) {
+  let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "");
+  if (msg.includes("dcb_conflict") || msg.includes("duplicate key")) {
+    return true;
+  } else {
+    return msg.includes("23505");
+  }
+}
+
+async function countAll(pool) {
+  let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT COUNT(*)::bigint AS c FROM dcb_event", []);
+  if (row === undefined) {
+    return 0;
+  }
+  let match = row["c"];
+  if (match === undefined) {
+    return 0;
+  }
+  switch (typeof match) {
+    case "string" :
+      return Stdlib_Option.getOr(Stdlib_Int.fromString(match, undefined), 0);
+    case "number" :
+      return match | 0;
+    default:
+      return 0;
+  }
+}
+
+function makeOps(pool, name, param, param$1, param$2, param$3, lockStrategyOpt, onAppendedOpt) {
+  let lockStrategy = lockStrategyOpt !== undefined ? lockStrategyOpt : "AdvisoryLocks";
+  let onAppended = onAppendedOpt !== undefined ? onAppendedOpt : noTracking;
+  let currentHead = async () => {
+    let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT lpad(transaction_id::text, 20, '0') || ':' || lpad(position::text, 20, '0') AS head\n         FROM dcb_event\n        WHERE log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\n        ORDER BY transaction_id DESC, position DESC\n        LIMIT 1", [name]);
+    if (row === undefined) {
+      return;
+    }
+    let match = row["head"];
+    if (typeof match === "string") {
+      return match;
+    }
+  };
+  let runQuery = async (query, after) => {
+    let b = {
+      params: []
+    };
+    let where = buildReadWhere(b, name, query, after, true);
+    let sql = `SELECT ` + selectColumns + ` FROM dcb_event WHERE ` + where + ` ORDER BY transaction_id ASC, position ASC`;
+    return (await PgDriver$ReventlessPostgres.query(pool, sql, b.params)).map(rowToEvent);
+  };
+  let read = async (query, after) => {
+    let afterCols = Stdlib_Option.flatMap(after, decodeCursor);
+    let events = await runQuery(query, afterCols);
+    let head = await currentHead();
+    if (head !== undefined) {
+      return {
+        events: events,
+        headPosition: head
+      };
+    } else {
+      return {
+        events: events
+      };
+    }
+  };
+  let append = async (newEvents, condition) => {
+    let eventsJson = newEvents.map(ev => (Object.fromEntries([
+      [
+        "event_type",
+        ev.eventType
+      ],
+      [
+        "tags",
+        ev.tags.map(t => t.key + "=" + t.value)
+      ],
+      [
+        "data",
+        ev.data
+      ],
+      [
+        "meta",
+        S.reverseConvertToJsonOrThrow(ev.meta, Message$Reventless.metaSchema)
+      ]
+    ])));
+    let conditionParam;
+    if (condition !== undefined) {
+      let queryJson = condition.query.map(clause => {
+        let types = clause.eventTypes;
+        let tags = clause.tags;
+        return Object.fromEntries([
+          [
+            "eventTypes",
+            types !== undefined ? types.map(prim => prim) : null
+          ],
+          [
+            "tags",
+            tags !== undefined ? tags.map(t => t.key + "=" + t.value) : null
+          ]
+        ]);
+      });
+      let fields = [[
+          "query",
+          queryJson
+        ]];
+      let a = condition.after;
+      if (a !== undefined) {
+        fields.push([
+          "after",
+          a
+        ]);
+      }
+      conditionParam = JSON.stringify(Object.fromEntries(fields));
+    } else {
+      conditionParam = null;
+    }
+    try {
+      let rows = await PgDriver$ReventlessPostgres.query(pool, "SELECT dcb_append($1, $2::jsonb, $3::jsonb, $4) AS pos", [
+        name,
+        JSON.stringify(eventsJson),
+        conditionParam,
+        strategyParam(lockStrategy)
+      ]);
+      let match = Stdlib_Option.flatMap(rows[0], r => r["pos"]);
+      if (match === undefined) {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: "dcb_append returned no position"
+          }
+        };
+      }
+      if (typeof match !== "string") {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: "dcb_append returned no position"
+          }
+        };
+      }
+      onAppended(Stdlib_Array.filterMap(newEvents, ev => {
+        let match$1 = decodeCursor(match);
+        if (match$1 !== undefined) {
+          return Stdlib_Option.map(Stdlib_Int.fromString(match$1[1], undefined), p => [
+            ev.meta.msgId,
+            p
+          ]);
+        }
+      }));
+      return {
+        TAG: "Ok",
+        _0: match
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (isConflict(exn)) {
+        return {
+          TAG: "Error",
+          _0: "Conflict"
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "storage error")
+          }
+        };
+      }
+    }
+  };
+  let readStream = (query, after, param) => Stream.paginateEffect(Stdlib_Option.flatMap(after, decodeCursor), cursor => Effect.map(Effect.promise(() => {
+    let b = {
+      params: []
+    };
+    let where = buildReadWhere(b, name, query, cursor, 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 ` + (500).toString();
+    return PgDriver$ReventlessPostgres.query(pool, sql, b.params);
+  }), rows => {
+    let events = rows.map(rowToEvent);
+    let next;
+    if (rows.length < 500) {
+      next = undefined;
+    } else {
+      let lastRow = rows[rows.length - 1 | 0];
+      if (lastRow !== undefined) {
+        let match = lastRow["tx_raw"];
+        let match$1 = lastRow["pos_raw"];
+        next = typeof match === "string" && typeof match$1 === "string" ? Primitive_option.some([
+            match,
+            match$1
+          ]) : undefined;
+      } else {
+        next = undefined;
+      }
+    }
+    return [
+      events,
+      next
+    ];
+  }));
+  let ops = {
+    read: read,
+    append: append,
+    readStream: readStream
+  };
+  return [
+    name,
+    ops
+  ];
+}
+
+let pageSize = 500;
+
+export {
+  strategyParam,
+  noTracking,
+  selectColumns,
+  decodeTag,
+  decodeTags,
+  rowToEvent,
+  mkBuilder,
+  param,
+  buildReadWhere,
+  stripZeros,
+  decodeCursor,
+  pageSize,
+  isConflict,
+  countAll,
+  makeOps,
+}
+/* S Not a pure module */

package/lib/bs/src/EventLogChangeFeed.res

@@ -0,0 +1,187 @@
+// 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. Point at the runtime-pure `_Ops` module (no `@pulumi/pulumi`): this
+// feed is drained by the deployed change-feed relay Lambda, whose cold-start
+// graph must stay Pulumi-free.
+module Dcb = DcbEventLogStorage_Postgres_Ops
+
+// 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_Ops$ReventlessPostgres from "./DcbEventLogStorage_Postgres_Ops.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_Ops$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_Ops$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 */