@reventlessdev/reventless-aws 3.0.0-alpha.260 → 3.0.0-alpha.262

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.262 (2026-08-03)
+
+### Bug Fixes
+
+* **aws:** key the shared automation channel's DCB topic by convention ([fe473d5](https://github.com/ReventlessDev/reventless-core/commit/fe473d561343f39bc1d05a2afaa902459142bbd0))
+
+
+# 3.0.0-alpha.261 (2026-08-03)
+
+### Features
+
+* **aws:** let an outbound slice read an aggregate at runtime ([24585f8](https://github.com/ReventlessDev/reventless-core/commit/24585f869c15a07910434632d76d8c8d8058042b))
+
+
 # 3.0.0-alpha.260 (2026-08-03)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.260",
+  "version": "3.0.0-alpha.262",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -11,18 +11,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.3",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.65",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.3",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.206",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.207",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.70",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.98",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.123"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.71",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.99"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Runtime/AutomationSliceEntryPoint.mjs

@@ -45,7 +45,19 @@ async function buildAllHandlers() {
           specModule.name,
           automationSliceCallbackMake(specModule)(bodyModule)
         );
-    StreamOps.addToRegistry(handlers, entry.sourceUrn, registered);
+    // A slice can listen on several streams — its plugin's DCB log and any
+    // Aggregate EventTopic it named. Register the one handler under each, since
+    // the router dispatches by the record's own eventSourceARN. `sourceUrn` is
+    // the pre-multi-source spelling, kept as a fallback so an older handler
+    // config still routes.
+    const sourceUrns = entry.sourceUrns?.length
+      ? entry.sourceUrns
+      : entry.sourceUrn
+        ? [entry.sourceUrn]
+        : [];
+    for (const sourceUrn of sourceUrns) {
+      StreamOps.addToRegistry(handlers, sourceUrn, registered);
+    }
   }));
 
   return handlers;

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -24,6 +24,20 @@ type sliceInfo = {
   // Threaded to phase 1 collect/resolve on the automation path (mirrors the
   // in-process builder's `~context`); outbound slices take no context.
   context: option<Reventless.AutomationSlice.context>,
+  // The non-DCB topics this slice subscribes to — an Aggregate's EventTopic when
+  // it names one by `Spec.name`. Empty for the common DCB-only slice.
+  //
+  // Captured *synchronously* here for the same reason the whole `bundledInfos`
+  // path exists: `forEventCollector` runs inside a `Pulumi.Output.apply`, so
+  // `storedSpecs` — which carries the resolved topics on the dead `finish` path
+  // — is still empty when `finishWithDcbEventLog` runs. The core builders
+  // compute this dict before that apply, so the value is available in time; it
+  // just had nowhere to go until now.
+  sourceTopics: ReventlessCore.EventTopic.allOutputs,
+  // Whether this slice also reads the plugin's own DCB event log. True for every
+  // slice that declares no sources (the default) and for any that names the log
+  // explicitly, which is why it is not derivable from `sourceTopics` being empty.
+  consumesDcbLog: bool,
 }
 
 let bundledInfos: dict<sliceInfo> = Dict.make()
@@ -35,6 +49,9 @@ let setDcbQueueUrl = url => dcbQueueUrlRef := Some(url)
 // ApiFragmentRegistry push (2e) to dispatch RecordApiFragmentPush.
 let getDcbQueueUrl = () => dcbQueueUrlRef.contents
 
+// `~sourceTopics` / `~consumesDcbLog` default to the DCB-only shape every slice
+// had before aggregate sources existed, so a caller that has not been updated
+// keeps exactly its previous wiring.
 let registerAutomationSlice = (
   ~name,
   ~specModulePath,
@@ -43,10 +60,21 @@ let registerAutomationSlice = (
   ~queryDbTableName,
   ~queryDbResources=[],
   ~context=?,
+  ~sourceTopics=Dict.make(),
+  ~consumesDcbLog=true,
 ) =>
   bundledInfos->Dict.set(
     name,
-    {specModulePath, bodyModulePath, callbackType, queryDbTableName, queryDbResources, context},
+    {
+      specModulePath,
+      bodyModulePath,
+      callbackType,
+      queryDbTableName,
+      queryDbResources,
+      context,
+      sourceTopics,
+      consumesDcbLog,
+    },
   )
 
 type storedSpec = {
@@ -259,9 +287,28 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         let opts = {Pulumi.ComponentResource.parent: parent}
         let dcbOutputs: ReventlessCore.DcbEventLog.outputs =
           dcbEventLog->ReventlessCore.Component.outputs
+        // The plugin's DCB log, plus every Aggregate EventTopic any slice on this
+        // Lambda named. One channel spans them all: `connect` turns each topic
+        // into its own event-source mapping, and the entry point routes an
+        // incoming record to the handlers registered for its stream, so a slice
+        // only ever sees the sources it asked for.
+        //
+        // Keyed `<plugin>DcbEventLog`, the convention `Dcb_Builder` uses when it
+        // puts the log into `allEventTopics`. That matters because a slice naming
+        // the log explicitly (every DCB-sourced AutomationSlice does) contributes
+        // it back under that key: a different key here would leave the same topic
+        // in the dict twice, and since an event-source mapping is named after the
+        // *topic resource* rather than the key, both would render as
+        // `<plugin>DcbEventLog2AllAutomationSlices` and the deploy would fail on a
+        // duplicate URN.
+        let dcbTopicKey = dcbResource.name->Option.getOr("") ++ "DcbEventLog"
         let eventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
-          ("DcbEventLog", dcbOutputs.eventTopic),
+          (dcbTopicKey, dcbOutputs.eventTopic),
         ])
+        bundledInfos->Dict.forEach(info =>
+          info.sourceTopics->Dict.forEachWithKey((topic, key) => eventTopics->Dict.set(key, topic))
+        )
+
         let channel = EventCollectorChannel.make(
           ~name="AllAutomationSlices",
           ~eventTopics,
@@ -269,13 +316,40 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           ~opts,
         )
 
-        // One DCB stream URN, identical for every slice on this plugin log — the
-        // dispatch key the entry point maps event-source records back to.
-        let sourceUrn = switch dcbOutputs.eventTopic.resources->Array.get(0) {
+        let dcbSourceUrn = switch dcbOutputs.eventTopic.resources->Array.get(0) {
         | Some(resource) => resource.urn
         | None => Pulumi.Output.make("")
         }
 
+        // The stream URNs this one slice listens on — the dispatch keys the entry
+        // point maps event-source records back to. Per slice rather than one
+        // shared DCB URN, which is what lets an Aggregate-sourced slice exist at
+        // all: its events arrive on the Aggregate's stream and would otherwise
+        // reach a registry that has never heard of them.
+        let sourceUrnsFor = (info: sliceInfo): Pulumi.Output.t<array<string>> => {
+          let urns = []
+          if info.consumesDcbLog {
+            urns->Array.push(dcbSourceUrn)->ignore
+          }
+          info.sourceTopics
+          ->Dict.valuesToArray
+          ->Array.forEach(topic =>
+            topic.resources->Array.forEach(resource => urns->Array.push(resource.urn)->ignore)
+          )
+          // Deduped after resolution, because the same stream can be reached two
+          // ways — `consumesDcbLog` and an explicit source naming the DCB log.
+          // The entry point registers the handler once per URN, so a repeat would
+          // run the slice twice for every event: no error, no log, just doubled
+          // work and doubled commands.
+          urns
+          ->Pulumi.Output.all
+          ->Pulumi.Output.apply(resolved =>
+            resolved->Array.reduce([], (acc, urn) =>
+              acc->Array.includes(urn) ? acc : acc->Array.concat([urn])
+            )
+          )
+        }
+
         let dcbQueueUrl = switch dcbQueueUrlRef.contents {
         | Some(url) => url
         | None => Pulumi.Output.make("NOT_AVAILABLE")
@@ -307,10 +381,16 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           }
 
           let handlerJson =
-            Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, sourceUrn))
-            ->Pulumi.Output.apply(((tableName, queueUrl, urn)) =>
-              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${urn}"${contextFragment}}`
-            )
+            Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, sourceUrnsFor(info)))
+            ->Pulumi.Output.apply(((tableName, queueUrl, urns)) => {
+              let urnsJson =
+                urns->Array.map(JSON.Encode.string)->JSON.Encode.array->JSON.stringify
+              // `sourceUrn` stays beside `sourceUrns` so a handler config read by
+              // an entry point that predates multi-source still routes its first
+              // stream rather than none.
+              let firstUrn = urns->Array.get(0)->Option.getOr("")
+              `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${firstUrn}","sourceUrns":${urnsJson}${contextFragment}}`
+            })
           let _ = handlerOutputs->Array.push(handlerJson)
         })
 

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs

@@ -28,16 +28,20 @@ function getDcbQueueUrl() {
   return dcbQueueUrlRef.contents;
 }
 
-function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context) {
+function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context, sourceTopicsOpt, consumesDcbLogOpt) {
   let callbackType = callbackTypeOpt !== undefined ? callbackTypeOpt : "automation";
   let queryDbResources = queryDbResourcesOpt !== undefined ? queryDbResourcesOpt : [];
+  let sourceTopics = sourceTopicsOpt !== undefined ? sourceTopicsOpt : ({});
+  let consumesDcbLog = consumesDcbLogOpt !== undefined ? consumesDcbLogOpt : true;
   bundledInfos[name] = {
     specModulePath: specModulePath,
     bodyModulePath: bodyModulePath,
     callbackType: callbackType,
     queryDbTableName: queryDbTableName,
     queryDbResources: queryDbResources,
-    context: context
+    context: context,
+    sourceTopics: sourceTopics,
+    consumesDcbLog: consumesDcbLog
   };
 }
 
@@ -157,13 +161,35 @@ function finishWithDcbEventLog(dcbEventLog) {
         parent: opts_parent
       };
       let dcbOutputs = Component$ReventlessCore.outputs(dcbEventLog);
+      let dcbTopicKey = Stdlib_Option.getOr(dcbResource.__name, "") + "DcbEventLog";
       let eventTopics = Object.fromEntries([[
-          "DcbEventLog",
+          dcbTopicKey,
           dcbOutputs.eventTopic
         ]]);
+      Stdlib_Dict.forEach(bundledInfos, info => Stdlib_Dict.forEachWithKey(info.sourceTopics, (topic, key) => {
+        eventTopics[key] = topic;
+      }));
       let channel = EventCollectorChannel_DynamoDbStream$ReventlessAws.make("AllAutomationSlices", eventTopics, undefined, opts);
       let resource = dcbOutputs.eventTopic.resources[0];
-      let sourceUrn = resource !== undefined ? resource.urn : Pulumi.output("");
+      let dcbSourceUrn = resource !== undefined ? resource.urn : Pulumi.output("");
+      let sourceUrnsFor = info => {
+        let urns = [];
+        if (info.consumesDcbLog) {
+          urns.push(dcbSourceUrn);
+        }
+        Object.values(info.sourceTopics).forEach(topic => {
+          topic.resources.forEach(resource => {
+            urns.push(resource.urn);
+          });
+        });
+        return Pulumi.all(urns).apply(resolved => Stdlib_Array.reduce(resolved, [], (acc, urn) => {
+          if (acc.includes(urn)) {
+            return acc;
+          } else {
+            return acc.concat([urn]);
+          }
+        }));
+      };
       let url = dcbQueueUrlRef.contents;
       let dcbQueueUrl = url !== undefined ? url : Pulumi.output("NOT_AVAILABLE");
       let handlerOutputs = [];
@@ -185,8 +211,13 @@ function finishWithDcbEventLog(dcbEventLog) {
         let handlerJson = Pulumi.all([
           info.queryDbTableName,
           dcbQueueUrl,
-          sourceUrn
-        ]).apply(param => `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + param[2] + `"` + contextFragment + `}`);
+          sourceUrnsFor(info)
+        ]).apply(param => {
+          let urns = param[2];
+          let urnsJson = JSON.stringify(urns.map(prim => prim));
+          let firstUrn = Stdlib_Option.getOr(urns[0], "");
+          return `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + firstUrn + `","sourceUrns":` + urnsJson + contextFragment + `}`;
+        });
         handlerOutputs.push(handlerJson);
       });
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);

package/src/components/AutomationSlice_Builder.res

@@ -37,6 +37,17 @@ module Make = (Api: {
       let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
       let queryDbTableName = tableResource.name
 
+      // An automation names its sources through its Mappings rather than a flat
+      // list, but the runtime question is the same one the outbound builder
+      // answers: which streams must this Lambda listen on. Unlike outbound, an
+      // automation's DCB log is already a key in `allEventTopics`, so the filter
+      // picks it up and nothing extra has to be assumed.
+      let sourceTopics =
+        allEventTopics->ReventlessCore.EventTopic.filter(sourceNames->Belt.Set.String.fromArray)
+      let consumesDcbLog =
+        sourceNames->Array.length == 0 ||
+          sourceNames->Array.some(name => !(allEventTopics->Dict.has(name)))
+
       EventCollectorRuntimeBuilder.registerAutomationSlice(
         ~name=Spec.name,
         ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
@@ -45,6 +56,8 @@ module Make = (Api: {
         ~queryDbTableName,
         ~queryDbResources=queryDbOutputs.resources,
         ~context,
+        ~sourceTopics,
+        ~consumesDcbLog,
       )
 
       as_

package/src/components/AutomationSlice_Builder.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as EventTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventTopic/EventTopic.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 AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
@@ -36,19 +38,22 @@ function Make(Api) {
   })(Api);
   let Make$1 = Spec => (Automation => {
     let InnerMake = Inner.Make(Spec)(Automation);
+    let sourceNames = InnerMake.sourceNames;
     let make = (allEventTopics, publishJsons, context, runtime, opts) => {
       let as_ = InnerMake.make(allEventTopics, publishJsons, context, runtime, opts);
       let queryDbOutputs = Component$ReventlessCore.outputs(as_).queryDb;
       let tableResource = queryDbOutputs.resources[0];
       let queryDbTableName = tableResource.name;
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context);
+      let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(sourceNames));
+      let consumesDcbLog = sourceNames.length === 0 || sourceNames.some(name => !(name in allEventTopics));
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context, sourceTopics, consumesDcbLog);
       return as_;
     };
     return {
       Spec: Spec,
       Automation: Automation,
       queryDbName: InnerMake.queryDbName,
-      sourceNames: InnerMake.sourceNames,
+      sourceNames: sourceNames,
       make: make
     };
   });

package/src/components/OutboundTranslationSlice_Builder.res

@@ -45,6 +45,20 @@ module Make = (Api: {
       let tableResource = queryDbOutputs.resources->Array.getUnsafe(0)
       let queryDbTableName = tableResource.name
 
+      // Which streams this slice's Lambda must actually listen on. The core
+      // `make` above has already validated every declared name and thrown on a
+      // typo, so this only has to select — a name absent from `allEventTopics`
+      // is necessarily the plugin's own DCB log, the one source that dict does
+      // not carry.
+      let declaredSources = Spec.sourceNames
+      let sourceTopics =
+        allEventTopics->ReventlessCore.EventTopic.filter(
+          declaredSources->Belt.Set.String.fromArray,
+        )
+      let consumesDcbLog =
+        declaredSources->Array.length == 0 ||
+          declaredSources->Array.some(name => !(allEventTopics->Dict.has(name)))
+
       AutomationSliceRuntime_Builder_Single.registerAutomationSlice(
         ~name=Spec.name,
         ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
@@ -52,6 +66,8 @@ module Make = (Api: {
         ~callbackType="outbound",
         ~queryDbTableName,
         ~queryDbResources=queryDbOutputs.resources,
+        ~sourceTopics,
+        ~consumesDcbLog,
       )
 
       ots

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as EventTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventTopic/EventTopic.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 QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
@@ -49,7 +51,10 @@ function Make(Api) {
       let queryDbOutputs = Component$ReventlessCore.outputs(ots).queryDb;
       let tableResource = queryDbOutputs.resources[0];
       let queryDbTableName = tableResource.name;
-      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined);
+      let declaredSources = Spec.sourceNames;
+      let sourceTopics = EventTopic$ReventlessCore.filter(allEventTopics, Belt_SetString.fromArray(declaredSources));
+      let consumesDcbLog = declaredSources.length === 0 || declaredSources.some(name => !(name in allEventTopics));
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined, sourceTopics, consumesDcbLog);
       return ots;
     };
     return {