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

package/src/EventLogStorage_Postgres.res.mjs

@@ -1,193 +1,14 @@
 // 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";
+import * as EventLogStorage_Postgres_Ops$ReventlessPostgres from "./EventLogStorage_Postgres_Ops.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
-  };
+function makeStorage(pool, name, opts, onAppendedOpt) {
+  let onAppended = onAppendedOpt !== undefined ? onAppendedOpt : EventLogStorage_Postgres_Ops$ReventlessPostgres.noTracking;
+  let match = EventLogStorage_Postgres_Ops$ReventlessPostgres.makeOps(pool, name, opts, onAppended);
+  let ops = match[1];
   return [
-    name,
+    match[0],
     ops,
     {
       resources: [],
@@ -196,12 +17,25 @@ function makeStorage(pool, name, param, onAppendedOpt) {
   ];
 }
 
+let noTracking = EventLogStorage_Postgres_Ops$ReventlessPostgres.noTracking;
+
+let decodePayload = EventLogStorage_Postgres_Ops$ReventlessPostgres.decodePayload;
+
+let coerceInt = EventLogStorage_Postgres_Ops$ReventlessPostgres.coerceInt;
+
+let countAll = EventLogStorage_Postgres_Ops$ReventlessPostgres.countAll;
+
+let isUniqueViolation = EventLogStorage_Postgres_Ops$ReventlessPostgres.isUniqueViolation;
+
+let makeOps = EventLogStorage_Postgres_Ops$ReventlessPostgres.makeOps;
+
 export {
   noTracking,
   decodePayload,
   coerceInt,
   countAll,
   isUniqueViolation,
+  makeOps,
   makeStorage,
 }
-/* Stream Not a pure module */
+/* @pulumi/pulumi Not a pure module */

package/src/EventLogStorage_Postgres_Ops.res

@@ -0,0 +1,180 @@
+// Runtime-pure classic (OCC) event-log operations for the Postgres backend.
+//
+// This module holds everything the DEPLOYED Lambda runtime needs and imports NO
+// `@pulumi/pulumi` — deploy-time-only. The deployed aggregate entry point pulls
+// these ops in unconditionally at cold start, so any deploy-time dependency here
+// leaks into the Lambda import graph and fails resolution (`@pulumi/pulumi` exists
+// in no Lambda — not the layer, not `/var/runtime`). The thin
+// `EventLogStorage_Postgres` wrapper adds the deploy-time `Pulumi.Output`-shaped
+// adapter on top for local/deploy consumers; the runtime imports `makeOps` here.
+// See docs/plans/deployed-lambda-esm-self-containment.md (Rung-3 finding).
+
+open ReventlessCore
+
+// Injected by reventless-local to feed the projection-checkpoint low-watermark
+// (ProjectionPending, aggregate axis). Standalone/deploy use passes nothing.
+type onAppended = array<(string, int)> => unit
+let noTracking: onAppended = _ => ()
+
+let decodePayload = (row: dict<JSON.t>): JSON.t =>
+  row->Dict.get("payload")->Option.getOr(JSON.Encode.null)
+
+let coerceInt = (v: JSON.t): int =>
+  switch v {
+  | JSON.Number(n) => Float.toInt(n)
+  | JSON.String(s) => s->Int.fromString->Option.getOr(0)
+  | _ => 0
+  }
+
+// Total events across all aggregates. Seeds the event-tap counter at startup so
+// timeline numbering continues across restarts.
+let countAll = async (pool: PgDriver.pool): int =>
+  switch await pool->PgDriver.queryOne("SELECT COUNT(*)::bigint AS c FROM event_log", []) {
+  | Some(row) => row->Dict.get("c")->Option.map(coerceInt)->Option.getOr(0)
+  | None => 0
+  }
+
+let isUniqueViolation = (exn: exn): bool => {
+  let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("")
+  // pg surfaces the SQLSTATE on `.code`; the message also carries the constraint.
+  msg->String.includes("duplicate key") ||
+  msg->String.includes("unique") ||
+  msg->String.includes("23505")
+}
+
+// Builds the classic runtime op set bound to `pool`. Returns `(name, ops)`; the
+// deploy-time `EventLog_Adapter` wrapper lives in `EventLogStorage_Postgres`.
+let makeOps = (
+  ~pool: PgDriver.pool,
+  ~name: string,
+  ~opts as _,
+  ~onAppended=noTracking,
+): (string, EventLog_Adapter.operations) => {
+  let appendTracked = async (~track, seqNr: int, id: string, jsons: array<JSON.t>) => {
+    // Empty append is a legitimate no-op (at-least-once retries, idempotent
+    // commands), NOT a conflict — return before the guarded insert whose 0-row
+    // result would otherwise be read as a conflict.
+    if jsons->Array.length == 0 {
+      Ok()
+    } else {
+      try {
+        let rows = await pool->PgDriver.query(
+          "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload, msg_id)
+           SELECT $1, $2, $3::bigint + (ord - 1), value, value->>'msgId'
+             FROM jsonb_array_elements($4::jsonb) WITH ORDINALITY AS t(value, ord)
+            WHERE $3::bigint = (SELECT COALESCE(MAX(seq_nr), -1) + 1
+                                  FROM event_log
+                                 WHERE log_name = $1 AND aggregate_id = $2)
+           RETURNING global_seq, msg_id",
+          [
+            JSON.Encode.string(name),
+            JSON.Encode.string(id),
+            JSON.Encode.int(seqNr),
+            JSON.Encode.string(JSON.stringify(JSON.Array(jsons))),
+          ],
+        )
+        if rows->Array.length == 0 {
+          // WHERE guard rejected the seq — a genuine OCC conflict (gap or stale).
+          Error(EventLog.Conflict)
+        } else {
+          if track {
+            onAppended(
+              rows->Array.filterMap(row =>
+                switch (row->Dict.get("msg_id"), row->Dict.get("global_seq")) {
+                | (Some(JSON.String(msgId)), Some(gseq)) => Some((msgId, coerceInt(gseq)))
+                | _ => None
+                }
+              ),
+            )
+          }
+          Ok()
+        }
+      } catch {
+      | exn =>
+        isUniqueViolation(exn)
+          ? Error(EventLog.Conflict)
+          : Error(
+              EventLog.StorageFailure(
+                exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("storage error"),
+              ),
+            )
+      }
+    }
+  }
+
+  let append: EventLog.append<string, JSON.t> = (seqNr, id, jsons) =>
+    appendTracked(~track=true, seqNr, id, jsons)
+
+  let replayArray = async (id: string, ~fromSeq=0): array<JSON.t> =>
+    (await pool->PgDriver.query(
+      "SELECT payload FROM event_log
+        WHERE log_name = $1 AND aggregate_id = $2 AND seq_nr >= $3::bigint
+        ORDER BY seq_nr ASC",
+      [JSON.Encode.string(name), JSON.Encode.string(id), JSON.Encode.int(fromSeq)],
+    ))->Array.map(decodePayload)
+
+  let replay: EventLog.replay<string, JSON.t> = id => replayArray(id)
+
+  let replayStream = (id, ~fromSeq=?) =>
+    Effect.promise(() => replayArray(id, ~fromSeq?))
+    ->Stream.fromEffect
+    ->Stream.flatMap(arr => Stream.fromIterable(arr))
+
+  let latestSnapshot: EventLog.latestSnapshot<string> = async id =>
+    switch await pool->PgDriver.queryOne(
+      "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name = $1 AND aggregate_id = $2",
+      [JSON.Encode.string(name), JSON.Encode.string(id)],
+    ) {
+    | Some(row) =>
+      switch (row->Dict.get("seq_nr"), row->Dict.get("state"), row->Dict.get("schema_hash")) {
+      | (Some(seq), Some(state), Some(JSON.String(schemaHash))) =>
+        Ok(Some({EventLog.seqNr: coerceInt(seq), state, schemaHash}))
+      | _ => Error("snapshot row has unexpected shape")
+      }
+    | None => Ok(None)
+    }
+
+  let writeSnapshot: EventLog.writeSnapshot<string> = async (id, snap) =>
+    try {
+      let _ = await pool->PgDriver.query(
+        "INSERT INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash)
+         VALUES ($1, $2, $3::bigint, $4::jsonb, $5)
+         ON CONFLICT (log_name, aggregate_id)
+         DO UPDATE SET seq_nr = EXCLUDED.seq_nr, state = EXCLUDED.state, schema_hash = EXCLUDED.schema_hash",
+        [
+          JSON.Encode.string(name),
+          JSON.Encode.string(id),
+          JSON.Encode.int(snap.EventLog.seqNr),
+          JSON.Encode.string(JSON.stringify(snap.state)),
+          JSON.Encode.string(snap.schemaHash),
+        ],
+      )
+      Ok()
+    } catch {
+    | exn =>
+      Error(exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("snapshot write error"))
+    }
+
+  let appendStream: EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) =>
+    stream
+    ->Stream.runCollect
+    ->Effect.flatMap(jsons =>
+      Effect.promise(() => appendTracked(~track=false, startingSeqNr, id, jsons))->Effect.flatMap(result =>
+        switch result {
+        | Ok() => Effect.succeed()
+        | Error(EventLog.Conflict) => Effect.fail("conflict")
+        | Error(StorageFailure(msg)) => Effect.fail(msg)
+        }
+      )
+    )
+
+  let ops: EventLog_Adapter.operations = {
+    append,
+    replay,
+    replayStream,
+    appendStream,
+    latestSnapshot,
+    writeSnapshot,
+  }
+  (name, ops)
+}

package/src/EventLogStorage_Postgres_Ops.res.mjs

@@ -0,0 +1,202 @@
+// 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 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 makeOps(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
+  ];
+}
+
+export {
+  noTracking,
+  decodePayload,
+  coerceInt,
+  countAll,
+  isUniqueViolation,
+  makeOps,
+}
+/* Stream Not a pure module */

package/src/PgChangeFeed.res

@@ -18,7 +18,12 @@
 open ReventlessCore
 open Reventless
 
-module Dcb = DcbEventLogStorage_Postgres
+// Runtime-pure ops module (no `@pulumi/pulumi`) — this feed is drained by the
+// deployed change-feed relay Lambda, so its cold-start graph must stay
+// Pulumi-free. `_Ops` carries every helper used below (mkBuilder,
+// buildReadWhere, decodeCursor, selectColumns, rowToEvent); the deploy-time
+// DcbEventLogStorage_Postgres only `include`s it and adds the Pulumi adapter.
+module Dcb = DcbEventLogStorage_Postgres_Ops
 
 // 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

package/src/PgChangeFeed.res.mjs

@@ -2,15 +2,15 @@
 
 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";
+import * as DcbEventLogStorage_Postgres_Ops$ReventlessPostgres from "./DcbEventLogStorage_Postgres_Ops.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 b = DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.mkBuilder();
+  let where = DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.buildReadWhere(b, logName, [], Stdlib_Option.flatMap(after, DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.decodeCursor), true);
+  let sql = `SELECT ` + DcbEventLogStorage_Postgres_Ops$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 events = rows.map(DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.rowToEvent);
   let last = events[events.length - 1 | 0];
   let cursor = last !== undefined ? last.position : undefined;
   return {
@@ -31,7 +31,7 @@ async function loadCheckpoint(pool, subscriber) {
 }
 
 async function saveCheckpoint(pool, subscriber, cursor) {
-  let match = DcbEventLogStorage_Postgres$ReventlessPostgres.decodeCursor(cursor);
+  let match = DcbEventLogStorage_Postgres_Ops$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,