@reventlessdev/reventless-aws 3.0.0-alpha.174 → 3.0.0-alpha.175

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.175 (2026-07-05)
+
+**Note:** Version bump only for package @reventlessdev/reventless-aws
+
+
+
+
+
 # 3.0.0-alpha.174 (2026-07-05)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.174",
+  "version": "3.0.0-alpha.175",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -10,15 +10,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.20",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.45",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.13",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.87",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.141",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.142",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.23",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.3",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.65"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.88",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.4",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.66"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/adapter/Postgres/PgChangeFeedRelay_Runtime.res

@@ -38,17 +38,19 @@ let toEventCollectorJson = (
 }
 
 /**
- * Drain a Postgres DCB log from its checkpoint and relay its events to the
- * EventCollector via the injected `sendBatch`. `sendBatch` is injected (rather than
- * hardcoding SQS) so the drain/transform is unit-testable; the relay entry point
- * wires it to the actual `SendMessage`. Returns the number of events processed.
+ * Drain a Postgres DCB log from its checkpoint on the given `pool` and relay its
+ * events to the EventCollector via the injected `sendBatch`. Both `pool` and
+ * `sendBatch` are injected (rather than hardcoding Secrets Manager / SQS) so the
+ * whole drain→transform→send path is integration-testable against a plain local
+ * Postgres (B2.4); the `relay` wrapper below builds the container pool for the
+ * deployed Lambda. Returns the number of events processed.
  *
  * At-least-once by construction: `PgChangeFeed.drain` replays the last page on a
  * crash before checkpoint, and EventCollector projections are idempotent
  * (event-sourced), so re-delivery is safe.
  */
-let relay = async (
-  ~config: PgConnection.connectionConfig,
+let relayWithPool = async (
+  ~pool: ReventlessPostgres.PgDriver.pool,
   ~logName: string,
   ~subscriber: string,
   // ~partitionTagJson: the DCB log's partition tag, sury-encoded into HANDLER_CONFIG
@@ -62,7 +64,6 @@ let relay = async (
     partitionTagJson->Option.map(json =>
       json->S.parseJsonOrThrow(Reventless.DcbTag.derivedPartitionTagSchema)
     )
-  let pool = PgRuntime.poolFor(config)
   await ReventlessPostgres.PgChangeFeed.drain(pool, ~logName, ~subscriber, ~handle=async events => {
     let jsons = events->Array.filterMap(event => toEventCollectorJson(event, ~partitionTag?))
     if jsons->Array.length > 0 {
@@ -70,3 +71,19 @@ let relay = async (
     }
   })
 }
+
+/**
+ * Deployed-Lambda entry: resolve the container-lifetime pool from the injected
+ * `PgConnection.connectionConfig` (via Secrets Manager) and relay. Thin wrapper over
+ * `relayWithPool`.
+ */
+let relay = async (
+  ~config: PgConnection.connectionConfig,
+  ~logName: string,
+  ~subscriber: string,
+  ~partitionTagJson: option<JSON.t>=?,
+  ~sendBatch: array<JSON.t> => promise<unit>,
+): int => {
+  let pool = PgRuntime.poolFor(config)
+  await relayWithPool(~pool, ~logName, ~subscriber, ~partitionTagJson?, ~sendBatch)
+}

package/src/adapter/Postgres/PgChangeFeedRelay_Runtime.res.mjs

@@ -22,9 +22,8 @@ function toEventCollectorJson(event, partitionTag) {
   return Util_DynamoDbStream_Runtime$ReventlessAws.buildJsonEvent$p(item);
 }
 
-async function relay(config, logName, subscriber, partitionTagJson, sendBatch) {
+async function relayWithPool(pool, logName, subscriber, partitionTagJson, sendBatch) {
   let partitionTag = Stdlib_Option.map(partitionTagJson, json => S.parseJsonOrThrow(json, DcbTag$Reventless.derivedPartitionTagSchema));
-  let pool = PgRuntime$ReventlessAws.poolFor(config);
   return await PgChangeFeed$ReventlessPostgres.drain(pool, logName, subscriber, undefined, async events => {
     let jsons = Stdlib_Array.filterMap(events, event => toEventCollectorJson(event, partitionTag));
     if (jsons.length !== 0) {
@@ -33,8 +32,14 @@ async function relay(config, logName, subscriber, partitionTagJson, sendBatch) {
   });
 }
 
+async function relay(config, logName, subscriber, partitionTagJson, sendBatch) {
+  let pool = PgRuntime$ReventlessAws.poolFor(config);
+  return await relayWithPool(pool, logName, subscriber, partitionTagJson, sendBatch);
+}
+
 export {
   toEventCollectorJson,
+  relayWithPool,
   relay,
 }
 /* S Not a pure module */

package/tests/PgChangeFeedRelay_IntegrationTest.res

@@ -0,0 +1,148 @@
+// Live-Postgres integration suite for the change-feed relay (B2.4).
+//
+// Skipped unless PG_URL is set, so the default `pnpm test` stays dependency-free.
+// Run against a real database with e.g.:
+//   PG_URL=postgres://postgres:postgres@localhost:5432/postgres pnpm test
+//
+// Exercises the deployed propagation path end-to-end minus AWS: DCB events are
+// appended to a real `dcb_event` log, then `PgChangeFeedRelay_Runtime.relayWithPool`
+// drains the feed, transforms each event into the EventCollector `{id, meta, event}`
+// body, and hands the batch to an injected `sendBatch` (standing in for the SQS
+// SendMessage the entry point wires). Asserts the emitted bodies, the partition-tag
+// `id` derivation, and the checkpoint (a second drain sees nothing new).
+
+open JestGlobals
+open ReventlessCore
+open Reventless
+
+@val external processEnv: dict<string> = "process.env"
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let jsonObj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+let stored = (eventType, tags, data): DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data,
+  tags,
+  meta: ReventlessCore.Message.generateMeta(~service="relay-it"),
+}
+
+// Collect every JSON body handed to sendBatch across all drain pages.
+let capturingSendBatch = sink => async jsons => sink := sink.contents->Array.concat(jsons)
+
+let idOf = json =>
+  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get("id"))->Option.flatMap(JSON.Decode.string)
+
+switch processEnv->Dict.get("PG_URL") {
+| None =>
+  testSync("Postgres relay integration (skipped — set PG_URL to run)", () =>
+    expect(true)->toBe(true)
+  )
+| Some(url) =>
+  let pool = ReventlessPostgres.PgDriver.makePool({connectionString: url})
+
+  let makeLog = name =>
+    ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(
+      ~pool,
+      ~name,
+      ~indexes=[],
+      ~partitionTag=DcbTag.Simple({key: "orderId"}),
+      ~opts,
+    )
+
+  beforeAllAsync(async () => {
+    await ReventlessPostgres.PgSchema.ensureSchema(pool)
+    await ReventlessPostgres.PgSchema.truncateAll(pool)
+  })
+  afterAll(() => {
+    let _ = pool->ReventlessPostgres.PgDriver.endPool
+  })
+
+  describe("PgChangeFeedRelay end-to-end (append → drain → EventCollector bodies)", () => {
+    testPromise("relays each appended DCB event as an {id, meta, event} body", async () => {
+      let (_n, ops, _s) = makeLog("relay-basic")
+      let mk = i =>
+        stored("OrderPlaced", [{key: "orderId", value: "o-1"}], jsonObj([("i", JSON.Encode.int(i))]))
+      let _ = await ops.append([mk(0), mk(1), mk(2)])
+
+      let sink = ref([])
+      let processed = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-basic",
+        ~subscriber="relay-it",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+
+      expect(processed)->toBe(3)
+      expect(sink.contents->Array.length)->toBe(3)
+
+      // Every body carries the derived id, the event type, and the producing service.
+      let first = sink.contents->Array.getUnsafe(0)
+      expect(idOf(first))->toEqual(Some("orderId:o-1"))
+      let obj = first->JSON.Decode.object->Option.getOrThrow
+      expect(obj->Dict.get("event")->Option.getOrThrow->JSON.stringify->String.includes("OrderPlaced"))->toBe(true)
+      let metaObj = obj->Dict.get("meta")->Option.flatMap(JSON.Decode.object)->Option.getOrThrow
+      expect(metaObj->Dict.get("service"))->toEqual(Some(JSON.Encode.string("relay-it")))
+    })
+
+    testPromise("checkpoints — a second drain from the same subscriber sees nothing new", async () => {
+      let (_n, ops, _s) = makeLog("relay-checkpoint")
+      let mk = i => stored("Fed", [{key: "orderId", value: "f"}], jsonObj([("i", JSON.Encode.int(i))]))
+      let _ = await ops.append([mk(0), mk(1)])
+
+      let sink = ref([])
+      let first = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-checkpoint",
+        ~subscriber="relay-it",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      expect(first)->toBe(2)
+
+      let second = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-checkpoint",
+        ~subscriber="relay-it",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      expect(second)->toBe(0)
+      // No extra bodies were emitted on the second pass.
+      expect(sink.contents->Array.length)->toBe(2)
+    })
+
+    testPromise("partitionTag pins the id to its tag on a multi-tag event", async () => {
+      let (_n, ops, _s) =
+        ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(
+          ~pool,
+          ~name="relay-pt",
+          ~indexes=[],
+          ~partitionTag=DcbTag.Simple({key: "customerId"}),
+          ~opts,
+        )
+      let ev =
+        stored(
+          "OrderPlaced",
+          [{key: "orderId", value: "o-9"}, {key: "customerId", value: "c-9"}],
+          jsonObj([("n", JSON.Encode.int(1))]),
+        )
+      let _ = await ops.append([ev])
+
+      // The relay receives the sury-encoded partition tag exactly as the builder emits it.
+      let partitionTagJson =
+        DcbTag.Simple({key: "customerId"})->S.reverseConvertToJsonOrThrow(
+          Reventless.DcbTag.derivedPartitionTagSchema,
+        )
+
+      let sink = ref([])
+      let _ = await PgChangeFeedRelay_Runtime.relayWithPool(
+        ~pool,
+        ~logName="relay-pt",
+        ~subscriber="relay-it",
+        ~partitionTagJson,
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      // Without the tag the id would be "orderId:o-9" (first tag); the tag pins it.
+      expect(idOf(sink.contents->Array.getUnsafe(0)))->toEqual(Some("customerId:c-9"))
+    })
+  })
+}

package/tests/PgChangeFeedRelay_IntegrationTest.res.mjs

@@ -0,0 +1,154 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgSchema$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
+import * as PgChangeFeedRelay_Runtime$ReventlessAws from "../src/adapter/Postgres/PgChangeFeedRelay_Runtime.res.mjs";
+import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
+
+let opts = {};
+
+function jsonObj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+function stored(eventType, tags, data) {
+  return {
+    eventType: eventType,
+    data: data,
+    tags: tags,
+    meta: Message$ReventlessCore.generateMeta("relay-it", undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+  };
+}
+
+function capturingSendBatch(sink) {
+  return async jsons => {
+    sink.contents = sink.contents.concat(jsons);
+  };
+}
+
+function idOf(json) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o["id"]), Stdlib_JSON.Decode.string);
+}
+
+let url = process.env["PG_URL"];
+
+if (url !== undefined) {
+  let pool = PgDriver$ReventlessPostgres.makePool({
+    connectionString: url
+  });
+  let makeLog = name => DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, [], {
+    TAG: "Simple",
+    _0: {
+      key: "orderId"
+    }
+  }, undefined, opts, undefined, undefined);
+  globalThis.beforeAll(async () => {
+    await PgSchema$ReventlessPostgres.ensureSchema(pool);
+    return await PgSchema$ReventlessPostgres.truncateAll(pool);
+  });
+  globalThis.afterAll(() => {
+    PgDriver$ReventlessPostgres.endPool(pool);
+  });
+  globalThis.describe("PgChangeFeedRelay end-to-end (append → drain → EventCollector bodies)", () => {
+    globalThis.test("relays each appended DCB event as an {id, meta, event} body", async () => {
+      let match = makeLog("relay-basic");
+      let mk = i => stored("OrderPlaced", [{
+          key: "orderId",
+          value: "o-1"
+        }], Object.fromEntries([[
+          "i",
+          i
+        ]]));
+      await match[1].append([
+        mk(0),
+        mk(1),
+        mk(2)
+      ], undefined);
+      let sink = {
+        contents: []
+      };
+      let processed = await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-basic", "relay-it", undefined, capturingSendBatch(sink));
+      globalThis.expect(processed).toBe(3);
+      globalThis.expect(sink.contents.length).toBe(3);
+      let first = sink.contents[0];
+      globalThis.expect(idOf(first)).toEqual("orderId:o-1");
+      let obj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(first), undefined);
+      globalThis.expect(JSON.stringify(Stdlib_Option.getOrThrow(obj["event"], undefined)).includes("OrderPlaced")).toBe(true);
+      let metaObj = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(obj["meta"], Stdlib_JSON.Decode.object), undefined);
+      globalThis.expect(metaObj["service"]).toEqual("relay-it");
+    });
+    globalThis.test("checkpoints — a second drain from the same subscriber sees nothing new", async () => {
+      let match = makeLog("relay-checkpoint");
+      let mk = i => stored("Fed", [{
+          key: "orderId",
+          value: "f"
+        }], Object.fromEntries([[
+          "i",
+          i
+        ]]));
+      await match[1].append([
+        mk(0),
+        mk(1)
+      ], undefined);
+      let sink = {
+        contents: []
+      };
+      let first = await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-checkpoint", "relay-it", undefined, capturingSendBatch(sink));
+      globalThis.expect(first).toBe(2);
+      let second = await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-checkpoint", "relay-it", undefined, capturingSendBatch(sink));
+      globalThis.expect(second).toBe(0);
+      globalThis.expect(sink.contents.length).toBe(2);
+    });
+    globalThis.test("partitionTag pins the id to its tag on a multi-tag event", async () => {
+      let match = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "relay-pt", [], {
+        TAG: "Simple",
+        _0: {
+          key: "customerId"
+        }
+      }, undefined, opts, undefined, undefined);
+      let ev = stored("OrderPlaced", [
+        {
+          key: "orderId",
+          value: "o-9"
+        },
+        {
+          key: "customerId",
+          value: "c-9"
+        }
+      ], Object.fromEntries([[
+          "n",
+          1
+        ]]));
+      await match[1].append([ev], undefined);
+      let partitionTagJson = S.reverseConvertToJsonOrThrow({
+        TAG: "Simple",
+        _0: {
+          key: "customerId"
+        }
+      }, DcbTag$Reventless.derivedPartitionTagSchema);
+      let sink = {
+        contents: []
+      };
+      await PgChangeFeedRelay_Runtime$ReventlessAws.relayWithPool(pool, "relay-pt", "relay-it", partitionTagJson, capturingSendBatch(sink));
+      globalThis.expect(idOf(sink.contents[0])).toEqual("customerId:c-9");
+    });
+  });
+} else {
+  globalThis.test("Postgres relay integration (skipped — set PG_URL to run)", () => {
+    globalThis.expect(true).toBe(true);
+  });
+}
+
+export {
+  opts,
+  jsonObj,
+  stored,
+  capturingSendBatch,
+  idOf,
+}
+/* url Not a pure module */