@reventlessdev/reventless-core 3.0.0-alpha.290 → 3.0.0-alpha.292

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 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.292 (2026-10-10)
+
+### Bug Fixes
+
+* an inbound translation is gated alike on every door, and encodes its commands by schema ([6ec3ce6](https://github.com/ReventlessDev/reventless-core/commit/6ec3ce672e53e2c162c64a90d103be691391be5e))
+### Features
+
+* **gwt:** automation and translation tests take the slice as written, and the sidecars read them ([93a0919](https://github.com/ReventlessDev/reventless-core/commit/93a0919a0d66730cf9bf89144ad8fba3cb025332))
+
+
+# 3.0.0-alpha.291 (2026-10-08)
+
+**Note:** Version bump only for package @reventlessdev/reventless-core
+
+
+
+
+
 # 3.0.0-alpha.290 (2026-10-08)
 
 **Note:** Version bump only for package @reventlessdev/reventless-core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.290",
+  "version": "3.0.0-alpha.292",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.22",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.21",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.21",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.22",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.189",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.39",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.187",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.159"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.161",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.23"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -166,50 +166,33 @@ module Make = (
       None
     }
 
-  // Per-source erased dispatch — pre-compile decoders once at module init.
-  type dispatch = {
-    sourceName: string,
-    handle: (JSON.t, ~sourceId: string, Reventless.AutomationSlice.context) => unit,
-  }
+  module Route = AutomationSlice_Route.Make(Spec, Automation)
 
-  let dispatches: array<
-    dispatch,
-  > = Automation.mappings->Array.map((module(M: Automation.Mapping)) => {
-    let decoder = Reventless.DcbDecode.makeDecoder(M.sourceEventSchema)
-    let handle = (json: JSON.t, ~sourceId: string, ctx: Reventless.AutomationSlice.context) => {
-      let (eventType, dataDict) = json->Message.splitMessage
-      switch decoder.decode(~eventType, ~data=dataDict) {
-      | Some(event) =>
-        // Collect — append new items keyed by ID; first writer wins (idempotent).
-        M.collect(event, ~sourceId, ctx)->Array.forEach(((id, item)) => {
-          switch todoItems->Dict.get(id) {
-          | Some(_) => () // Already exists — skip
-          | None =>
-            let row: todoRow = {
-              item: item->Reventless.Util_Sury.toJson(Spec.todoItemSchema),
-              status: Pending,
-              createdAt: now(),
-              retryCount: 0,
-              maxRetries: Spec.maxRetries,
-            }
-            todoItems->Dict.set(id, row)
-          }
-        })
-        // Resolve — mark a pending item as completed.
-        switch M.resolve(event) {
-        | Some(id) =>
-          todoItems
-          ->Dict.get(id)
-          ->Option.forEach(row => {
-            todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
-          })
-        | None => ()
+  let apply = ({collected, resolved}: AutomationSlice_Route.routed<Spec.todoItem>) => {
+    // Collect — append new items keyed by ID; first writer wins (idempotent).
+    collected->Array.forEach(((id, item)) => {
+      switch todoItems->Dict.get(id) {
+      | Some(_) => () // Already exists — skip
+      | None =>
+        let row: todoRow = {
+          item: item->Reventless.Util_Sury.toJson(Spec.todoItemSchema),
+          status: Pending,
+          createdAt: now(),
+          retryCount: 0,
+          maxRetries: Spec.maxRetries,
         }
-      | None => ()
+        todoItems->Dict.set(id, row)
       }
-    }
-    {sourceName: M.sourceName, handle}
-  })
+    })
+    // Resolve — mark a pending item as completed.
+    resolved->Option.forEach(id =>
+      todoItems
+      ->Dict.get(id)
+      ->Option.forEach(row => {
+        todoItems->Dict.set(id, {...row, status: Completed, completedAt: now()})
+      })
+    )
+  }
 
   let phase1 = (events: array<JSON.t>, ctx: Reventless.AutomationSlice.context) => {
     events->Array.forEach(json => {
@@ -223,11 +206,7 @@ module Make = (
       | None => json
       }
       // Multiple mappings can share a sourceName; all matching dispatches run.
-      dispatches->Array.forEach(d => {
-        if d.sourceName == sourceName {
-          d.handle(eventPayload, ~sourceId=context.id, ctx)
-        }
-      })
+      Route.route(eventPayload, ~sourceName, ~sourceId=context.id, ctx)->Array.forEach(apply)
     })
   }
 

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -8,11 +8,11 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
-import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as AutomationSlice_Route$ReventlessCore from "./AutomationSlice_Route.res.mjs";
 
 let todoStatusSchema = Sury.union([
   Sury.literal("Pending"),
@@ -55,59 +55,40 @@ function Make(Spec) {
       newrecord.status = retryCount >= Spec.maxRetries ? "Abandoned" : "Failed";
       return newrecord;
     };
-    let dispatches = Automation.mappings.map(M => {
-      let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
-      let handle = (json, sourceId, ctx) => {
-        let match = Message$ReventlessCore.splitMessage(json);
-        let event = decoder.decode(match[0], match[1]);
-        if (event === undefined) {
+    let Route = AutomationSlice_Route$ReventlessCore.Make(Spec)(Automation);
+    let apply = param => {
+      param.collected.forEach(param => {
+        let id = param[0];
+        let match = todoItems[id];
+        if (match !== undefined) {
           return;
         }
-        let event$1 = Primitive_option.valFromOption(event);
-        M.collect(event$1, sourceId, ctx).forEach(param => {
-          let id = param[0];
-          let match = todoItems[id];
-          if (match !== undefined) {
-            return;
-          }
-          let row_item = Util_Sury$Reventless.toJson(param[1], Spec.todoItemSchema);
-          let row_createdAt = new Date().toISOString();
-          let row_maxRetries = Spec.maxRetries;
-          let row = {
-            item: row_item,
-            status: "Pending",
-            createdAt: row_createdAt,
-            retryCount: 0,
-            maxRetries: row_maxRetries
-          };
-          todoItems[id] = row;
-        });
-        let id = M.resolve(event$1);
-        if (id !== undefined) {
-          return Stdlib_Option.forEach(todoItems[id], row => {
-            let newrecord = {...row};
-            newrecord.completedAt = new Date().toISOString();
-            newrecord.status = "Completed";
-            todoItems[id] = newrecord;
-          });
-        }
-      };
-      return {
-        sourceName: M.sourceName,
-        handle: handle
-      };
-    });
+        let row_item = Util_Sury$Reventless.toJson(param[1], Spec.todoItemSchema);
+        let row_createdAt = new Date().toISOString();
+        let row_maxRetries = Spec.maxRetries;
+        let row = {
+          item: row_item,
+          status: "Pending",
+          createdAt: row_createdAt,
+          retryCount: 0,
+          maxRetries: row_maxRetries
+        };
+        todoItems[id] = row;
+      });
+      Stdlib_Option.forEach(param.resolved, id => Stdlib_Option.forEach(todoItems[id], row => {
+        let newrecord = {...row};
+        newrecord.completedAt = new Date().toISOString();
+        newrecord.status = "Completed";
+        todoItems[id] = newrecord;
+      }));
+    };
     let phase1 = (events, ctx) => {
       events.forEach(json => {
         let context = Message$ReventlessCore.decode(json, Message$Reventless.contextSchema);
         let sourceName = context.meta.service;
         let dict = Stdlib_JSON.Decode.object(json);
         let eventPayload = dict !== undefined ? Stdlib_Option.getOr(dict["event"], json) : json;
-        dispatches.forEach(d => {
-          if (d.sourceName === sourceName) {
-            return d.handle(eventPayload, context.id, ctx);
-          }
-        });
+        Route.route(eventPayload, sourceName, context.id, ctx).forEach(apply);
       });
     };
     let phase2 = async publishJsons => {

package/src/components/AutomationSlice/AutomationSlice_Route.res

@@ -0,0 +1,50 @@
+// Decode one source event and run its mappings' `collect`/`resolve`, with no
+// side effects. Shared by the runtime callback, which applies the result to its
+// to-do list, and by the GWT sweep, which must route exactly as the runtime does.
+
+/** What one mapping made of one event. */
+type routed<'item> = {
+  collected: array<(string, 'item)>,
+  resolved: option<string>,
+}
+
+module Make = (
+  Spec: Reventless.AutomationSlice.Spec,
+  Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+) => {
+  type dispatch = {
+    sourceName: string,
+    handle: (
+      JSON.t,
+      ~sourceId: string,
+      Reventless.AutomationSlice.context,
+    ) => option<routed<Spec.todoItem>>,
+  }
+
+  // Decoders are compiled once, per mapping.
+  let dispatches: array<
+    dispatch,
+  > = Automation.mappings->Array.map((module(M: Automation.Mapping)) => {
+    let decoder = Reventless.DcbDecode.makeDecoder(M.sourceEventSchema)
+    let handle = (json: JSON.t, ~sourceId: string, ctx: Reventless.AutomationSlice.context) => {
+      let (eventType, dataDict) = json->Message.splitMessage
+      decoder.decode(~eventType, ~data=dataDict)->Option.map(event => {
+        collected: M.collect(event, ~sourceId, ctx),
+        resolved: M.resolve(event),
+      })
+    }
+    {sourceName: M.sourceName, handle}
+  })
+
+  /** Every mapping registered for `sourceName` that understood the payload, in
+      registration order. `payload` is the inner event, not the envelope. */
+  let route = (
+    payload: JSON.t,
+    ~sourceName: string,
+    ~sourceId: string,
+    ctx: Reventless.AutomationSlice.context,
+  ): array<routed<Spec.todoItem>> =>
+    dispatches->Array.filterMap(d =>
+      d.sourceName == sourceName ? d.handle(payload, ~sourceId, ctx) : None
+    )
+}

package/src/components/AutomationSlice/AutomationSlice_Route.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+
+function Make(Spec) {
+  return Automation => {
+    let dispatches = Automation.mappings.map(M => {
+      let decoder = DcbDecode$Reventless.makeDecoder(M.sourceEventSchema);
+      let handle = (json, sourceId, ctx) => {
+        let match = Message$ReventlessCore.splitMessage(json);
+        return Stdlib_Option.map(decoder.decode(match[0], match[1]), event => ({
+          collected: M.collect(event, sourceId, ctx),
+          resolved: M.resolve(event)
+        }));
+      };
+      return {
+        sourceName: M.sourceName,
+        handle: handle
+      };
+    });
+    let route = (payload, sourceName, sourceId, ctx) => Stdlib_Array.filterMap(dispatches, d => {
+      if (d.sourceName === sourceName) {
+        return d.handle(payload, sourceId, ctx);
+      }
+    });
+    return {
+      dispatches: dispatches,
+      route: route
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* DcbDecode-Reventless Not a pure module */

package/src/components/Dcb/Dcb_Builder.res

@@ -89,6 +89,16 @@ let emptyResult: dcbResult = {
   eventLogEntries: [],
 }
 
+// An inbound slice's door rule, read off its spec.
+let inboundDoorPermission = (
+  commandSchema: S.t<'command>,
+  commandAuthorization: 'command => Reventless.Authorization.rule<'role>,
+) =>
+  Plugin_Structure.inboundDoorPermission(
+    ~commandSchema=commandSchema->S.castToUnknown,
+    ~commandAuthorization=cmd => cmd->commandAuthorization->Reventless.Authorization.named,
+  )
+
 module Make = (
   DcbEventLogStorage: DcbEventLog_Adapter.Storage,
   DcbEventTopicPublisher: EventTopic_Adapter.Publisher,
@@ -749,6 +759,10 @@ module Make = (
             registerResolver(
               ~fieldName,
               ~externalInputSchema=ITS.Spec.externalInputSchema->S.castToUnknown,
+              ~permission=?inboundDoorPermission(
+                ITS.Spec.commandSchema,
+                ITS.Spec.commandAuthorization,
+              ),
             )
           | None => ()
           }
@@ -865,16 +879,14 @@ module Make = (
             let raw: dict<JSON.t> = event->Obj.magic
             switch raw->Dict.get("__inboundTranslation") {
             | Some(_) =>
-              let fieldName =
-                raw
-                ->Dict.get("fieldName")
-                ->Option.flatMap(JSON.Decode.string)
-                ->Option.getOr("")
-              let args = raw->Dict.get("arguments")->Option.getOr(JSON.Encode.null)
-              switch receivers->Dict.get(fieldName) {
+              let invocation: InboundTranslationSlice_Callback.doorInvocation = event->Obj.magic
+              switch receivers->Dict.get(invocation.fieldName) {
               | Some(receiveFn) =>
                 Effect.promise(async () => {
-                  let result = await receiveFn(args)
+                  let result = await receiveFn(
+                    invocation.arguments,
+                    ~caller=InboundTranslationSlice_Callback.doorCaller(invocation.identity),
+                  )
                   let response =
                     result
                     ->InboundTranslationSlice_Callback.receiveResultToOutcome
@@ -1034,33 +1046,9 @@ module Make = (
         })
       }
 
-      // DCB-specific API schema entries
-      //
-      // Stage E2: a DCB StateChangeSlice has a single GraphQL field but its
-      // command type may declare multiple constructors with different
-      // authorization rules. The Cognito group directive operates at field
-      // granularity, so we read the auth for the first constructor (matching
-      // the existing dcbTags convention at line 549 above). When all
-      // constructors share the file-level default, this is exact; when they
-      // differ, resolver-level enforcement still fires inside the per-slice
-      // handler (the file-level rule applied here is the least-restrictive
-      // bound).
-      let permissionForFirstConstructor = (
-        ~commandSchema: S.t<unknown>,
-        ~commandAuthorization: unknown => Reventless.Authorization.permission,
-      ): option<Reventless.Authorization.permission> => {
-        let names = Reventless.DcbTag.extractAllVariantNames(commandSchema->Obj.magic)
-        switch names->Array.get(0) {
-        | None => None
-        | Some(first) =>
-          let hasPayload = Reventless.DcbTag.isVariantPayloadBearing(
-            commandSchema->Obj.magic,
-            first,
-          )
-          let syntheticCmd: unknown = hasPayload ? {"TAG": first}->Obj.magic : first->Obj.magic
-          Some(commandAuthorization(syntheticCmd))
-        }
-      }
+      // DCB-specific API schema entries. A state change slice has one field per
+      // constructor, each gated by its own rule; an inbound slice has one field,
+      // gated by `inboundDoorPermission`, and checks each command in `receive`.
       let mutationEntriesFromSlices =
         stateChangeSlices->Array.filterMap((module(S: StateChangeSlice.T)) => {
           let commandSchema = S.Spec.commandSchema->Reventless.DcbTag.toUnknownSchema
@@ -1108,14 +1096,10 @@ module Make = (
         inboundTranslationSlices->Array.map((module(ITS: InboundTranslationSlice.T)) => {
           let fieldName = Api_Naming.sliceMutationField(~plugin=name, ~slice=ITS.Spec.name)
           let fieldPermissions = Dict.make()
-          switch permissionForFirstConstructor(
-            ~commandSchema=ITS.Spec.commandSchema->Reventless.DcbTag.toUnknownSchema,
-            ~commandAuthorization=command =>
-              ITS.Spec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named,
-          ) {
-          | Some(rule) => fieldPermissions->Dict.set(fieldName, rule)
-          | None => ()
-          }
+          inboundDoorPermission(
+            ITS.Spec.commandSchema,
+            ITS.Spec.commandAuthorization,
+          )->Option.forEach(rule => fieldPermissions->Dict.set(fieldName, rule))
           {
             ReventlessInfra.Api.fieldNames: [fieldName],
             commandSchema: ITS.Spec.externalInputSchema->S.castToUnknown,

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

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
@@ -119,6 +118,10 @@ let emptyResult = {
   eventLogEntries: emptyResult_eventLogEntries
 };
 
+function inboundDoorPermission(commandSchema, commandAuthorization) {
+  return Plugin_Structure$ReventlessCore.inboundDoorPermission(commandSchema, cmd => Authorization$Reventless.named(commandAuthorization(cmd)));
+}
+
 function Make(DcbEventLogStorage) {
   return DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (RuntimeBuilder => (HooksConfig => {
     let construct = (name, childName, apiNamePrefixOpt, onAdminApiOpt, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, aggregateProducedEventsOpt, publishToAggregatesOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, systemCallableComponentsOpt, componentRuntimeOpt, pluginStructure, opts) => {
@@ -394,7 +397,7 @@ function Make(DcbEventLogStorage) {
         let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, ITS.Spec.name);
         let registerResolver = HooksConfig.hooks.inboundMutationResolverHook;
         if (registerResolver !== undefined) {
-          registerResolver(fieldName, ITS.Spec.externalInputSchema);
+          registerResolver(fieldName, ITS.Spec.externalInputSchema, inboundDoorPermission(ITS.Spec.commandSchema, ITS.Spec.commandAuthorization));
         }
         let bindReceive = HooksConfig.hooks.inboundMutationBindReceiveHook;
         if (bindReceive !== undefined) {
@@ -464,12 +467,10 @@ function Make(DcbEventLogStorage) {
         return (event, ctx) => {
           let match = event["__inboundTranslation"];
           if (match !== undefined) {
-            let fieldName = Stdlib_Option.getOr(Stdlib_Option.flatMap(event["fieldName"], Stdlib_JSON.Decode.string), "");
-            let args = Stdlib_Option.getOr(event["arguments"], null);
-            let receiveFn = receivers[fieldName];
+            let receiveFn = receivers[event.fieldName];
             if (receiveFn !== undefined) {
               return Effect.promise(async () => {
-                let result = await receiveFn(args);
+                let result = await receiveFn(event.arguments, InboundTranslationSlice_Callback$ReventlessCore.doorCaller(event.identity));
                 return CommandTopic$ReventlessCore.commandOutcomeToJson(InboundTranslationSlice_Callback$ReventlessCore.receiveResultToOutcome(result));
               });
             } else {
@@ -544,18 +545,6 @@ function Make(DcbEventLogStorage) {
           RuntimeBuilder.forDcbCommandTopic(asyncDcbHandler, asyncDcbConnectFn, sliceMemoryFloor(asyncSlices), sliceTimeoutFloor(asyncSlices), asyncDcbCommandTopic);
         });
       };
-      let permissionForFirstConstructor = (commandSchema, commandAuthorization) => {
-        let names = DcbTag$Reventless.extractAllVariantNames(commandSchema);
-        let first = names[0];
-        if (first === undefined) {
-          return;
-        }
-        let hasPayload = DcbTag$Reventless.isVariantPayloadBearing(commandSchema, first);
-        let syntheticCmd = hasPayload ? ({
-            TAG: first
-          }) : first;
-        return commandAuthorization(syntheticCmd);
-      };
       let mutationEntriesFromSlices = Stdlib_Array.filterMap(stateChangeSlices, S => {
         let commandSchema = S.Spec.commandSchema;
         let fieldSpecs = Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema);
@@ -585,10 +574,9 @@ function Make(DcbEventLogStorage) {
       let mutationEntriesFromInboundSlices = inboundTranslationSlices.map(ITS => {
         let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, ITS.Spec.name);
         let fieldPermissions = {};
-        let rule = permissionForFirstConstructor(ITS.Spec.commandSchema, command => Authorization$Reventless.named(ITS.Spec.commandAuthorization(command)));
-        if (rule !== undefined) {
+        Stdlib_Option.forEach(inboundDoorPermission(ITS.Spec.commandSchema, ITS.Spec.commandAuthorization), rule => {
           fieldPermissions[fieldName] = rule;
-        }
+        });
         return {
           fieldNames: [fieldName],
           commandSchema: ITS.Spec.externalInputSchema,
@@ -691,6 +679,7 @@ export {
   variantTag,
   mergedEventSchema,
   emptyResult,
+  inboundDoorPermission,
   Make,
 }
 /* log Not a pure module */

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res

@@ -81,8 +81,8 @@ module Make = (
         ->Pulumi.Output.all2
         ->Pulumi.Output.apply(((queryDbOps, publishJsonsFn)) => {
           let ops: InboundTranslationSlice.operations = {
-            receive: async inputJson => {
-              let result = await Callback.receive(publishJsonsFn, inputJson)
+            receive: async (inputJson, ~caller=?) => {
+              let result = await Callback.receive(publishJsonsFn, inputJson, ~caller?)
               await syncToQueryDb(queryDbOps, result->InboundTranslationSlice_Callback.requestIdOf)
               result
             },

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res.mjs

@@ -55,8 +55,8 @@ function Make(QueryDbStorage) {
           let publishJsonsFn = param[1];
           let queryDbOps = param[0];
           return {
-            receive: async inputJson => {
-              let result = await Callback.receive(publishJsonsFn, inputJson);
+            receive: async (inputJson, caller) => {
+              let result = await Callback.receive(publishJsonsFn, inputJson, caller);
               await syncToQueryDb(queryDbOps, InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result));
               return result;
             }