@reventlessdev/reventless-aws 3.0.0-alpha.261 → 3.0.0-alpha.263

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.263 (2026-08-03)
+
+### Bug Fixes
+
+* **aws:** make the slice callback protocol one declaration, not three ([d49e543](https://github.com/ReventlessDev/reventless-core/commit/d49e543f4715c955c75cec8bd691ee0927b7e2f4))
+
+
+# 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.261",
+  "version": "3.0.0-alpha.263",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -12,17 +12,17 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.3",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.65",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.71",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.207",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.99"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.208",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.99",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.72"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -129,16 +129,21 @@ let makeSyncTodoItems = (
 // The callback shapes the shell's functor applications produce
 // (AutomationSlice_Callback.T / OutboundTranslationSlice_Callback.T), typed at
 // the seam.
-type automationCallback = {
-  todoItems: dict<ReventlessCore.AutomationSlice_Callback.todoRow>,
-  phase1: (array<JSON.t>, Reventless.AutomationSlice.context) => unit,
-  phase2: ReventlessCore.CommandTopic.publishJsons => promise<unit>,
-}
-type outboundCallback<'event> = {
-  todoItems: dict<ReventlessCore.OutboundTranslationSlice_Callback.todoRow>,
-  phase1: array<'event> => unit,
-  phase2: ReventlessCore.CommandTopic.publishJsons => promise<unit>,
-}
+// The entry point builds callbacks dynamically per HANDLER_CONFIG entry, so it
+// cannot name `AutomationSlice_Callback.T` / `OutboundTranslationSlice_Callback.T`
+// — the Spec is not known statically — and has to ascribe a structural type where
+// the value crosses from the dynamically-imported JS module into ReScript.
+//
+// These are aliases of the protocol types each callback module owns, never
+// restatements of them. That distinction is the whole point: a hand-written copy
+// is a second source of truth the compiler cannot reconcile with the first, and
+// it drifts silently. It did — when `phase1` gained its `sourceId` the copy here
+// kept saying `array<'event>`, stayed internally consistent, compiled, and then
+// destructured a bare event as a tuple at runtime, so every outbound slice on AWS
+// died reading `.TAG` of `undefined` on its first record. As aliases, the same
+// change is a compile error here instead.
+type automationCallback = ReventlessCore.AutomationSlice_Callback.runtime
+type outboundCallback<'event> = ReventlessCore.OutboundTranslationSlice_Callback.runtime<'event>
 
 // Automation: phase 1 takes the RAW envelope JSONs — the callback routes by
 // `meta.service` and unwraps `{id, meta, event}` itself — plus the context.
@@ -175,14 +180,20 @@ let makeOutboundJsonEventsHandler = (
     stream
     ->Stream.mapEffect(json =>
       Effect.sync(() => {
-        let rawEvent =
-          json
-          ->JSON.Decode.object
-          ->Option.flatMap(d => d->Dict.get("event"))
-          ->Option.getOr(json)
+        let envelope = json->JSON.Decode.object
+        let rawEvent = envelope->Option.flatMap(d => d->Dict.get("event"))->Option.getOr(json)
+        // The entity the event was published for, mirroring the in-process
+        // builder. An Aggregate's event payload does not repeat its own id, so
+        // without lifting this out of the envelope `collect` cannot name the
+        // subject of the outbound item it creates.
+        let sourceId =
+          envelope
+          ->Option.flatMap(d => d->Dict.get("id"))
+          ->Option.flatMap(JSON.Decode.string)
+          ->Option.getOr("")
         let (eventType, dataDict) = rawEvent->ReventlessCore.Message.splitMessage
         switch decoder.decode(~eventType, ~data=dataDict) {
-        | Some(event) => [event]
+        | Some(event) => [(sourceId, event)]
         | None => []
         }
       })

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

@@ -98,11 +98,16 @@ function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTo
 function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems) {
   let decoder = DcbDecode$Reventless.makeDecoder(consumedEventSchema);
   return stream => Effect.flatMap(Stream.runCollect(Stream$1.flatMap(Stream$1.mapEffect(stream, json => Effect.sync(() => {
-    let rawEvent = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["event"]), json);
+    let envelope = Stdlib_JSON.Decode.object(json);
+    let rawEvent = Stdlib_Option.getOr(Stdlib_Option.flatMap(envelope, d => d["event"]), json);
+    let sourceId = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(envelope, d => d["id"]), Stdlib_JSON.Decode.string), "");
     let match = Message$ReventlessCore.splitMessage(rawEvent);
     let event = decoder.decode(match[0], match[1]);
     if (event !== undefined) {
-      return [Primitive_option.valFromOption(event)];
+      return [[
+          sourceId,
+          Primitive_option.valFromOption(event)
+        ]];
     } else {
       return [];
     }

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -292,8 +292,18 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
         // 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))
@@ -326,7 +336,18 @@ let finishWithDcbEventLog = (dcbEventLog: ReventlessCore.DcbEventLog.component)
           ->Array.forEach(topic =>
             topic.resources->Array.forEach(resource => urns->Array.push(resource.urn)->ignore)
           )
-          urns->Pulumi.Output.all
+          // 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 {

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

@@ -161,8 +161,9 @@ 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) => {
@@ -181,7 +182,13 @@ function finishWithDcbEventLog(dcbEventLog) {
             urns.push(resource.urn);
           });
         });
-        return Pulumi.all(urns);
+        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");

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -150,16 +150,26 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
       ~publishJsons=noopPublish,
       ~syncTodoItems=async () => steps->Array.push("sync"),
     )
+    // `id` is the envelope's subject — the entity the event was published for.
+    // An Aggregate's event payload does not repeat it, so this is the only place
+    // `collect` can learn which customer/order an event belongs to.
     let placed = obj([
+      ("id", str("ord-1")),
       ("meta", obj([("service", str("Order"))])),
       ("event", obj([("TAG", str("OrderPlaced")), ("orderId", str("ord-1"))])),
     ])
     // Not consumed by this slice — dropped without an error.
     let ignored = obj([("event", obj([("TAG", str("OrderShipped")), ("orderId", str("ord-1"))]))])
-    // Bare payload-less variant, no envelope.
+    // Bare payload-less variant, no envelope and therefore no id.
     let archived = str("OrderArchived")
     await Stream.fromIterable([placed, ignored, archived])->handler->Effect.runPromise
-    expect(received.contents)->toEqual([OrderPlaced({orderId: "ord-1"}), OrderArchived])
+    // Pairs, not bare events. Asserting the bare shape is what let the AWS entry
+    // point ship a phase1 that destructured `undefined` out of a non-tuple: the
+    // test agreed with the drifted local type instead of with the callback.
+    expect(received.contents)->toEqual([
+      ("ord-1", OrderPlaced({orderId: "ord-1"})),
+      ("", OrderArchived),
+    ])
     expect(steps)->toEqual(["phase1", "sync", "phase2", "sync"])
   })
 })

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -216,6 +216,10 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       steps.push("sync");
     });
     let placed = Object.fromEntries([
+      [
+        "id",
+        "ord-1"
+      ],
       [
         "meta",
         Object.fromEntries([[
@@ -256,11 +260,17 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       "OrderArchived"
     ])));
     globalThis.expect(received.contents).toEqual([
-      {
-        TAG: "OrderPlaced",
-        orderId: "ord-1"
-      },
-      "OrderArchived"
+      [
+        "ord-1",
+        {
+          TAG: "OrderPlaced",
+          orderId: "ord-1"
+        }
+      ],
+      [
+        "",
+        "OrderArchived"
+      ]
     ]);
     globalThis.expect(steps).toEqual([
       "phase1",