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

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.176 (2026-07-06)
+
+### Bug Fixes
+
+* **reventless-aws:** QueryEngine deploy crash on resource-less Postgres QueryDbs (B3.1b) ([a11b5d6](https://github.com/ReventlessDev/reventless-core/commit/a11b5d6f0797f1c9324f2a4ff3ba4197c20e721b))
+### Features
+
+* **reventless-aws:** classic EventLog Postgres deploy-time wiring + relay (B1 vertical) ([8235ba4](https://github.com/ReventlessDev/reventless-core/commit/8235ba44e506f7094d17251405c6a05c39789805))
+* **reventless-aws:** PgQueryResolver Lambda dispatcher for Postgres GraphQL reads (B3.2a-2) ([140d2bd](https://github.com/ReventlessDev/reventless-core/commit/140d2bd44c2443a03de16e21fd29d5a66b5db9be))
+* **reventless-aws:** Postgres projection delivery via relay feed queues (B3.0) ([80a0ffb](https://github.com/ReventlessDev/reventless-core/commit/80a0ffb1696902a1df99acca1f7915dd65e5c016))
+* **reventless-aws:** Postgres QueryDb storage vertical (B3.1) ([51a7993](https://github.com/ReventlessDev/reventless-core/commit/51a79934c1d9f59bb6f61233a90651d5eadf9f4e))
+
+
+# 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.176",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,16 +9,16 @@
     "sury": "11.0.0-alpha.4",
     "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-effect": "0.1.0-alpha.25",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.45",
     "@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-interop": "3.0.0-alpha.23",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.3",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.65"
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.89",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.5",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.67",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.143"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
@@ -61,7 +61,7 @@
     "build": "rescript build",
     "start": "rescript watch",
     "clean": "rescript clean",
-    "rebuild": "pnpm run clean && pnpm run build -- -with-deps",
+    "rebuild": "pnpm run clean && pnpm run build",
     "deploy": "./scripts/deploy.sh",
     "test": "NODE_OPTIONS='--experimental-vm-modules' npx jest",
     "coverage": "nyc report --temp-directory=coverage --reporter=text-lcov | coveralls",

package/src/Platform.res

@@ -81,17 +81,35 @@ module MakeWithConfig = (
   Config.commandHandlerConfig.stateChanges->Option.forEach(({?sync, ?async}) =>
     PluginRuntime_Builder.setStateChangesConfig(~sync?, ~async?, ())
   )
-  // B2.3c: when a PgConnection is supplied, route ALL DCB EventLogs to Postgres
-  // (aggregate EventLogs stay on DynamoDB until the classic feed lands — B2.5) and
-  // record the selection for the change-feed relay wiring in makePlatform below.
-  // Set BEFORE the Admin/plugin functors run so DcbEventLogStorage.Selectable sees it.
-  Config.pgConnection->Option.forEach((pg: PgConnection.t) =>
+  // B2.3c: when a PgConnection is supplied, route ALL DCB EventLogs (DcbBackend)
+  // AND all classic aggregate EventLogs (EventLogBackend, Single strategies) to
+  // Postgres, and record the selections for the change-feed relay wiring in
+  // makePlatform below. Set BEFORE the Admin/plugin functors run so the storage
+  // Selectables see it.
+  Config.pgConnection->Option.forEach((pg: PgConnection.t) => {
     DcbBackend.set({
       connectionConfig: pg.connectionConfig,
       securityGroupId: pg.securityGroupId,
       subnetIds: pg.subnetIds,
     })
-  )
+    EventLogBackend.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds,
+    })
+    // B3.1: app read models / state view slices store to Postgres too. Admin
+    // read models are exempt — deploy-time consumers (schema-clobber guard's
+    // Plugin-RM scan, PLUGIN_RM_TABLE_NAME gates, retire hooks) query them
+    // during `pulumi up` from outside the VPC, and the platform lifecycle
+    // depends on them.
+    QueryDbBackend.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds,
+    })
+    QueryDbBackend.exempt(ReventlessCore.PluginsReadModelSpec.name)
+    QueryDbBackend.exempt(ReventlessCore.UIFragmentRegistryReadModelSpec.name)
+  })
   type api = Types.AppSync.api
   type role = Types.AppSync.role
   type apiTarget = Domain | Platform
@@ -1230,36 +1248,101 @@ module MakeWithConfig = (
   type mcpSupported = | @as(true) McpSupported | @as(false) McpNotSupported
   let mcpSupported = McpNotSupported
 
-  // B2.3d: provision the Postgres change-feed relay when the DCB backend is Postgres.
-  // Called after plugins are built (makePlatform monolithic, or deployPlugin per
-  // stack). Each Postgres DCB log registered {logName, partitionTag} during its
-  // plugin build (DcbEventLogStorage_Postgres.make), and its plugin's EventCollector
-  // queue was attached in forPluginEventCollector — so the registry is complete here.
-  // One shared relay Lambda drains all logs from their per-log dcb_subscription
-  // checkpoints and feeds each plugin's collector queue.
-  let provisionPgChangeFeedRelay = () =>
-    switch DcbBackend.get() {
-    | Some({connectionConfig, securityGroupId, subnetIds}) =>
-      let relayLogs =
-        DcbBackend.getRelayLogs()->Array.filterMap(entry =>
-          switch (entry.collectorQueueUrl, entry.collectorQueueArn) {
-          | (Some(targetQueueUrl), Some(targetQueueArn)) =>
-            Some({
+  // B2.3d: provision the Postgres change-feed relay when a Postgres backend is
+  // active. Called after plugins are built (makePlatform monolithic, or deployPlugin
+  // per stack). Each Postgres log registered itself during its plugin build
+  // (DcbEventLogStorage_Postgres.make / EventLogStorage_Postgres.make), and its
+  // plugin's EventCollector queue was attached in forPluginEventCollector — so the
+  // registries are complete here. One shared relay Lambda drains all logs (DCB and
+  // classic) and feeds each plugin's collector queue. The checkpoint tables key by
+  // subscriber alone, so the subscriber embeds the log name — a shared subscriber
+  // string across logs would clobber checkpoints and skip events.
+  let provisionPgChangeFeedRelay = () => {
+    // B3.0: besides each plugin's EventCollector queue, every log also fans out
+    // to the registered projection feed queues (the AllReadModels /
+    // AllStateViewSlices Lambdas) — Postgres logs have no DynamoDB stream, so
+    // this is how RM/SVS projections are fed. One subscriber per (feed, log)
+    // keeps checkpoints isolated.
+    let feedTargets = (~connectionConfig, ~logName, ~feed, ~isClassic) =>
+      PgProjectionFeed.getFeedQueues()->Array.filterMap(fq =>
+        (isClassic ? fq.includeClassic : fq.includeDcb)
+          ? Some({
+              PgChangeFeedRelay_Builder.connectionConfig,
+              logName,
+              subscriber: `${fq.scope}:${logName}`,
+              feed,
+              targetQueueUrl: fq.url,
+              targetQueueArn: fq.arn,
+            })
+          : None
+      )
+    let dcbLogs = switch DcbBackend.get() {
+    | Some({connectionConfig}) =>
+      DcbBackend.getRelayLogs()->Array.flatMap(entry => {
+        let feed = PgChangeFeedRelay_Builder.Dcb({partitionTag: entry.partitionTag})
+        let ecTarget = switch (entry.collectorQueueUrl, entry.collectorQueueArn) {
+        | (Some(targetQueueUrl), Some(targetQueueArn)) => [
+            {
               PgChangeFeedRelay_Builder.connectionConfig,
               logName: entry.logName,
-              subscriber: "aws-eventcollector-relay",
-              partitionTag: entry.partitionTag,
+              subscriber: `aws-eventcollector-relay:${entry.logName}`,
+              feed,
               targetQueueUrl,
               targetQueueArn,
-            })
-          | _ =>
-            log.warn(
-              ~comp="Platform",
-              `PgChangeFeedRelay: DCB log ${entry.logName} has no EventCollector queue — skipping (its events will not propagate)`,
-            )
-            None
-          }
+            },
+          ]
+        | _ =>
+          log.warn(
+            ~comp="Platform",
+            `PgChangeFeedRelay: DCB log ${entry.logName} has no EventCollector queue — EP/extension fan-out skipped for it`,
+          )
+          []
+        }
+        ecTarget->Array.concat(
+          feedTargets(~connectionConfig, ~logName=entry.logName, ~feed, ~isClassic=false),
+        )
+      })
+    | None => []
+    }
+    let classicLogs = switch EventLogBackend.get() {
+    | Some({connectionConfig}) =>
+      EventLogBackend.getRelayLogs()->Array.flatMap(entry => {
+        let feed = PgChangeFeedRelay_Builder.Classic
+        let ecTarget = switch (entry.collectorQueueUrl, entry.collectorQueueArn) {
+        | (Some(targetQueueUrl), Some(targetQueueArn)) => [
+            {
+              PgChangeFeedRelay_Builder.connectionConfig,
+              logName: entry.logName,
+              subscriber: `aws-eventcollector-relay:${entry.logName}`,
+              feed,
+              targetQueueUrl,
+              targetQueueArn,
+            },
+          ]
+        | _ =>
+          log.warn(
+            ~comp="Platform",
+            `PgChangeFeedRelay: classic log ${entry.logName} has no EventCollector queue — EP/extension fan-out skipped for it`,
+          )
+          []
+        }
+        ecTarget->Array.concat(
+          feedTargets(~connectionConfig, ~logName=entry.logName, ~feed, ~isClassic=true),
         )
+      })
+    | None => []
+    }
+    let relayLogs = dcbLogs->Array.concat(classicLogs)
+    let relayVpc = switch DcbBackend.get() {
+    | Some(sel) => Some((sel.securityGroupId, sel.subnetIds))
+    | None =>
+      switch EventLogBackend.get() {
+      | Some(sel) => Some((sel.securityGroupId, sel.subnetIds))
+      | None => None
+      }
+    }
+    switch relayVpc {
+    | Some((securityGroupId, subnetIds)) =>
       if relayLogs->Array.length > 0 {
         let _ = PgChangeFeedRelay_Builder.make(
           ~name="PgChangeFeedRelay",
@@ -1270,6 +1353,7 @@ module MakeWithConfig = (
       }
     | None => ()
     }
+  }
 
   // In split mode, create a dedicated core AppSync API and push the core schema.
   // In unified mode, makePlatform is a no-op (schema stitching handled by events).

package/src/Platform.res.mjs

@@ -31,12 +31,15 @@ import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/
 import * as Util_DynamoDb$ReventlessAws from "./util/Util_DynamoDb.res.mjs";
 import * as Platform_Casts$ReventlessAws from "./Platform_Casts.res.mjs";
 import * as Platform_Stack$ReventlessAws from "./Platform_Stack.res.mjs";
+import * as QueryDbBackend$ReventlessAws from "./adapter/QueryDb/QueryDbBackend.res.mjs";
 import * as AppSync_Adapter$ReventlessAws from "./components/Api/AppSync_Adapter.res.mjs";
 import * as Counter_Builder$ReventlessAws from "./components/Counter_Builder.res.mjs";
+import * as EventLogBackend$ReventlessAws from "./adapter/EventLog/EventLogBackend.res.mjs";
 import * as Platform_Admin$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin.res.mjs";
 import * as PluginBehavior$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
+import * as PgProjectionFeed$ReventlessAws from "./adapter/Postgres/PgProjectionFeed.res.mjs";
 import * as Util_LocalConfig$ReventlessAws from "./util/Util_LocalConfig.res.mjs";
 import * as IndexJs from "@pulumi/pulumi/runtime/index.js";
 import * as AppSync_EventsApi$ReventlessAws from "./adapter/Api/AppSync_EventsApi.res.mjs";
@@ -120,11 +123,25 @@ function MakeWithConfig(Config) {
     Stdlib_Option.forEach(param.async, AggregateRuntime_Builder_Single_Async$ReventlessAws.setConfig);
   });
   Stdlib_Option.forEach(Config.commandHandlerConfig.stateChanges, param => PluginRuntime_Builder$ReventlessAws.setStateChangesConfig(param.sync, param.async, undefined));
-  Stdlib_Option.forEach(Config.pgConnection, pg => DcbBackend$ReventlessAws.set({
-    connectionConfig: pg.connectionConfig,
-    securityGroupId: pg.securityGroupId,
-    subnetIds: pg.subnetIds
-  }));
+  Stdlib_Option.forEach(Config.pgConnection, pg => {
+    DcbBackend$ReventlessAws.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds
+    });
+    EventLogBackend$ReventlessAws.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds
+    });
+    QueryDbBackend$ReventlessAws.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds
+    });
+    QueryDbBackend$ReventlessAws.exempt(PluginsReadModelSpec$ReventlessCore.name);
+    QueryDbBackend$ReventlessAws.exempt(UIFragmentRegistryReadModelSpec$ReventlessCore.name);
+  });
   let currentDeployTarget = {
     contents: "Domain"
   };
@@ -816,28 +833,99 @@ function MakeWithConfig(Config) {
     return Component$ReventlessCore.operations(component);
   };
   let provisionPgChangeFeedRelay = () => {
-    let match = DcbBackend$ReventlessAws.get();
-    if (match === undefined) {
-      return;
-    }
-    let connectionConfig = match.connectionConfig;
-    let relayLogs = Stdlib_Array.filterMap(DcbBackend$ReventlessAws.getRelayLogs(), entry => {
-      let match = entry.collectorQueueUrl;
-      let match$1 = entry.collectorQueueArn;
-      if (match !== undefined && match$1 !== undefined) {
+    let feedTargets = (connectionConfig, logName, feed, isClassic) => Stdlib_Array.filterMap(PgProjectionFeed$ReventlessAws.getFeedQueues(), fq => {
+      if (isClassic ? fq.includeClassic : fq.includeDcb) {
         return {
           connectionConfig: connectionConfig,
-          logName: entry.logName,
-          subscriber: "aws-eventcollector-relay",
-          partitionTag: entry.partitionTag,
-          targetQueueUrl: match,
-          targetQueueArn: match$1
+          logName: logName,
+          subscriber: fq.scope + `:` + logName,
+          feed: feed,
+          targetQueueUrl: fq.url,
+          targetQueueArn: fq.arn
         };
       }
-      log.warn("Platform", undefined, `PgChangeFeedRelay: DCB log ` + entry.logName + ` has no EventCollector queue — skipping (its events will not propagate)`);
     });
-    if (relayLogs.length !== 0) {
-      PgChangeFeedRelay_Builder$ReventlessAws.make("PgChangeFeedRelay", relayLogs, match.securityGroupId, match.subnetIds, undefined, undefined);
+    let match = DcbBackend$ReventlessAws.get();
+    let dcbLogs;
+    if (match !== undefined) {
+      let connectionConfig = match.connectionConfig;
+      dcbLogs = DcbBackend$ReventlessAws.getRelayLogs().flatMap(entry => {
+        let feed = {
+          TAG: "Dcb",
+          partitionTag: entry.partitionTag
+        };
+        let match = entry.collectorQueueUrl;
+        let match$1 = entry.collectorQueueArn;
+        let ecTarget;
+        let exit = 0;
+        if (match !== undefined && match$1 !== undefined) {
+          ecTarget = [{
+              connectionConfig: connectionConfig,
+              logName: entry.logName,
+              subscriber: `aws-eventcollector-relay:` + entry.logName,
+              feed: feed,
+              targetQueueUrl: match,
+              targetQueueArn: match$1
+            }];
+        } else {
+          exit = 1;
+        }
+        if (exit === 1) {
+          log.warn("Platform", undefined, `PgChangeFeedRelay: DCB log ` + entry.logName + ` has no EventCollector queue — EP/extension fan-out skipped for it`);
+          ecTarget = [];
+        }
+        return ecTarget.concat(feedTargets(connectionConfig, entry.logName, feed, false));
+      });
+    } else {
+      dcbLogs = [];
+    }
+    let match$1 = EventLogBackend$ReventlessAws.get();
+    let classicLogs;
+    if (match$1 !== undefined) {
+      let connectionConfig$1 = match$1.connectionConfig;
+      classicLogs = EventLogBackend$ReventlessAws.getRelayLogs().flatMap(entry => {
+        let match = entry.collectorQueueUrl;
+        let match$1 = entry.collectorQueueArn;
+        let ecTarget;
+        let exit = 0;
+        if (match !== undefined && match$1 !== undefined) {
+          ecTarget = [{
+              connectionConfig: connectionConfig$1,
+              logName: entry.logName,
+              subscriber: `aws-eventcollector-relay:` + entry.logName,
+              feed: "Classic",
+              targetQueueUrl: match,
+              targetQueueArn: match$1
+            }];
+        } else {
+          exit = 1;
+        }
+        if (exit === 1) {
+          log.warn("Platform", undefined, `PgChangeFeedRelay: classic log ` + entry.logName + ` has no EventCollector queue — EP/extension fan-out skipped for it`);
+          ecTarget = [];
+        }
+        return ecTarget.concat(feedTargets(connectionConfig$1, entry.logName, "Classic", true));
+      });
+    } else {
+      classicLogs = [];
+    }
+    let relayLogs = dcbLogs.concat(classicLogs);
+    let sel = DcbBackend$ReventlessAws.get();
+    let relayVpc;
+    if (sel !== undefined) {
+      relayVpc = [
+        sel.securityGroupId,
+        sel.subnetIds
+      ];
+    } else {
+      let sel$1 = EventLogBackend$ReventlessAws.get();
+      relayVpc = sel$1 !== undefined ? [
+          sel$1.securityGroupId,
+          sel$1.subnetIds
+        ] : undefined;
+    }
+    if (relayVpc !== undefined && relayLogs.length !== 0) {
+      PgChangeFeedRelay_Builder$ReventlessAws.make("PgChangeFeedRelay", relayLogs, relayVpc[0], relayVpc[1], undefined, undefined);
       return;
     }
   };
@@ -1245,11 +1333,25 @@ function Make($star) {
     Stdlib_Option.forEach(param.async, AggregateRuntime_Builder_Single_Async$ReventlessAws.setConfig);
   });
   Stdlib_Option.forEach(commandHandlerConfig.stateChanges, param => PluginRuntime_Builder$ReventlessAws.setStateChangesConfig(param.sync, param.async, undefined));
-  Stdlib_Option.forEach(undefined, pg => DcbBackend$ReventlessAws.set({
-    connectionConfig: pg.connectionConfig,
-    securityGroupId: pg.securityGroupId,
-    subnetIds: pg.subnetIds
-  }));
+  Stdlib_Option.forEach(undefined, pg => {
+    DcbBackend$ReventlessAws.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds
+    });
+    EventLogBackend$ReventlessAws.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds
+    });
+    QueryDbBackend$ReventlessAws.set({
+      connectionConfig: pg.connectionConfig,
+      securityGroupId: pg.securityGroupId,
+      subnetIds: pg.subnetIds
+    });
+    QueryDbBackend$ReventlessAws.exempt(PluginsReadModelSpec$ReventlessCore.name);
+    QueryDbBackend$ReventlessAws.exempt(UIFragmentRegistryReadModelSpec$ReventlessCore.name);
+  });
   let currentDeployTarget = {
     contents: "Domain"
   };
@@ -1940,28 +2042,99 @@ function Make($star) {
     return Component$ReventlessCore.operations(component);
   };
   let provisionPgChangeFeedRelay = () => {
-    let match = DcbBackend$ReventlessAws.get();
-    if (match === undefined) {
-      return;
-    }
-    let connectionConfig = match.connectionConfig;
-    let relayLogs = Stdlib_Array.filterMap(DcbBackend$ReventlessAws.getRelayLogs(), entry => {
-      let match = entry.collectorQueueUrl;
-      let match$1 = entry.collectorQueueArn;
-      if (match !== undefined && match$1 !== undefined) {
+    let feedTargets = (connectionConfig, logName, feed, isClassic) => Stdlib_Array.filterMap(PgProjectionFeed$ReventlessAws.getFeedQueues(), fq => {
+      if (isClassic ? fq.includeClassic : fq.includeDcb) {
         return {
           connectionConfig: connectionConfig,
-          logName: entry.logName,
-          subscriber: "aws-eventcollector-relay",
-          partitionTag: entry.partitionTag,
-          targetQueueUrl: match,
-          targetQueueArn: match$1
+          logName: logName,
+          subscriber: fq.scope + `:` + logName,
+          feed: feed,
+          targetQueueUrl: fq.url,
+          targetQueueArn: fq.arn
         };
       }
-      log.warn("Platform", undefined, `PgChangeFeedRelay: DCB log ` + entry.logName + ` has no EventCollector queue — skipping (its events will not propagate)`);
     });
-    if (relayLogs.length !== 0) {
-      PgChangeFeedRelay_Builder$ReventlessAws.make("PgChangeFeedRelay", relayLogs, match.securityGroupId, match.subnetIds, undefined, undefined);
+    let match = DcbBackend$ReventlessAws.get();
+    let dcbLogs;
+    if (match !== undefined) {
+      let connectionConfig = match.connectionConfig;
+      dcbLogs = DcbBackend$ReventlessAws.getRelayLogs().flatMap(entry => {
+        let feed = {
+          TAG: "Dcb",
+          partitionTag: entry.partitionTag
+        };
+        let match = entry.collectorQueueUrl;
+        let match$1 = entry.collectorQueueArn;
+        let ecTarget;
+        let exit = 0;
+        if (match !== undefined && match$1 !== undefined) {
+          ecTarget = [{
+              connectionConfig: connectionConfig,
+              logName: entry.logName,
+              subscriber: `aws-eventcollector-relay:` + entry.logName,
+              feed: feed,
+              targetQueueUrl: match,
+              targetQueueArn: match$1
+            }];
+        } else {
+          exit = 1;
+        }
+        if (exit === 1) {
+          log.warn("Platform", undefined, `PgChangeFeedRelay: DCB log ` + entry.logName + ` has no EventCollector queue — EP/extension fan-out skipped for it`);
+          ecTarget = [];
+        }
+        return ecTarget.concat(feedTargets(connectionConfig, entry.logName, feed, false));
+      });
+    } else {
+      dcbLogs = [];
+    }
+    let match$1 = EventLogBackend$ReventlessAws.get();
+    let classicLogs;
+    if (match$1 !== undefined) {
+      let connectionConfig$1 = match$1.connectionConfig;
+      classicLogs = EventLogBackend$ReventlessAws.getRelayLogs().flatMap(entry => {
+        let match = entry.collectorQueueUrl;
+        let match$1 = entry.collectorQueueArn;
+        let ecTarget;
+        let exit = 0;
+        if (match !== undefined && match$1 !== undefined) {
+          ecTarget = [{
+              connectionConfig: connectionConfig$1,
+              logName: entry.logName,
+              subscriber: `aws-eventcollector-relay:` + entry.logName,
+              feed: "Classic",
+              targetQueueUrl: match,
+              targetQueueArn: match$1
+            }];
+        } else {
+          exit = 1;
+        }
+        if (exit === 1) {
+          log.warn("Platform", undefined, `PgChangeFeedRelay: classic log ` + entry.logName + ` has no EventCollector queue — EP/extension fan-out skipped for it`);
+          ecTarget = [];
+        }
+        return ecTarget.concat(feedTargets(connectionConfig$1, entry.logName, "Classic", true));
+      });
+    } else {
+      classicLogs = [];
+    }
+    let relayLogs = dcbLogs.concat(classicLogs);
+    let sel = DcbBackend$ReventlessAws.get();
+    let relayVpc;
+    if (sel !== undefined) {
+      relayVpc = [
+        sel.securityGroupId,
+        sel.subnetIds
+      ];
+    } else {
+      let sel$1 = EventLogBackend$ReventlessAws.get();
+      relayVpc = sel$1 !== undefined ? [
+          sel$1.securityGroupId,
+          sel$1.subnetIds
+        ] : undefined;
+    }
+    if (relayVpc !== undefined && relayLogs.length !== 0) {
+      PgChangeFeedRelay_Builder$ReventlessAws.make("PgChangeFeedRelay", relayLogs, relayVpc[0], relayVpc[1], undefined, undefined);
       return;
     }
   };

package/src/adapter/DcbEventLog/DcbBackend.res

@@ -10,8 +10,8 @@
 //     EventCollector SQS queue.
 //
 // All DCB logs in the platform share one selection (the confirmed B2.3c toggle);
-// aggregate EventLogs are unaffected — they stay on DynamoDB until the classic
-// `event_log` change feed lands (B2.5). See docs/plans/aws-postgres-change-feed-bridge.md.
+// classic aggregate EventLogs follow the same platform toggle via the sibling
+// `EventLogBackend` registry. See docs/plans/done/aws-postgres-change-feed-bridge.md.
 
 type selection = {
   connectionConfig: Pulumi.Output.t<PgConnection.connectionConfig>,

package/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res

@@ -32,10 +32,13 @@ let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'con
   ~eventTopics,
   ~opts as _,
 ) => {
+  // Postgres-backed event logs have NO storage resources (no table, no stream) —
+  // skip them instead of producing undefined entries; their events arrive via the
+  // PgProjectionFeed SQS queue (B3.0), not a stream ESM.
   let eventTopicResources =
     eventTopics
     ->Dict.valuesToArray
-    ->Array.map(outputs => outputs.resources->Array.getUnsafe(0)) // FIXME
+    ->Array.filterMap(outputs => outputs.resources->Array.get(0))
 
   let enqueueEventNotSupported = (delay, id, messageBody) => {
     // TODO: can we check this at deploy time ?

package/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs

@@ -21,7 +21,7 @@ function connect(name, channelSpecs, runtime, opts) {
 }
 
 function make(param, eventTopics, param$1) {
-  let eventTopicResources = Object.values(eventTopics).map(outputs => outputs.resources[0]);
+  let eventTopicResources = Stdlib_Array.filterMap(Object.values(eventTopics), outputs => outputs.resources[0]);
   let enqueueEventNotSupported = (delay, id, messageBody) => {
     log.debug("EventCollectorChannel_DynamoDbStream", Object.fromEntries([
       [

package/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res

@@ -1,12 +1,22 @@
+// Shared record decoder for the ReadModel / StateViewSlice entry points.
+//
+// DynamoDB path: the Lambda is invoked by DynamoDB-stream ESMs — decode each
+// NEW_IMAGE. Postgres path (B3.0): the Lambda is invoked by its SQS feed queue,
+// fed by the PgChangeFeedRelay with ready-made `{id, meta, event}` bodies —
+// parse each body straight back to JSON. Both record kinds can appear in one
+// deployment (mixed backends), so the branch is per record, not per event.
 let handleStreamEvent: (
   ReventlessCore.EventCollector.jsonEventsHandler,
-  PulumiAws.DynamoDb.Stream.event,
+  PulumiAws.Lambda.CallbackFunction.event,
   _,
-) => Effect.t<unit, string, unit> = (handleEvents, streamEvent, _) => {
-  let jsons = streamEvent.records->Array.filterMap(record =>
+) => Effect.t<unit, string, unit> = (handleEvents, event, _) => {
+  let jsons = event.records->Array.filterMap(record =>
     switch record.eventSource {
+    | "aws:sqs" => record->PulumiAws.SQS.Queue.asRecord->Util.SQS_Runtime.parseSqsRecord
     | "aws:dynamodb" =>
-      switch record->Util.DynamoDbStream_Runtime.parseDynamoDbStreamRecordEvent {
+      switch record
+      ->PulumiAws.DynamoDb.Stream.asRecord
+      ->Util.DynamoDbStream_Runtime.parseDynamoDbStreamRecordEvent {
       | NewImage(_, newImage)
       | NewAndOldImage(_, newImage, _) =>
         Some(newImage)