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

package/src/components/StateViewSlice_Builder.res.mjs

@@ -1,10 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Pulumi from "@pulumi/pulumi";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
-import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbBackend$ReventlessAws from "../adapter/QueryDb/QueryDbBackend.res.mjs";
+import * as QueryDbStorage$ReventlessAws from "../adapter/QueryDb/QueryDbStorage.res.mjs";
+import * as QueryDbResolvers$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers.res.mjs";
 import * as StateViewSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs";
-import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 import * as StateViewSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/StateViewSliceRuntime_Builder_Single.res.mjs";
@@ -16,11 +18,7 @@ function Make(Api) {
     extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
     asEventHandler: prim => prim,
     asEffectHandler: prim => prim
-  })({
-    make: QueryDbStorage_DynamoDb$ReventlessAws.make
-  })({
-    make: QueryDbResolvers_AppSync$ReventlessAws.make
-  })({
+  })(QueryDbStorage$ReventlessAws.Selectable)(QueryDbResolvers$ReventlessAws.Selectable)({
     make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
     connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
   })({
@@ -36,8 +34,8 @@ function Make(Api) {
     let make = (dcbEventLog, opts) => {
       let sv = InnerMake.make(dcbEventLog, opts);
       let queryDbOutputs = Component$ReventlessCore.outputs(sv).queryDb;
-      let tableResource = queryDbOutputs.resources[0];
-      StateViewSliceRuntime_Builder_Single$ReventlessAws.registerStateViewSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Projection.moduleUrl), tableResource.name, queryDbOutputs.resources);
+      let queryDbTableName = QueryDbBackend$ReventlessAws.isPostgresFor(Spec.name) ? Pulumi.output(Spec.name) : queryDbOutputs.resources[0].name;
+      StateViewSliceRuntime_Builder_Single$ReventlessAws.registerStateViewSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Projection.moduleUrl), queryDbTableName, queryDbOutputs.resources);
       return sv;
     };
     return {
@@ -65,4 +63,4 @@ export {
   EventCollectorRuntimeBuilder,
   Make,
 }
-/* Component-ReventlessCore Not a pure module */
+/* @pulumi/pulumi Not a pure module */

package/src/components/StateViewSlice_Builder_Stream.res

@@ -15,8 +15,8 @@ module Make = (Api: {
 }) => {
   module Inner = ReventlessCore.StateViewSlice_Builder.Make(
     RuntimeEnvironment,
-    QueryDbStorage_DynamoDbStream,
-    QueryDbResolvers.AppSync,
+    QueryDbStorage.SelectableStream,
+    QueryDbResolvers.Selectable,
     EventCollectorChannel,
     EventCollectorRuntimeBuilder,
     Api,
@@ -36,12 +36,18 @@ module Make = (Api: {
     let make = (~dcbEventLog, ~opts=?): component => {
       let sv = InnerMake.make(~dcbEventLog, ~opts?)
       let queryDbOutputs = (sv->ReventlessCore.Component.outputs).queryDb
-      let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
+      // On the Postgres backend there is no DynamoDB table (resources is
+      // empty) — the slice spec name is the stable `qdb_<name>` discriminator.
+      let queryDbTableName = if QueryDbBackend.isPostgresFor(Spec.name) {
+        Pulumi.Output.make(Spec.name)
+      } else {
+        (queryDbOutputs.resources->Array.getUnsafe(0)).name
+      }
       EventCollectorRuntimeBuilder.registerStateViewSlice(
         ~name=Spec.name,
         ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
         ~projectionModulePath=Util_Bundle.getModuleSpecifier(Projection.moduleUrl),
-        ~queryDbTableName=tableResource.name,
+        ~queryDbTableName,
         ~queryDbResources=queryDbOutputs.resources,
       )
       sv

package/src/components/StateViewSlice_Builder_Stream.res.mjs

@@ -1,11 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Pulumi from "@pulumi/pulumi";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
+import * as QueryDbBackend$ReventlessAws from "../adapter/QueryDb/QueryDbBackend.res.mjs";
+import * as QueryDbStorage$ReventlessAws from "../adapter/QueryDb/QueryDbStorage.res.mjs";
+import * as QueryDbResolvers$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers.res.mjs";
 import * as StateViewSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs";
-import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
-import * as QueryDbStorage_DynamoDbStream$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDbStream.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 import * as StateViewSliceRuntime_Builder_Single$ReventlessAws from "../adapter/Runtime/StateViewSliceRuntime_Builder_Single.res.mjs";
 
@@ -16,11 +18,7 @@ function Make(Api) {
     extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
     asEventHandler: prim => prim,
     asEffectHandler: prim => prim
-  })({
-    make: QueryDbStorage_DynamoDbStream$ReventlessAws.make
-  })({
-    make: QueryDbResolvers_AppSync$ReventlessAws.make
-  })({
+  })(QueryDbStorage$ReventlessAws.SelectableStream)(QueryDbResolvers$ReventlessAws.Selectable)({
     make: EventCollectorChannel_DynamoDbStream$ReventlessAws.make,
     connect: EventCollectorChannel_DynamoDbStream$ReventlessAws.connect
   })({
@@ -36,8 +34,8 @@ function Make(Api) {
     let make = (dcbEventLog, opts) => {
       let sv = InnerMake.make(dcbEventLog, opts);
       let queryDbOutputs = Component$ReventlessCore.outputs(sv).queryDb;
-      let tableResource = queryDbOutputs.resources[0];
-      StateViewSliceRuntime_Builder_Single$ReventlessAws.registerStateViewSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Projection.moduleUrl), tableResource.name, queryDbOutputs.resources);
+      let queryDbTableName = QueryDbBackend$ReventlessAws.isPostgresFor(Spec.name) ? Pulumi.output(Spec.name) : queryDbOutputs.resources[0].name;
+      StateViewSliceRuntime_Builder_Single$ReventlessAws.registerStateViewSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Projection.moduleUrl), queryDbTableName, queryDbOutputs.resources);
       return sv;
     };
     return {
@@ -65,4 +63,4 @@ export {
   EventCollectorRuntimeBuilder,
   Make,
 }
-/* Component-ReventlessCore Not a pure module */
+/* @pulumi/pulumi Not a pure module */

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -216,6 +216,18 @@ module Make = (
       }
     }
 
+    // Classic Postgres logs: `~eventTopics` is keyed by aggregate name, so each key
+    // attaches this plugin's EventCollector queue to exactly the aggregates whose
+    // event-log DynamoDB stream the collector would have subscribed on the DynamoDB
+    // path (admin's extension-point filtering included).
+    if EventLogBackend.isPostgres() {
+      eventTopics
+      ->Dict.keysToArray
+      ->Array.forEach(aggregateName =>
+        EventLogBackend.attachCollectorQueue(~aggregateName, ~url=queue.id, ~arn=queue.arn)
+      )
+    }
+
     // Pull the per-EventCollector context registered by Plugin_Helpers.connect
     // (plugins) or synthesise an admin one if none registered.
     let context: ReventlessCore.Plugin_Helpers.eventCollectorContext =

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -14,6 +14,7 @@ import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/p
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
 import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.res.mjs";
+import * as EventLogBackend$ReventlessAws from "../../adapter/EventLog/EventLogBackend.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "../../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
 import * as StateChangeSliceRuntime_Builder_Single$ReventlessAws from "../../adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res.mjs";
@@ -174,6 +175,9 @@ function Make(EventCollectorChannel) {
         DcbBackend$ReventlessAws.attachCollectorQueue(pluginName + "DcbEventLog", queue.id, queue.arn);
       }
     }
+    if (EventLogBackend$ReventlessAws.isPostgres()) {
+      Object.keys(eventTopics).forEach(aggregateName => EventLogBackend$ReventlessAws.attachCollectorQueue(aggregateName, queue.id, queue.arn));
+    }
     let ctx = Plugin_Helpers$ReventlessCore.eventCollectorContextRef.contents[name];
     let context = ctx !== undefined ? ctx : synthesizeAdminContext();
     let envVars = {};

package/tests/EventCollectorChannelStreamRuntimeTest.res

@@ -0,0 +1,55 @@
+// B3.0: the ReadModel/StateViewSlice record decoder must accept BOTH DynamoDB
+// stream records (DynamoDB backend) and SQS records (Postgres backend — bodies
+// injected by the PgChangeFeedRelay via the projection feed queue), in one batch.
+
+open JestGlobals
+
+let mkEvent = (records): PulumiAws.Lambda.CallbackFunction.event => Obj.magic({"Records": records})
+
+let sqsRecord = body =>
+  {
+    "eventSource": "aws:sqs",
+    "eventSourceARN": "arn:aws:sqs:eu-west-1:1:AllReadModelsFeed",
+    "body": body,
+  }
+
+let run = event => {
+  let seen: array<JSON.t> = []
+  let handler: ReventlessCore.EventCollector.jsonEventsHandler = stream =>
+    stream
+    ->Stream.runForEach(json => Effect.succeed(seen->Array.push(json)->ignore))
+    ->Effect.map(_ => ())
+  EventCollectorChannel_DynamoDbStream_Runtime.handleStreamEvent(handler, event, ())
+  ->Effect.runPromise
+  ->Promise.thenResolve(_ => seen)
+}
+
+describe("handleStreamEvent (ReadModel/SVS record decoder)", () => {
+  test("parses SQS feed-queue records into their JSON bodies", async () => {
+    let seen = await run(
+      mkEvent([
+        sqsRecord(`{"id":"agg-1","meta":{"service":"Product"},"event":{"type":"Added","data":{}}}`),
+        sqsRecord(`{"id":"agg-2","meta":{"service":"Product"},"event":{"type":"Added","data":{}}}`),
+      ]),
+    )
+    expect(seen->Array.length)->toBe(2)
+    let id0 =
+      seen
+      ->Array.getUnsafe(0)
+      ->JSON.Decode.object
+      ->Option.flatMap(o => o->Dict.get("id"))
+      ->Option.flatMap(JSON.Decode.string)
+    expect(id0)->toEqual(Some("agg-1"))
+  })
+
+  test("skips malformed SQS bodies and unknown sources without failing the batch", async () => {
+    let seen = await run(
+      mkEvent([
+        sqsRecord("not-json"),
+        {"eventSource": "aws:kinesis", "eventSourceARN": "arn:x", "body": "{}"},
+        sqsRecord(`{"ok":true}`),
+      ]),
+    )
+    expect(seen->Array.length)->toBe(1)
+  })
+})

package/tests/EventCollectorChannelStreamRuntimeTest.res.mjs

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as EventCollectorChannel_DynamoDbStream_Runtime$ReventlessAws from "../src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+
+function mkEvent(records) {
+  return {
+    Records: records
+  };
+}
+
+function sqsRecord(body) {
+  return {
+    eventSource: "aws:sqs",
+    eventSourceARN: "arn:aws:sqs:eu-west-1:1:AllReadModelsFeed",
+    body: body
+  };
+}
+
+function run(event) {
+  let seen = [];
+  let handler = stream => Effect.map(Stream.runForEach(stream, json => Effect.succeed((seen.push(json), undefined))), () => {});
+  return Effect.runPromise(EventCollectorChannel_DynamoDbStream_Runtime$ReventlessAws.handleStreamEvent(handler, event, undefined)).then(() => seen);
+}
+
+globalThis.describe("handleStreamEvent (ReadModel/SVS record decoder)", () => {
+  globalThis.test("parses SQS feed-queue records into their JSON bodies", async () => {
+    let seen = await run({
+      Records: [
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "arn:aws:sqs:eu-west-1:1:AllReadModelsFeed",
+          body: `{"id":"agg-1","meta":{"service":"Product"},"event":{"type":"Added","data":{}}}`
+        },
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "arn:aws:sqs:eu-west-1:1:AllReadModelsFeed",
+          body: `{"id":"agg-2","meta":{"service":"Product"},"event":{"type":"Added","data":{}}}`
+        }
+      ]
+    });
+    globalThis.expect(seen.length).toBe(2);
+    let id0 = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(seen[0]), o => o["id"]), Stdlib_JSON.Decode.string);
+    globalThis.expect(id0).toEqual("agg-1");
+  });
+  globalThis.test("skips malformed SQS bodies and unknown sources without failing the batch", async () => {
+    let seen = await run({
+      Records: [
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "arn:aws:sqs:eu-west-1:1:AllReadModelsFeed",
+          body: "not-json"
+        },
+        {
+          eventSource: "aws:kinesis",
+          eventSourceARN: "arn:x",
+          body: "{}"
+        },
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "arn:aws:sqs:eu-west-1:1:AllReadModelsFeed",
+          body: `{"ok":true}`
+        }
+      ]
+    });
+    globalThis.expect(seen.length).toBe(1);
+  });
+});
+
+export {
+  mkEvent,
+  sqsRecord,
+  run,
+}
+/*  Not a pure module */

package/tests/PgChangeFeedRelay_IntegrationTest.res

@@ -5,11 +5,13 @@
 //   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
+// appended to a real `dcb_event` log (classic events to `event_log`), then
+// `PgChangeFeedRelay_Runtime.relayWithPool` / `relayClassicWithPool` 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).
+// `id` derivation, and the checkpoints (a second drain sees nothing new; per-log
+// subscribers stay isolated).
 
 open JestGlobals
 open ReventlessCore
@@ -110,6 +112,115 @@ switch processEnv->Dict.get("PG_URL") {
       expect(sink.contents->Array.length)->toBe(2)
     })
 
+    testPromise("classic: relays each appended event_log event as an {id, meta, event} body", async () => {
+      let (_n, ops, _s) =
+        ReventlessPostgres.EventLogStorage_Postgres.makeStorage(
+          ~pool,
+          ~name="ClassicRelayBasicEventLog",
+          ~opts=(),
+        )
+      // The flat on-disk item the classic append stores verbatim — same shape the
+      // DynamoDB path puts (id, position, event, data, decomposed meta).
+      let flatItem = (~id, ~seq, ~eventType, ~data) =>
+        [
+          ("id", JSON.Encode.string(id)),
+          ("position", JSON.Encode.string(seq->Int.toString->String.padStart(9, "0"))),
+          ("event", JSON.Encode.string(eventType)),
+          ("data", data),
+        ]
+        ->Array.concat(
+          ReventlessCore.Message.generateMeta(~service="relay-it")->ReventlessCore.Message.decomposeMeta,
+        )
+        ->Dict.fromArray
+        ->JSON.Encode.object
+      let _ = await ops.append(
+        0,
+        "agg-1",
+        [
+          flatItem(~id="agg-1", ~seq=0, ~eventType="NameUpdated", ~data=jsonObj([("n", JSON.Encode.int(0))])),
+          flatItem(~id="agg-1", ~seq=1, ~eventType="NameUpdated", ~data=jsonObj([("n", JSON.Encode.int(1))])),
+        ],
+      )
+
+      let sink = ref([])
+      let processed = await PgChangeFeedRelay_Runtime.relayClassicWithPool(
+        ~pool,
+        ~logName="ClassicRelayBasicEventLog",
+        ~subscriber="relay-it:ClassicRelayBasicEventLog",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+
+      expect(processed)->toBe(2)
+      expect(sink.contents->Array.length)->toBe(2)
+      let first = sink.contents->Array.getUnsafe(0)
+      expect(idOf(first))->toEqual(Some("agg-1"))
+      let obj = first->JSON.Decode.object->Option.getOrThrow
+      expect(
+        obj->Dict.get("event")->Option.getOrThrow->JSON.stringify->String.includes("NameUpdated"),
+      )->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")))
+
+      // Checkpointed: a second drain from the same subscriber sees nothing new.
+      let second = await PgChangeFeedRelay_Runtime.relayClassicWithPool(
+        ~pool,
+        ~logName="ClassicRelayBasicEventLog",
+        ~subscriber="relay-it:ClassicRelayBasicEventLog",
+        ~sendBatch=capturingSendBatch(sink),
+      )
+      expect(second)->toBe(0)
+      expect(sink.contents->Array.length)->toBe(2)
+    })
+
+    testPromise("classic: per-log subscribers keep checkpoints isolated across logs", async () => {
+      // event_log_subscription keys by subscriber alone. With a SHARED subscriber,
+      // draining log A after log B's events were appended would save a cursor past
+      // B's rows and silently skip them — the clobber the per-log subscriber fixes.
+      let mkOps = name => {
+        let (_n, ops, _s) =
+          ReventlessPostgres.EventLogStorage_Postgres.makeStorage(~pool, ~name, ~opts=())
+        ops
+      }
+      let opsB = mkOps("ClassicRelayIsoBEventLog")
+      let opsA = mkOps("ClassicRelayIsoAEventLog")
+      let meta = () =>
+        ReventlessCore.Message.generateMeta(~service="relay-it")->ReventlessCore.Message.decomposeMeta
+      let item = (id, eventType) =>
+        [
+          ("id", JSON.Encode.string(id)),
+          ("position", JSON.Encode.string("000000000")),
+          ("event", JSON.Encode.string(eventType)),
+          ("data", jsonObj([])),
+        ]
+        ->Array.concat(meta())
+        ->Dict.fromArray
+        ->JSON.Encode.object
+      // B's event commits FIRST (lower global_seq), then A's.
+      let _ = await opsB.append(0, "b-1", [item("b-1", "BHappened")])
+      let _ = await opsA.append(0, "a-1", [item("a-1", "AHappened")])
+
+      // Drain A first — its checkpoint lands PAST B's rows in global_seq order.
+      let sinkA = ref([])
+      let drainedA = await PgChangeFeedRelay_Runtime.relayClassicWithPool(
+        ~pool,
+        ~logName="ClassicRelayIsoAEventLog",
+        ~subscriber="relay-it:ClassicRelayIsoAEventLog",
+        ~sendBatch=capturingSendBatch(sinkA),
+      )
+      expect(drainedA)->toBe(1)
+
+      // B still sees its event because its subscriber has its own checkpoint.
+      let sinkB = ref([])
+      let drainedB = await PgChangeFeedRelay_Runtime.relayClassicWithPool(
+        ~pool,
+        ~logName="ClassicRelayIsoBEventLog",
+        ~subscriber="relay-it:ClassicRelayIsoBEventLog",
+        ~sendBatch=capturingSendBatch(sinkB),
+      )
+      expect(drainedB)->toBe(1)
+      expect(idOf(sinkB.contents->Array.getUnsafe(0)))->toEqual(Some("b-1"))
+    })
+
     testPromise("partitionTag pins the id to its tag on a multi-tag event", async () => {
       let (_n, ops, _s) =
         ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(

package/tests/PgChangeFeedRelay_IntegrationTest.res.mjs

@@ -8,6 +8,7 @@ import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Mess
 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 EventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogStorage_Postgres.res.mjs";
 import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
 
 let opts = {};
@@ -104,6 +105,89 @@ if (url !== undefined) {
       globalThis.expect(second).toBe(0);
       globalThis.expect(sink.contents.length).toBe(2);
     });
+    globalThis.test("classic: relays each appended event_log event as an {id, meta, event} body", async () => {
+      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "ClassicRelayBasicEventLog", undefined, undefined);
+      let flatItem = (id, seq, eventType, data) => Object.fromEntries([
+        [
+          "id",
+          id
+        ],
+        [
+          "position",
+          seq.toString().padStart(9, "0")
+        ],
+        [
+          "event",
+          eventType
+        ],
+        [
+          "data",
+          data
+        ]
+      ].concat(Message$ReventlessCore.decomposeMeta(Message$ReventlessCore.generateMeta("relay-it", undefined, undefined, undefined, undefined, undefined, undefined, undefined))));
+      await match[1].append(0, "agg-1", [
+        flatItem("agg-1", 0, "NameUpdated", Object.fromEntries([[
+            "n",
+            0
+          ]])),
+        flatItem("agg-1", 1, "NameUpdated", Object.fromEntries([[
+            "n",
+            1
+          ]]))
+      ]);
+      let sink = {
+        contents: []
+      };
+      let processed = await PgChangeFeedRelay_Runtime$ReventlessAws.relayClassicWithPool(pool, "ClassicRelayBasicEventLog", "relay-it:ClassicRelayBasicEventLog", capturingSendBatch(sink));
+      globalThis.expect(processed).toBe(2);
+      globalThis.expect(sink.contents.length).toBe(2);
+      let first = sink.contents[0];
+      globalThis.expect(idOf(first)).toEqual("agg-1");
+      let obj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(first), undefined);
+      globalThis.expect(JSON.stringify(Stdlib_Option.getOrThrow(obj["event"], undefined)).includes("NameUpdated")).toBe(true);
+      let metaObj = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(obj["meta"], Stdlib_JSON.Decode.object), undefined);
+      globalThis.expect(metaObj["service"]).toEqual("relay-it");
+      let second = await PgChangeFeedRelay_Runtime$ReventlessAws.relayClassicWithPool(pool, "ClassicRelayBasicEventLog", "relay-it:ClassicRelayBasicEventLog", capturingSendBatch(sink));
+      globalThis.expect(second).toBe(0);
+      globalThis.expect(sink.contents.length).toBe(2);
+    });
+    globalThis.test("classic: per-log subscribers keep checkpoints isolated across logs", async () => {
+      let mkOps = name => EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, undefined, undefined)[1];
+      let opsB = mkOps("ClassicRelayIsoBEventLog");
+      let opsA = mkOps("ClassicRelayIsoAEventLog");
+      let meta = () => Message$ReventlessCore.decomposeMeta(Message$ReventlessCore.generateMeta("relay-it", undefined, undefined, undefined, undefined, undefined, undefined, undefined));
+      let item = (id, eventType) => Object.fromEntries([
+        [
+          "id",
+          id
+        ],
+        [
+          "position",
+          "000000000"
+        ],
+        [
+          "event",
+          eventType
+        ],
+        [
+          "data",
+          Object.fromEntries([])
+        ]
+      ].concat(meta()));
+      await opsB.append(0, "b-1", [item("b-1", "BHappened")]);
+      await opsA.append(0, "a-1", [item("a-1", "AHappened")]);
+      let sinkA = {
+        contents: []
+      };
+      let drainedA = await PgChangeFeedRelay_Runtime$ReventlessAws.relayClassicWithPool(pool, "ClassicRelayIsoAEventLog", "relay-it:ClassicRelayIsoAEventLog", capturingSendBatch(sinkA));
+      globalThis.expect(drainedA).toBe(1);
+      let sinkB = {
+        contents: []
+      };
+      let drainedB = await PgChangeFeedRelay_Runtime$ReventlessAws.relayClassicWithPool(pool, "ClassicRelayIsoBEventLog", "relay-it:ClassicRelayIsoBEventLog", capturingSendBatch(sinkB));
+      globalThis.expect(drainedB).toBe(1);
+      globalThis.expect(idOf(sinkB.contents[0])).toEqual("b-1");
+    });
     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",