@reventlessdev/reventless-aws 3.0.0-alpha.235 → 3.0.0-alpha.236

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.236 (2026-07-27)
+
+### Bug Fixes
+
+* **aws:** deploy AllAutomationSlices via DCB-eventlog finalizer ([d88ff1a](https://github.com/ReventlessDev/reventless-core/commit/d88ff1aac3a67881f5653c48bfd441878e822945))
+
+
 # 3.0.0-alpha.235 (2026-07-27)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.235",
+  "version": "3.0.0-alpha.236",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -11,17 +11,17 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.25",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.61",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.61",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.185",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.106",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.49",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.81"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.186",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.50",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.81",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.29"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -695,7 +695,7 @@ module MakeWithConfig = (
     onDcbSlicesCreated: dcbEventLogUnknown => {
       let dcbEventLog = dcbEventLogUnknown->asDcbEventLog
       StateViewSliceRuntime_Builder_Single.finishWithDcbEventLog(dcbEventLog)
-      AutomationSliceRuntime_Builder_Single.finish()
+      AutomationSliceRuntime_Builder_Single.finishWithDcbEventLog(dcbEventLog)
     },
     // Heartbeat EP channel hook — extracts SQS queue URL for heartbeat Lambda handler
     // and records the calling plugin's id so the Lambda runtime can emit Connect commands

package/src/Platform.res.mjs

@@ -496,7 +496,7 @@ function MakeWithConfig(Config) {
   };
   let hooks_onDcbSlicesCreated = dcbEventLogUnknown => {
     StateViewSliceRuntime_Builder_Single$ReventlessAws.finishWithDcbEventLog(dcbEventLogUnknown);
-    AutomationSliceRuntime_Builder_Single$ReventlessAws.finish();
+    AutomationSliceRuntime_Builder_Single$ReventlessAws.finishWithDcbEventLog(dcbEventLogUnknown);
   };
   let hooks_onHeartbeatEpChannelAvailable = (remoteChannelUnknown, pluginId, heartbeatInterval) => {
     let resource = remoteChannelUnknown.resources[0];
@@ -1502,7 +1502,7 @@ function Make($star) {
   };
   let hooks_onDcbSlicesCreated = dcbEventLogUnknown => {
     StateViewSliceRuntime_Builder_Single$ReventlessAws.finishWithDcbEventLog(dcbEventLogUnknown);
-    AutomationSliceRuntime_Builder_Single$ReventlessAws.finish();
+    AutomationSliceRuntime_Builder_Single$ReventlessAws.finishWithDcbEventLog(dcbEventLogUnknown);
   };
   let hooks_onHeartbeatEpChannelAvailable = (remoteChannelUnknown, pluginId, heartbeatInterval) => {
     let resource = remoteChannelUnknown.resources[0];

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -16,6 +16,11 @@ type sliceInfo = {
   bodyModulePath: string,
   callbackType: string,
   queryDbTableName: Pulumi.Output.t<string>,
+  // The slice's TODO view table resource(s). Passed as the channel `resources`
+  // so `connect` grants the Lambda write access to sync todo rows. Captured
+  // synchronously at `registerAutomationSlice` time — the finalizer must not
+  // depend on the apply-deferred `storedSpecs` (see `finishWithDcbEventLog`).
+  queryDbResources: array<ReventlessInfra.Adapter.resource>,
   // 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>,
@@ -36,9 +41,13 @@ let registerAutomationSlice = (
   ~bodyModulePath,
   ~callbackType="automation",
   ~queryDbTableName,
+  ~queryDbResources=[],
   ~context=?,
 ) =>
-  bundledInfos->Dict.set(name, {specModulePath, bodyModulePath, callbackType, queryDbTableName, context})
+  bundledInfos->Dict.set(
+    name,
+    {specModulePath, bodyModulePath, callbackType, queryDbTableName, queryDbResources, context},
+  )
 
 type storedSpec = {
   componentName: string,
@@ -112,6 +121,13 @@ let forEventCollector: ReventlessCore.Runtime.forEventCollector<
 
 let finished = ref(false)
 
+// Legacy finalizer, kept only to satisfy `EventCollectorRuntime_Builder.T`.
+// It is gated on `storedSpecs`, which the core `AutomationSlice_Builder`
+// populates via `forEventCollector` *inside a `Pulumi.Output.apply`* — i.e.
+// asynchronously. The platform's `onDcbSlicesCreated` hook runs synchronously,
+// so at call time `storedSpecs` is still empty and no Lambda is ever built.
+// The DCB platform path uses `finishWithDcbEventLog` instead, which drives off
+// the synchronously-registered `bundledInfos`. Mirrors StateViewSlice's split.
 let finish = () =>
   if !finished.contents {
     if storedSpecs->Array.length > 0 {
@@ -216,3 +232,114 @@ let finish = () =>
     }
     finished := true
   }
+
+// The finalizer the platform actually calls (Platform.res `onDcbSlicesCreated`).
+// Mirrors `StateViewSliceRuntime_Builder_Single.finishWithDcbEventLog`: it drives
+// off the synchronously-populated `bundledInfos` (never the apply-deferred
+// `storedSpecs`) and builds a single channel from the plugin's DCB EventLog
+// stream — the sole source for automation/outbound slices, which dispatch by
+// `meta.service` inside the callback. `dcbEventLog` is passed so the parent and
+// the stream URN are available synchronously here.
+let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component) =>
+  if !finished.contents {
+    if bundledInfos->Dict.keysToArray->Array.length > 0 {
+      let dcbResource = dcbEventLog->ReventlessCore.Component.toPulumiResource
+      switch dcbResource.parent {
+      | Some(parent) =>
+        let opts = {Pulumi.ComponentResource.parent: parent}
+        let dcbOutputs: ReventlessCore.DcbEventLog.outputs =
+          dcbEventLog->ReventlessCore.Component.outputs
+        let eventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
+          ("DcbEventLog", dcbOutputs.eventTopic),
+        ])
+        let channel = EventCollectorChannel.make(
+          ~name="AllAutomationSlices",
+          ~eventTopics,
+          ~owner=None,
+          ~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) {
+        | Some(resource) => resource.urn
+        | None => Pulumi.Output.make("")
+        }
+
+        let dcbQueueUrl = switch dcbQueueUrlRef.contents {
+        | Some(url) => url
+        | None => Pulumi.Output.make("NOT_AVAILABLE")
+        }
+
+        let handlerOutputs: array<Pulumi.Output.t<string>> = []
+        let packageDirs: dict<string> = Dict.make()
+        let allQueryDbResources: array<ReventlessInfra.Adapter.resource> = []
+
+        bundledInfos->Dict.forEachWithKey((info, _name) => {
+          info.queryDbResources->Array.forEach(r => allQueryDbResources->Array.push(r)->ignore)
+          let pkg = Util_Bundle.extractPackageName(info.specModulePath)
+          packageDirs->Dict.set(pkg, Util_Bundle.resolvePackageRoot(pkg))
+          // Usually the same package as the spec, but bundle it explicitly —
+          // the entry point imports the body module by specifier too.
+          let bodyPkg = Util_Bundle.extractPackageName(info.bodyModulePath)
+          packageDirs->Dict.set(bodyPkg, Util_Bundle.resolvePackageRoot(bodyPkg))
+
+          let specModule = info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+          let bodyModule = info.bodyModulePath->JSON.stringifyAny->Option.getOr(`""`)
+          let callbackType = info.callbackType->JSON.stringifyAny->Option.getOr(`""`)
+          let contextFragment = switch info.context {
+          | Some(context) =>
+            context
+            ->JSON.stringifyAny
+            ->Option.map(json => `,"context":${json}`)
+            ->Option.getOr("")
+          | None => ""
+          }
+
+          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}}`
+            )
+          let _ = handlerOutputs->Array.push(handlerJson)
+        })
+
+        let handlerConfigOutput =
+          Pulumi.Output.all(handlerOutputs)
+          ->Pulumi.Output.apply(handlers => `{"handlers":[${handlers->Array.join(",")}]}`)
+
+        let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+        envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+
+        let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+          ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",
+          ~packageDirs,
+        )
+
+        let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+          ~name="AllAutomationSlices",
+          ~unitKind=ReventlessCore.Monitoring.Reactor,
+          ~componentKind=ReventlessCore.ComponentType.AutomationSlice,
+          ~code,
+          ~sourceCodeHash,
+          ~envVars,
+          ~memorySize=1024,
+          ~timeout=30,
+          ~opts,
+        )
+
+        let _connectResources = EventCollectorChannel.connect(
+          ~name="AllAutomationSlices",
+          ~channelSpecs=[{channel, eventTopics, resources: allQueryDbResources}],
+          ~runtime,
+          ~opts,
+        )
+      | None =>
+        log.warn(
+          ~comp="AutomationSliceRuntime_Builder_Single",
+          "finishWithDcbEventLog: DCB EventLog has no parent",
+        )
+      }
+    }
+    finished := true
+  }

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

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
@@ -26,13 +27,15 @@ function getDcbQueueUrl() {
   return dcbQueueUrlRef.contents;
 }
 
-function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, context) {
+function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, queryDbResourcesOpt, context) {
   let callbackType = callbackTypeOpt !== undefined ? callbackTypeOpt : "automation";
+  let queryDbResources = queryDbResourcesOpt !== undefined ? queryDbResourcesOpt : [];
   bundledInfos[name] = {
     specModulePath: specModulePath,
     bodyModulePath: bodyModulePath,
     callbackType: callbackType,
     queryDbTableName: queryDbTableName,
+    queryDbResources: queryDbResources,
     context: context
   };
 }
@@ -137,6 +140,68 @@ function finish() {
   finished.contents = true;
 }
 
+function finishWithDcbEventLog(dcbEventLog) {
+  if (finished.contents) {
+    return;
+  }
+  if (Object.keys(bundledInfos).length !== 0) {
+    let dcbResource = Component$ReventlessCore.toPulumiResource(dcbEventLog);
+    let parent = dcbResource.__parentResource;
+    if (parent !== undefined) {
+      let opts_parent = parent;
+      let opts = {
+        parent: opts_parent
+      };
+      let dcbOutputs = Component$ReventlessCore.outputs(dcbEventLog);
+      let eventTopics = Object.fromEntries([[
+          "DcbEventLog",
+          dcbOutputs.eventTopic
+        ]]);
+      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 url = dcbQueueUrlRef.contents;
+      let dcbQueueUrl = url !== undefined ? url : Pulumi.output("NOT_AVAILABLE");
+      let handlerOutputs = [];
+      let packageDirs = {};
+      let allQueryDbResources = [];
+      Stdlib_Dict.forEachWithKey(bundledInfos, (info, _name) => {
+        info.queryDbResources.forEach(r => {
+          allQueryDbResources.push(r);
+        });
+        let pkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+        packageDirs[pkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(pkg);
+        let bodyPkg = Util_Bundle$ReventlessAws.extractPackageName(info.bodyModulePath);
+        packageDirs[bodyPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(bodyPkg);
+        let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+        let bodyModule = Stdlib_Option.getOr(JSON.stringify(info.bodyModulePath), `""`);
+        let callbackType = Stdlib_Option.getOr(JSON.stringify(info.callbackType), `""`);
+        let context = info.context;
+        let contextFragment = context !== undefined ? Stdlib_Option.getOr(Stdlib_Option.map(JSON.stringify(context), json => `,"context":` + json), "") : "";
+        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 + `}`);
+        handlerOutputs.push(handlerJson);
+      });
+      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
+      let envVars = {};
+      envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", "AutomationSlice", match.code, match.sourceCodeHash, envVars, 1024, 30, undefined, undefined, undefined, undefined, undefined, opts);
+      EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllAutomationSlices", [{
+          channel: channel,
+          eventTopics: eventTopics,
+          resources: allQueryDbResources
+        }], runtime, opts);
+    } else {
+      log.warn("AutomationSliceRuntime_Builder_Single", undefined, "finishWithDcbEventLog: DCB EventLog has no parent");
+    }
+  }
+  finished.contents = true;
+}
+
 let EventCollectorChannel;
 
 let RuntimeEnvironment;
@@ -155,5 +220,6 @@ export {
   forEventCollector,
   finished,
   finish,
+  finishWithDcbEventLog,
 }
 /* log Not a pure module */

package/src/components/AutomationSlice_Builder.res

@@ -43,6 +43,7 @@ module Make = (Api: {
         ~bodyModulePath=Util_Bundle.getModuleSpecifier(Automation.moduleUrl),
         ~callbackType="automation",
         ~queryDbTableName,
+        ~queryDbResources=queryDbOutputs.resources,
         ~context,
       )
 

package/src/components/AutomationSlice_Builder.res.mjs

@@ -41,7 +41,7 @@ function Make(Api) {
       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, context);
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Automation.moduleUrl), "automation", queryDbTableName, queryDbOutputs.resources, context);
       return as_;
     };
     return {

package/src/components/OutboundTranslationSlice_Builder.res

@@ -51,6 +51,7 @@ module Make = (Api: {
         ~bodyModulePath=Util_Bundle.getModuleSpecifier(Translation.moduleUrl),
         ~callbackType="outbound",
         ~queryDbTableName,
+        ~queryDbResources=queryDbOutputs.resources,
       )
 
       ots

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -48,7 +48,7 @@ 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, undefined);
+      AutomationSliceRuntime_Builder_Single$ReventlessAws.registerAutomationSlice(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl), "outbound", queryDbTableName, queryDbOutputs.resources, undefined);
       return ots;
     };
     return {