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

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.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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.262",
+  "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-effect": "0.1.0-alpha.32",
     "@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-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.207",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.208",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.71",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.99"
+    "@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/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",