@reventlessdev/reventless-core 3.0.0-alpha.207 → 3.0.0-alpha.209

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 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.209 (2026-08-03)
+
+### Bug Fixes
+
+* **aws:** give slice command publishes a queue they can actually reach ([42fdb55](https://github.com/ReventlessDev/reventless-core/commit/42fdb55b751a197d586c49e3615ce12ffea42046))
+### Features
+
+* **dcb:** route an outbound slice's command to the aggregate it targets ([897b37b](https://github.com/ReventlessDev/reventless-core/commit/897b37b46a4e856567646dfdc2f0652e81cf7388))
+
+
+# 3.0.0-alpha.208 (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.207 (2026-08-03)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.207",
+  "version": "3.0.0-alpha.209",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,13 +29,13 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.1",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.124",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.99"

package/src/admin/Platform_Admin.res.mjs

@@ -78,7 +78,7 @@ function Make(RuntimeEnvironment) {
         A.Spec.eventSchema
       ]);
       Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
-      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, aggregateProducedEvents, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
+      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, aggregateProducedEvents, undefined, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
       let slicePublishJsons = dcbResult.dcbPublishJsons;
       if (slicePublishJsons !== undefined) {
         stateChangeSlices.forEach(Sc => {

package/src/components/Aggregate/Aggregate_Builder.res

@@ -66,7 +66,17 @@ module Make = (
     }
   }
 
-  let createCommandTopic = (eventLog: SpecificEventLog.component, name, opts, ~memorySize, ~timeout) =>
+  let createCommandTopic = (eventLog: SpecificEventLog.component, name, opts, ~memorySize, ~timeout) => {
+    // Created outside the apply below, so the topic — and with it the channel's
+    // queue — exists while plugin construction is still synchronous. An outbound
+    // slice targeting this aggregate resolves its publish queue in a finalizer
+    // that runs before any Output settles; a queue created inside the apply is
+    // invisible there. Only the handler needs the event log's operations.
+    let commandTopic = SpecificCommandTopic.make(
+      ~name,
+      ~owner={kind: ComponentType.Aggregate, name: Spec.name},
+      ~opts,
+    )
     eventLog
     ->Component.operations
     ->Pulumi.Output.apply(eventLogOps => {
@@ -79,11 +89,6 @@ module Make = (
           let eventLog = eventLogOps
         },
       )
-      let commandTopic = SpecificCommandTopic.make(
-        ~name,
-        ~owner={kind: ComponentType.Aggregate, name: Spec.name},
-        ~opts,
-      )
       let handler = SpecificCommandTopic.makeHandler(
         ~commandTopic,
         ~commandsHandler=AggregateCallback.handleCommands,
@@ -98,6 +103,7 @@ module Make = (
       )
       commandTopic
     })
+  }
 
   let createCommandGenerator = (
     commandTopic: Pulumi.Output.t<SpecificCommandTopic.component>,

package/src/components/Aggregate/Aggregate_Builder.res.mjs

@@ -30,25 +30,27 @@ function Make(Spec) {
       Id: Spec.Id,
       commandSchema: Spec.commandSchema
     })(SpecificEventCollector)(EventMappings)(AggregateRuntimeBuilder);
-    let createCommandTopic = (eventLog, name, opts, memorySize, timeout) => Component$ReventlessCore.operations(eventLog).apply(eventLogOps => {
-      let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Behavior)({
-        Spec: Spec,
-        EventLog: SpecificEventLog,
-        eventLog: eventLogOps
-      });
+    let createCommandTopic = (eventLog, name, opts, memorySize, timeout) => {
       let commandTopic = SpecificCommandTopic.make(name, {
         kind: "Aggregate",
         name: Spec.name
       }, opts);
-      let handler = SpecificCommandTopic.makeHandler(commandTopic, AggregateCallback.handleCommands);
-      let eventLog$1 = Component$ReventlessCore.outputs(eventLog);
-      let resources = [
-        eventLog$1.resources,
-        eventLog$1.eventTopic.resources
-      ].flat();
-      AggregateRuntimeBuilder.forCommandTopic(handler, none => SpecificCommandTopic.connect(none, resources, commandTopic), memorySize, timeout, commandTopic);
-      return commandTopic;
-    });
+      return Component$ReventlessCore.operations(eventLog).apply(eventLogOps => {
+        let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Behavior)({
+          Spec: Spec,
+          EventLog: SpecificEventLog,
+          eventLog: eventLogOps
+        });
+        let handler = SpecificCommandTopic.makeHandler(commandTopic, AggregateCallback.handleCommands);
+        let eventLog$1 = Component$ReventlessCore.outputs(eventLog);
+        let resources = [
+          eventLog$1.resources,
+          eventLog$1.eventTopic.resources
+        ].flat();
+        AggregateRuntimeBuilder.forCommandTopic(handler, none => SpecificCommandTopic.connect(none, resources, commandTopic), memorySize, timeout, commandTopic);
+        return commandTopic;
+      });
+    };
     let createCommandGenerator = (commandTopic, api, name, opts, memorySize, timeout) => Output$Pulumi.flatMap(commandTopic, commandTopic => Component$ReventlessCore.operations(commandTopic).apply(param => {
       let publishJsonsAndWait = param.publishJsonsAndWait;
       let publishJsons = param.publishJsons;

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -31,6 +31,30 @@ type todoRow = {
   retryCount: int,
 }
 
+/**
+The runtime protocol between a built callback and whoever drives it — the same
+arrangement as `OutboundTranslationSlice_Callback`, and for the same reason. The
+AWS entry point builds callbacks dynamically and has to ascribe a structural type
+at the JS boundary; pointing that ascription at these aliases is what keeps it
+from becoming an unreconcilable second declaration of the shape.
+
+Unlike outbound, phase 1 here takes *raw* envelope JSONs: the callback routes by
+`meta.service` and unwraps `{id, meta, event}` itself, per-source, through the
+registered Mappings.
+*/
+type phase1 = (array<JSON.t>, Reventless.AutomationSlice.context) => unit
+
+/** Phase 2: process all pending items, publishing commands. */
+type phase2 = ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+
+/** The whole protocol as a value, for a driver that holds a built callback and
+    knows nothing of the Spec behind it. */
+type runtime = {
+  todoItems: Dict.t<todoRow>,
+  phase1: phase1,
+  phase2: phase2,
+}
+
 module type T = {
   module Spec: Reventless.AutomationSlice.Spec
   module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
@@ -40,10 +64,10 @@ module type T = {
 
   /** Phase 1: update TODO list from a batch of raw event JSONs. Internally
       decodes per-source via the registered Mappings. */
-  let phase1: (array<JSON.t>, Reventless.AutomationSlice.context) => unit
+  let phase1: phase1
 
   /** Phase 2: process all pending items, publishing commands via publishJsons. */
-  let phase2: ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+  let phase2: phase2
 }
 
 module Make = (

package/src/components/Dcb/Dcb_Builder.res

@@ -94,6 +94,17 @@ module Make = (
     // also drives DCB GSI creation: an aggregate's events live on its own
     // EventLog and must not mint indexes on the DCB table.
     ~aggregateProducedEvents: array<(string, S.t<unknown>)>=[],
+    // Per-aggregate command publishers, keyed by Aggregate `Spec.name`. An
+    // OutboundTranslationSlice naming one in `targetName` publishes its command
+    // through that aggregate's CommandTopic instead of this plugin's DCB topic —
+    // the two are handled by different Lambdas, so sending an aggregate command
+    // to the DCB queue delivers it somewhere nothing handles it.
+    //
+    // Populated before this runs (`createAggregatesWithoutEventMappers`), so the
+    // publisher is in hand by the time a slice is built. DCB StateChangeSlice
+    // publishers are registered *after* and are deliberately absent: a slice
+    // targeting one wants the DCB topic, which is the fallback.
+    ~publishToAggregates: dict<Pulumi.Output.t<CommandTopic.publishJsons>>=Dict.make(),
     ~stateChangeSlices: array<module(StateChangeSlice.T)>,
     ~stateViewSlices: array<module(StateViewSlice.T)>,
     ~automationSlices: array<module(AutomationSlice.T)>,
@@ -629,12 +640,21 @@ module Make = (
         let outboundTranslationSlicesOutputs =
           outboundTranslationSlices
           ->Array.map((module(OTS: OutboundTranslationSlice.T)) => {
+            // Where this slice's inbound command goes. `targetName` naming an
+            // Aggregate routes to that aggregate's CommandTopic; anything else —
+            // a DCB slice, or no target at all — keeps the plugin's DCB topic,
+            // which is what every slice wanted before aggregates were reachable.
+            let targetPublishJsons =
+              OTS.Spec.targetName
+              ->Option.flatMap(target => publishToAggregates->Dict.get(target))
+              ->Option.getOr(publishJsons)
+
             let ots = OTS.make(
               ~dcbEventLog,
               // Same dict the AutomationSlices get, so an outbound slice can
               // name an Aggregate source by its Spec.name.
               ~allEventTopics,
-              ~publishJsons,
+              ~publishJsons=targetPublishJsons,
               ~runtime=?componentRuntime->Dict.get(OTS.Spec.name),
               ~opts,
             )

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -83,13 +83,14 @@ let emptyResult = {
 
 function Make(DcbEventLogStorage) {
   return DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (RuntimeBuilder => (HooksConfig => {
-    let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, aggregateProducedEventsOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
+    let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, aggregateProducedEventsOpt, publishToAggregatesOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
       let apiNamePrefix = apiNamePrefixOpt !== undefined ? apiNamePrefixOpt : name;
       let onAdminApi = onAdminApiOpt !== undefined ? onAdminApiOpt : false;
       let environment = environmentOpt !== undefined ? environmentOpt : "";
       let platformName = platformNameOpt !== undefined ? platformNameOpt : "";
       let aggregateEventTopics = aggregateEventTopicsOpt !== undefined ? aggregateEventTopicsOpt : ({});
       let aggregateProducedEvents = aggregateProducedEventsOpt !== undefined ? aggregateProducedEventsOpt : [];
+      let publishToAggregates = publishToAggregatesOpt !== undefined ? publishToAggregatesOpt : ({});
       let systemCallableComponents = systemCallableComponentsOpt !== undefined ? systemCallableComponentsOpt : [];
       let componentRuntime = componentRuntimeOpt !== undefined ? componentRuntimeOpt : ({});
       let hasDcb = stateChangeSlices.length !== 0;
@@ -330,7 +331,8 @@ function Make(DcbEventLogStorage) {
         ];
       }));
       let outboundTranslationSlicesOutputs = Object.fromEntries(outboundTranslationSlices.map(OTS => {
-        let ots = OTS.make(dcbEventLog, allEventTopics, publishJsons, componentRuntime[OTS.Spec.name], opts);
+        let targetPublishJsons = Stdlib_Option.getOr(Stdlib_Option.flatMap(OTS.Spec.targetName, target => publishToAggregates[target]), publishJsons);
+        let ots = OTS.make(dcbEventLog, allEventTopics, targetPublishJsons, componentRuntime[OTS.Spec.name], opts);
         return [
           OTS.Spec.name,
           Component$ReventlessCore.outputs(ots)

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -22,6 +22,34 @@ type todoRow = {
   lastError?: string,
 }
 
+/**
+The runtime protocol between a built callback and whoever drives it.
+
+Defined here, once, and referenced by every party — `module type T` below, the
+in-process builder, and the AWS entry point, which cannot name `T` because it
+builds callbacks dynamically per `HANDLER_CONFIG` entry and must ascribe a
+structural type at the JS boundary.
+
+That ascription is the reason these aliases exist. A driver that restates the
+shape instead of referencing it becomes a second source of truth that the
+compiler cannot reconcile with this one: when `phase1` gained its `sourceId`,
+the AWS entry point kept passing bare events and nothing complained, because its
+hand-written copy was internally consistent. The mismatch surfaced only at
+runtime, as `undefined` destructured from a tuple that was never a tuple.
+*/
+type phase1<'event> = array<(string, 'event)> => unit
+
+/** Phase 2: translate all pending items, optionally publishing commands. */
+type phase2 = ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+
+/** The whole protocol as a value — what a driver holding a built callback needs,
+    with no knowledge of the Spec it was built from. */
+type runtime<'event> = {
+  todoItems: Dict.t<todoRow>,
+  phase1: phase1<'event>,
+  phase2: phase2,
+}
+
 module type T = {
   module Spec: Reventless.OutboundTranslationSlice.Spec
   module Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec
@@ -32,10 +60,10 @@ module type T = {
   /** Phase 1: update TODO list from a batch of `(sourceId, event)` pairs
       (collect only, no resolve). `sourceId` is the envelope id of the entity the
       event was published for. */
-  let phase1: array<(string, Spec.consumedEvent)> => unit
+  let phase1: phase1<Spec.consumedEvent>
 
   /** Phase 2: translate all pending items, optionally publishing commands via publishJsons. */
-  let phase2: ReventlessInfra.CommandTopic.publishJsons => promise<unit>
+  let phase2: phase2
 }
 
 module Make = (

package/src/plugin/component/Plugin_Builder.res

@@ -168,6 +168,9 @@ module Make = (
       ~platformName=Spec.platformName,
       ~aggregateEventTopics,
       ~aggregateProducedEvents,
+      // Carries the aggregate publishers registered just above, so an outbound
+      // slice can route its command to the aggregate it names.
+      ~publishToAggregates,
       ~stateChangeSlices,
       ~stateViewSlices,
       ~automationSlices,

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -156,7 +156,7 @@ function Make(Spec) {
         let DcbBuilder = Dcb_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher)(DcbCommandTopicChannel)(DcbCommandTopicChannelAsync)(PluginRuntimeBuilder)({
           hooks: Spec.hooks
         });
-        let dcbResult = DcbBuilder.construct(extra$1, childName, undefined, undefined, Spec.environment, Spec.platformName, aggregateEventTopics, aggregateProducedEvents, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponents, componentRuntime, pluginStructure, opts);
+        let dcbResult = DcbBuilder.construct(extra$1, childName, undefined, undefined, Spec.environment, Spec.platformName, aggregateEventTopics, aggregateProducedEvents, Plugin_Helpers$ReventlessCore.publishToAggregates, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponents, componentRuntime, pluginStructure, opts);
         let mutationEntriesFromAggregates = aggregates.flatMap(M => {
           let commandSchema = M.Spec.commandSchema;
           if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {