@reventlessdev/reventless-core 3.0.0-alpha.291 → 3.0.0-alpha.293

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.293 (2026-10-10)
+
+* feat!: a command's rule is looked up by its name, without a cast ([5f02c40](https://github.com/ReventlessDev/reventless-core/commit/5f02c4081d077bf4a6951d8c9b2b16553a8ca87b))
+
+### BREAKING CHANGES
+
+* a spec that writes `commandAuthorization` by hand writes
+`authorizationOf = (name: string) => …` instead; the PPX refuses the old name.
+
+
+
+# 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.291",
+  "version": "3.0.0-alpha.293",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "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-jest": "1.0.0-alpha.11",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.22",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.23",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.188",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.39",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.160"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.162",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.190"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.98"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.99"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/admin/Platform_Admin_Structure.res

@@ -37,8 +37,7 @@ let pluginCommands: array<commandDef> = Plugin_Structure.extractCommandDefs(
   ~isAggregate=true,
   ~mutationFieldFor=variantName =>
     Api_Naming.adminField(~name=PluginSpec.name ++ "_" ++ variantName),
-  ~commandAuthorization=command =>
-    PluginSpec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named,
+  ~authorizationOf=name => PluginSpec.authorizationOf(name)->Reventless.Authorization.named,
   ~commandTransition=PluginSpec.commandTransition->Obj.magic,
   commandSchema,
 )

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -8,7 +8,7 @@ import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/Plugin
 
 let pluginId = "Platform";
 
-let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(undefined, true, undefined, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), command => Authorization$Reventless.named(PluginSpec$ReventlessCore.commandAuthorization(command)), PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
+let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(undefined, true, undefined, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), name => Authorization$Reventless.named(PluginSpec$ReventlessCore.authorizationOf(name)), PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
 
 let pluginAggregate_producedEventTypes = [];
 

package/src/admin/UiFragmentRegistry/StateChange/UiFragmentRegistry.res.mjs

@@ -42,7 +42,7 @@ let eventSchema = Sury.union([
 
 let commandSchema$1 = Api$ReventlessInfra.markNoApi(commandSchema);
 
-function commandAuthorization(param) {
+function authorizationOf(param) {
   return "AllowAuthenticated";
 }
 
@@ -70,7 +70,7 @@ export {
   consumedEventSchema,
   commandSchema$1 as commandSchema,
   moduleUrl,
-  commandAuthorization,
+  authorizationOf,
   readConsistency,
   commandTransition,
   traits,

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>,
+  authorizationOf: string => Reventless.Authorization.rule<'role>,
+) =>
+  Plugin_Structure.inboundDoorPermission(
+    ~commandSchema=commandSchema->S.castToUnknown,
+    ~authorizationOf=name => name->authorizationOf->Reventless.Authorization.named,
+  )
+
 module Make = (
   DcbEventLogStorage: DcbEventLog_Adapter.Storage,
   DcbEventTopicPublisher: EventTopic_Adapter.Publisher,
@@ -534,8 +544,7 @@ module Make = (
                 ~commandSchema,
               )->Array.map(((f, _)) => f),
               ~commandSchema,
-              ~commandAuthorization=command =>
-                S.Spec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named,
+              ~authorizationOf=name => S.Spec.authorizationOf(name)->Reventless.Authorization.named,
             )
           }
         })
@@ -550,8 +559,7 @@ module Make = (
                 ~commandSchema,
               )->Array.map(((f, _)) => f),
               ~commandSchema,
-              ~commandAuthorization=command =>
-                S.Spec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named,
+              ~authorizationOf=name => S.Spec.authorizationOf(name)->Reventless.Authorization.named,
             )
           }
         })
@@ -749,6 +757,7 @@ module Make = (
             registerResolver(
               ~fieldName,
               ~externalInputSchema=ITS.Spec.externalInputSchema->S.castToUnknown,
+              ~permission=?inboundDoorPermission(ITS.Spec.commandSchema, ITS.Spec.authorizationOf),
             )
           | None => ()
           }
@@ -865,16 +874,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 +1041,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
@@ -1078,17 +1061,13 @@ module Make = (
               )
             // One SDL field per constructor, each with its own constructor's args and
             // its own per-constructor authorization rule.
-            let commandAuthorization: unknown => Reventless.Authorization.permission = command =>
-              S.Spec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named
             let fieldPermissions = Dict.make()
-            fieldSpecs->Array.forEach(((fieldName, ctor)) => {
-              let hasPayload = Reventless.DcbTag.isVariantPayloadBearing(
-                commandSchema->Obj.magic,
-                ctor,
+            fieldSpecs->Array.forEach(((fieldName, ctor)) =>
+              fieldPermissions->Dict.set(
+                fieldName,
+                S.Spec.authorizationOf(ctor)->Reventless.Authorization.named,
               )
-              let syntheticCmd: unknown = hasPayload ? {"TAG": ctor}->Obj.magic : ctor->Obj.magic
-              fieldPermissions->Dict.set(fieldName, commandAuthorization(syntheticCmd))
-            })
+            )
             Some({
               ReventlessInfra.Api.fieldNames: fieldSpecs->Array.map(((f, _)) => f),
               commandSchema,
@@ -1108,14 +1087,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.authorizationOf,
+          )->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, authorizationOf) {
+  return Plugin_Structure$ReventlessCore.inboundDoorPermission(commandSchema, name => Authorization$Reventless.named(authorizationOf(name)));
+}
+
 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) => {
@@ -292,13 +295,13 @@ function Make(DcbEventLogStorage) {
         syncSlices.forEach(S => {
           let commandSchema = S.Spec.commandSchema;
           if (!ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
-            return registerResolver("Dcb", Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema).map(param => param[0]), commandSchema, command => Authorization$Reventless.named(S.Spec.commandAuthorization(command)));
+            return registerResolver("Dcb", Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema).map(param => param[0]), commandSchema, name => Authorization$Reventless.named(S.Spec.authorizationOf(name)));
           }
         });
         asyncSlices.forEach(S => {
           let commandSchema = S.Spec.commandSchema;
           if (!ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
-            return registerResolver("Dcb", Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema).map(param => param[0]), commandSchema, command => Authorization$Reventless.named(S.Spec.commandAuthorization(command)));
+            return registerResolver("Dcb", Api_Naming$ReventlessCore.sliceMutationFields(apiNamePrefix, S.Spec.name, commandSchema).map(param => param[0]), commandSchema, name => Authorization$Reventless.named(S.Spec.authorizationOf(name)));
           }
         });
       }
@@ -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.authorizationOf));
         }
         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);
@@ -565,12 +554,7 @@ function Make(DcbEventLogStorage) {
         let sliceDef = Stdlib_Option.flatMap(pluginStructure, s => s.stateChangeSlices.find(d => d.name === S.Spec.name));
         let fieldPermissions = {};
         fieldSpecs.forEach(param => {
-          let ctor = param[1];
-          let hasPayload = DcbTag$Reventless.isVariantPayloadBearing(commandSchema, ctor);
-          let syntheticCmd = hasPayload ? ({
-              TAG: ctor
-            }) : ctor;
-          fieldPermissions[param[0]] = Authorization$Reventless.named(S.Spec.commandAuthorization(syntheticCmd));
+          fieldPermissions[param[0]] = Authorization$Reventless.named(S.Spec.authorizationOf(param[1]));
         });
         return {
           fieldNames: fieldSpecs.map(param => param[0]),
@@ -585,10 +569,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.authorizationOf), rule => {
           fieldPermissions[fieldName] = rule;
-        }
+        });
         return {
           fieldNames: [fieldName],
           commandSchema: ITS.Spec.externalInputSchema,
@@ -691,6 +674,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
             },