@reventlessdev/reventless-postgres 3.0.0-alpha.1

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

@@ -0,0 +1,207 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+
+function noTracking(param) {
+  
+}
+
+function decodePayload(row) {
+  return Stdlib_Option.getOr(row["payload"], null);
+}
+
+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;
+  }
+}
+
+async function countAll(pool) {
+  let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT COUNT(*)::bigint AS c FROM event_log", []);
+  if (row !== undefined) {
+    return Stdlib_Option.getOr(Stdlib_Option.map(row["c"], coerceInt), 0);
+  } else {
+    return 0;
+  }
+}
+
+function isUniqueViolation(exn) {
+  let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "");
+  if (msg.includes("duplicate key") || msg.includes("unique")) {
+    return true;
+  } else {
+    return msg.includes("23505");
+  }
+}
+
+function makeStorage(pool, name, param, onAppendedOpt) {
+  let onAppended = onAppendedOpt !== undefined ? onAppendedOpt : noTracking;
+  let appendTracked = async (track, seqNr, id, jsons) => {
+    if (jsons.length === 0) {
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+    try {
+      let rows = await PgDriver$ReventlessPostgres.query(pool, "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload, msg_id)\n           SELECT $1, $2, $3::bigint + (ord - 1), value, value->>'msgId'\n             FROM jsonb_array_elements($4::jsonb) WITH ORDINALITY AS t(value, ord)\n            WHERE $3::bigint = (SELECT COALESCE(MAX(seq_nr), -1) + 1\n                                  FROM event_log\n                                 WHERE log_name = $1 AND aggregate_id = $2)\n           RETURNING global_seq, msg_id", [
+        name,
+        id,
+        seqNr,
+        JSON.stringify(jsons)
+      ]);
+      if (rows.length === 0) {
+        return {
+          TAG: "Error",
+          _0: "Conflict"
+        };
+      } else {
+        if (track) {
+          onAppended(Stdlib_Array.filterMap(rows, row => {
+            let match = row["msg_id"];
+            let match$1 = row["global_seq"];
+            if (typeof match === "string" && match$1 !== undefined) {
+              return [
+                match,
+                coerceInt(match$1)
+              ];
+            }
+          }));
+        }
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (isUniqueViolation(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 append = (seqNr, id, jsons) => appendTracked(true, seqNr, id, jsons);
+  let replayArray = async (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    return (await PgDriver$ReventlessPostgres.query(pool, "SELECT payload FROM event_log\n        WHERE log_name = $1 AND aggregate_id = $2 AND seq_nr >= $3::bigint\n        ORDER BY seq_nr ASC", [
+      name,
+      id,
+      fromSeq
+    ])).map(decodePayload);
+  };
+  let replay = id => replayArray(id, undefined);
+  let replayStream = (id, fromSeq) => Stream$1.flatMap(Stream$1.fromEffect(Effect.promise(() => replayArray(id, fromSeq))), arr => Stream$1.fromIterable(arr));
+  let latestSnapshot = async id => {
+    let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name = $1 AND aggregate_id = $2", [
+      name,
+      id
+    ]);
+    if (row === undefined) {
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+    let match = row["seq_nr"];
+    let match$1 = row["state"];
+    let match$2 = row["schema_hash"];
+    if (match !== undefined && match$1 !== undefined && typeof match$2 === "string") {
+      return {
+        TAG: "Ok",
+        _0: {
+          seqNr: coerceInt(match),
+          state: match$1,
+          schemaHash: match$2
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "snapshot row has unexpected shape"
+      };
+    }
+  };
+  let writeSnapshot = async (id, snap) => {
+    try {
+      await PgDriver$ReventlessPostgres.query(pool, "INSERT INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash)\n         VALUES ($1, $2, $3::bigint, $4::jsonb, $5)\n         ON CONFLICT (log_name, aggregate_id)\n         DO UPDATE SET seq_nr = EXCLUDED.seq_nr, state = EXCLUDED.state, schema_hash = EXCLUDED.schema_hash", [
+        name,
+        id,
+        snap.seqNr,
+        JSON.stringify(snap.state),
+        snap.schemaHash
+      ]);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "snapshot write error")
+      };
+    }
+  };
+  let appendStream = (startingSeqNr, id, stream) => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.flatMap(Effect.promise(() => appendTracked(false, startingSeqNr, id, jsons)), result => {
+    if (result.TAG === "Ok") {
+      return Effect.succeed();
+    }
+    let msg = result._0;
+    if (typeof msg !== "object") {
+      return Effect.fail("conflict");
+    } else {
+      return Effect.fail(msg._0);
+    }
+  }));
+  let ops = {
+    append: append,
+    replay: replay,
+    replayStream: replayStream,
+    appendStream: appendStream,
+    latestSnapshot: latestSnapshot,
+    writeSnapshot: writeSnapshot
+  };
+  return [
+    name,
+    ops,
+    {
+      resources: [],
+      operations: Pulumi.output(ops)
+    }
+  ];
+}
+
+export {
+  noTracking,
+  decodePayload,
+  coerceInt,
+  countAll,
+  isUniqueViolation,
+  makeStorage,
+}
+/* Stream Not a pure module */

package/lib/bs/src/PgChangeFeed.res

@@ -0,0 +1,145 @@
+// DCB change feed — checkpointed polling with LISTEN/NOTIFY wakeup.
+//
+// This is the one component with no in-repo template (DynamoDB Streams has no
+// drop-in equivalent). It is NOT logical decoding: events are already durably
+// queryable in-table, so the feed is a fenced read over dcb_event plus a
+// `dcb_subscription` checkpoint. `dcb_append` issues `pg_notify('dcb_<log>')`,
+// which turns polling into near-real-time wakeup; a low-frequency fallback tick
+// covers missed notifications (payload overflow, listener reconnect).
+//
+// The feed-consumer API below is a DOCUMENTED PUBLIC SURFACE of the package —
+// external relays and platform packages bridging the feed onto a bus/topic are
+// first-class consumers. Cursor semantics: the opaque `<xid8>:<position>` string
+// (see DcbEventLogStorage_Postgres), which decodes to the (transaction_id,
+// position) pair. Reads apply the xmin barrier, so a returned cursor is stable
+// forever — an event committed late (lower position, later commit) is never
+// skipped by a checkpointing reader.
+
+open ReventlessCore
+open Reventless
+
+module Dcb = DcbEventLogStorage_Postgres
+
+// One page of the feed. `events` are in (transaction_id, position) 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<DcbEventLog_Adapter.rawSequencedEvent>,
+  cursor: option<DcbTag.sequencePosition>,
+}
+
+// Read up to `limit` events after `after` (the xmin-fenced feed query — no tag
+// filter, whole log). Returns the events and the cursor of the last one.
+let readBatch = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~after: option<DcbTag.sequencePosition>=?,
+  ~limit: int=500,
+): batch => {
+  let b = Dcb.mkBuilder()
+  let where = Dcb.buildReadWhere(
+    b,
+    ~name=logName,
+    ~query=[],
+    ~after=after->Option.flatMap(Dcb.decodeCursor),
+    ~applyFence=true,
+  )
+  let sql = `SELECT ${Dcb.selectColumns} FROM dcb_event WHERE ${where} ORDER BY transaction_id ASC, position ASC LIMIT ${Int.toString(limit)}`
+  let rows = await pool->PgDriver.query(sql, b.params)
+  let events = rows->Array.map(Dcb.rowToEvent)
+  let cursor = switch events->Array.get(events->Array.length - 1) {
+  | Some(last) => Some(last.position)
+  | None => None
+  }
+  {events, cursor}
+}
+
+// --- Checkpoint contract (dcb_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<DcbTag.sequencePosition> =>
+  switch await pool->PgDriver.queryOne(
+    "SELECT lpad(last_tx::text, 20, '0') || ':' || lpad(last_position::text, 20, '0') AS cursor
+       FROM dcb_subscription WHERE subscriber = $1 AND last_position > 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: DcbTag.sequencePosition,
+): unit =>
+  switch Dcb.decodeCursor(cursor) {
+  | Some((tx, pos)) =>
+    let _ = await pool->PgDriver.query(
+      "INSERT INTO dcb_subscription(subscriber, last_tx, last_position)
+       VALUES ($1, $2::xid8, $3::bigint)
+       ON CONFLICT (subscriber)
+       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_position = EXCLUDED.last_position",
+      [JSON.Encode.string(subscriber), JSON.Encode.string(tx), JSON.Encode.string(pos)],
+    )
+  | None => ()
+  }
+
+// --- Wakeup ---
+
+// LISTEN on `dcb_<logName>`; `onWake` fires on every notification. Returns the
+// dedicated client (caller owns it — release via PgDriver.unlisten). Pair with a
+// low-frequency fallback tick in the consumer loop so a missed NOTIFY only adds
+// latency, never a permanent stall.
+let listen = (pool: PgDriver.pool, ~logName: string, ~onWake: unit => unit): promise<PgDriver.client> =>
+  pool->PgDriver.listen(~channel="dcb_" ++ logName, ~onNotify=_ => onWake())
+
+let unlisten = (client: PgDriver.client, ~logName: string): promise<unit> =>
+  client->PgDriver.unlisten(~channel="dcb_" ++ 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. This is the in-repo reference consumer;
+// a bus/topic relay would call the same primitives with its own `handle`.
+let drain = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~subscriber: string,
+  ~limit: int=500,
+  ~handle: array<DcbEventLog_Adapter.rawSequencedEvent> => 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/PgChangeFeed.res.mjs

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+
+async function readBatch(pool, logName, after, limitOpt) {
+  let limit = limitOpt !== undefined ? limitOpt : 500;
+  let b = DcbEventLogStorage_Postgres$ReventlessPostgres.mkBuilder();
+  let where = DcbEventLogStorage_Postgres$ReventlessPostgres.buildReadWhere(b, logName, [], Stdlib_Option.flatMap(after, DcbEventLogStorage_Postgres$ReventlessPostgres.decodeCursor), true);
+  let sql = `SELECT ` + DcbEventLogStorage_Postgres$ReventlessPostgres.selectColumns + ` FROM dcb_event WHERE ` + where + ` ORDER BY transaction_id ASC, position ASC LIMIT ` + limit.toString();
+  let rows = await PgDriver$ReventlessPostgres.query(pool, sql, b.params);
+  let events = rows.map(DcbEventLogStorage_Postgres$ReventlessPostgres.rowToEvent);
+  let last = events[events.length - 1 | 0];
+  let cursor = last !== undefined ? last.position : 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_position::text, 20, '0') AS cursor\n       FROM dcb_subscription WHERE subscriber = $1 AND last_position > 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 dcb_subscription(subscriber, last_tx, last_position)\n       VALUES ($1, $2::xid8, $3::bigint)\n       ON CONFLICT (subscriber)\n       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_position = EXCLUDED.last_position", [
+      subscriber,
+      match[0],
+      match[1]
+    ]);
+    return;
+  }
+}
+
+function listen(pool, logName, onWake) {
+  return PgDriver$ReventlessPostgres.listen(pool, "dcb_" + logName, param => onWake());
+}
+
+function unlisten(client, logName) {
+  return PgDriver$ReventlessPostgres.unlisten(client, "dcb_" + 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,
+  readBatch,
+  loadCheckpoint,
+  saveCheckpoint,
+  listen,
+  unlisten,
+  drain,
+}
+/* PgDriver-ReventlessPostgres Not a pure module */

package/lib/bs/src/PgDriver.res

@@ -0,0 +1,111 @@
+// node-postgres (`pg`) binding. See PgDriver.resi for the contract.
+
+type pool
+type client
+
+// TLS options passed straight to node's tls. RDS Postgres (PG15+) defaults to
+// `rds.force_ssl=1`, so a managed-Postgres pool must enable SSL. Verifying the
+// RDS CA needs the bundle wired in (`ca`); `rejectUnauthorized: false` encrypts
+// without CA verification — acceptable for v1, tighten later.
+type sslConfig = {rejectUnauthorized: bool}
+
+// pg calls the password provider (with no args) each time it opens a physical
+// connection, so a rotated secret is picked up on the next new connection
+// without rebuilding the pool.
+type passwordProvider = unit => promise<string>
+
+type poolConfig = {
+  // Either supply a full `connectionString`, or the discrete fields below (used
+  // by the AWS adapter, where the password comes from a Secrets Manager
+  // provider and cannot be baked into a static string).
+  connectionString?: string,
+  host?: string,
+  port?: int,
+  database?: string,
+  user?: string,
+  password?: passwordProvider,
+  ssl?: sslConfig,
+  max?: int,
+}
+
+// pg is CJS (`module.exports = { Pool, Client, ... }`); Node's ESM interop
+// exposes `Pool` as a named import.
+@module("pg") @new external makePool: poolConfig => pool = "Pool"
+
+@send external _end: pool => promise<unit> = "end"
+let endPool = pool => _end(pool)
+
+// pg's `query` resolves to a result object; `.rows` is the payload we want.
+type queryResult = {rows: array<dict<JSON.t>>}
+
+@send external _query: (pool, string, array<JSON.t>) => promise<queryResult> = "query"
+@send external _queryText: (pool, string) => promise<queryResult> = "query"
+@send external _connect: pool => promise<client> = "connect"
+@send external _release: client => unit = "release"
+@send external _clientQuery: (client, string, array<JSON.t>) => promise<queryResult> = "query"
+@send external _clientQueryText: (client, string) => promise<queryResult> = "query"
+
+let query = async (pool, sql, params) => (await _query(pool, sql, params)).rows
+
+let queryOne = async (pool, sql, params) =>
+  (await _query(pool, sql, params)).rows->Array.get(0)
+
+let exec = async (pool, sql) => {
+  let _ = await _queryText(pool, sql)
+}
+
+let queryOn = async (client, sql, params) => (await _clientQuery(client, sql, params)).rows
+let execOn = async (client, sql) => {
+  let _ = await _clientQueryText(client, sql)
+}
+
+let transaction = async (pool, fn) => {
+  let client = await _connect(pool)
+  try {
+    let _ = await _clientQueryText(client, "BEGIN")
+    let result = await fn(client)
+    let _ = await _clientQueryText(client, "COMMIT")
+    _release(client)
+    result
+  } catch {
+  | exn =>
+    // Roll back and release, but never let a failing ROLLBACK mask the original
+    // error (the original is the diagnostic one). Always return the connection.
+    try {
+      let _ = await _clientQueryText(client, "ROLLBACK")
+    } catch {
+    | _ => ()
+    }
+    _release(client)
+    throw(exn)
+  }
+}
+
+// LISTEN/NOTIFY on a dedicated connection. `notification` events carry
+// `{channel, payload}`; we forward the payload string.
+type notification = {payload: Nullable.t<string>}
+@send
+external _onNotification: (client, @as("notification") _, notification => unit) => unit = "on"
+
+let listen = async (pool, ~channel, ~onNotify) => {
+  let client = await _connect(pool)
+  client->_onNotification(n =>
+    switch n.payload->Nullable.toOption {
+    | Some(p) => onNotify(p)
+    | None => ()
+    }
+  )
+  // Channel identifiers can't be parameterised; the caller supplies a
+  // framework-controlled name (`dcb_<log>`), never user input.
+  let _ = await _clientQueryText(client, `LISTEN "${channel}"`)
+  client
+}
+
+let unlisten = async (client, ~channel) => {
+  try {
+    let _ = await _clientQueryText(client, `UNLISTEN "${channel}"`)
+  } catch {
+  | _ => ()
+  }
+  _release(client)
+}

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

@@ -0,0 +1,85 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pg from "pg";
+
+function endPool(pool) {
+  return pool.end();
+}
+
+async function query(pool, sql, params) {
+  return (await pool.query(sql, params)).rows;
+}
+
+async function queryOne(pool, sql, params) {
+  return (await pool.query(sql, params)).rows[0];
+}
+
+async function exec(pool, sql) {
+  await pool.query(sql);
+}
+
+async function queryOn(client, sql, params) {
+  return (await client.query(sql, params)).rows;
+}
+
+async function execOn(client, sql) {
+  await client.query(sql);
+}
+
+async function transaction(pool, fn) {
+  let client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+    let result = await fn(client);
+    await client.query("COMMIT");
+    client.release();
+    return result;
+  } catch (exn) {
+    try {
+      await client.query("ROLLBACK");
+    } catch (exn$1) {
+      
+    }
+    client.release();
+    throw exn;
+  }
+}
+
+async function listen(pool, channel, onNotify) {
+  let client = await pool.connect();
+  client.on("notification", n => {
+    let p = n.payload;
+    if (!(p == null)) {
+      return onNotify(p);
+    }
+  });
+  await client.query(`LISTEN "` + channel + `"`);
+  return client;
+}
+
+async function unlisten(client, channel) {
+  try {
+    await client.query(`UNLISTEN "` + channel + `"`);
+  } catch (exn) {
+    
+  }
+  client.release();
+}
+
+function makePool(prim) {
+  return new Pg.Pool(prim);
+}
+
+export {
+  makePool,
+  endPool,
+  query,
+  queryOne,
+  exec,
+  transaction,
+  queryOn,
+  execOn,
+  listen,
+  unlisten,
+}
+/* pg Not a pure module */