@reventlessdev/reventless-local 3.0.0-alpha.281 → 3.0.0-alpha.282

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.282 (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))
+
+
 # 3.0.0-alpha.281 (2026-10-08)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.281",
+  "version": "3.0.0-alpha.282",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -40,13 +40,13 @@
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.291",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.139",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.238",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.188",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.155",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.292",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.140",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.239",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.33",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.160"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.189",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.156",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.161"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/Platform.res

@@ -314,10 +314,11 @@ module MakeWithConfig = (
     // Phase 2: bind generateCommand when Output.apply resolves.
     mutationBindHook: CommandGeneratorResolvers_GraphQL.bindHandler,
     // InboundTranslationSlice hooks — pass resolved server for correct target routing.
-    inboundMutationResolverHook: (~fieldName, ~externalInputSchema) =>
+    inboundMutationResolverHook: (~fieldName, ~externalInputSchema, ~permission=?) =>
       InboundTranslationResolvers_GraphQL.register(
         ~fieldName,
         ~externalInputSchema,
+        ~permission?,
         ~server=resolveTargetGraphQL(),
       ),
     inboundMutationBindReceiveHook: InboundTranslationResolvers_GraphQL.bindReceive,

package/src/Platform.res.mjs

@@ -233,7 +233,7 @@ function MakeWithConfig(Config) {
     fields.forEach(field => CommandGeneratorResolvers_GraphQL$ReventlessLocal.registerDcb(field, commandSchema, commandAuthorization, server));
   };
   let hooks_mutationBindHook = CommandGeneratorResolvers_GraphQL$ReventlessLocal.bindHandler;
-  let hooks_inboundMutationResolverHook = (fieldName, externalInputSchema) => InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, externalInputSchema, resolveTargetGraphQL());
+  let hooks_inboundMutationResolverHook = (fieldName, externalInputSchema, permission) => InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, externalInputSchema, permission, resolveTargetGraphQL());
   let hooks_inboundMutationBindReceiveHook = InboundTranslationResolvers_GraphQL$ReventlessLocal.bindReceive;
   let hooks_schemaTypeRegistrationHook = sdlTypes => resolveTargetGraphQL().registerTypes(sdlTypes);
   let hooks_mcpSchemaRegistrationHook = param => {
@@ -1993,7 +1993,7 @@ function Make($star) {
     fields.forEach(field => CommandGeneratorResolvers_GraphQL$ReventlessLocal.registerDcb(field, commandSchema, commandAuthorization, server));
   };
   let hooks_mutationBindHook = CommandGeneratorResolvers_GraphQL$ReventlessLocal.bindHandler;
-  let hooks_inboundMutationResolverHook = (fieldName, externalInputSchema) => InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, externalInputSchema, resolveTargetGraphQL());
+  let hooks_inboundMutationResolverHook = (fieldName, externalInputSchema, permission) => InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, externalInputSchema, permission, resolveTargetGraphQL());
   let hooks_inboundMutationBindReceiveHook = InboundTranslationResolvers_GraphQL$ReventlessLocal.bindReceive;
   let hooks_schemaTypeRegistrationHook = sdlTypes => resolveTargetGraphQL().registerTypes(sdlTypes);
   let hooks_mcpSchemaRegistrationHook = param => {

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res

@@ -1,39 +1,35 @@
-// GraphQL mutation resolvers for in-memory InboundTranslationSlices.
-// Registers one GraphQL mutation field per InboundTranslationSlice.
-// Each resolver calls `receive(argsJson)` directly — the InboundTranslationSlice
-// handles parsing, validation, translation, and command publishing internally.
+// GraphQL mutation resolvers for in-memory InboundTranslationSlices: one field per
+// slice, gated by the door's rule and handing the caller on to `receive`.
 
 @@warning("-44")
 open ReventlessCore
 
-// Mutable registry: fieldName → receive function.
-// Pre-populated synchronously in Phase 1 via a queuing forwarder so callers
-// (e.g. PlatformInspector's onPlatformDeployedHook) can invoke receive before
-// Phase 2 bindReceive runs. Calls park in a Promise queue and drain once bound.
-let receiveRegistry: dict<
-  JSON.t => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
-> = Dict.make()
+type receive = (
+  JSON.t,
+  ~caller: Reventless.Identity.t=?,
+) => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>
+
+// fieldName → receive. Pre-populated with a queuing forwarder so a call made
+// before `bindReceive` parks until it runs.
+let receiveRegistry: dict<receive> = Dict.make()
 
 type pendingCall = {
   inputJson: JSON.t,
+  caller: option<Reventless.Identity.t>,
   resolve: ReventlessInfra.InboundTranslationSlice.receiveResult => unit,
 }
 
-// Per-field pending-call queues — drained when bindReceive fires.
 let pendingQueueRegistry: dict<ref<array<pendingCall>>> = Dict.make()
 
-// Phase 1: Register SDL + resolver stub synchronously (before server starts).
-// Also pre-registers a queuing forwarder in receiveRegistry so callers can
-// invoke receive immediately; calls are parked until bindReceive drains them.
+// Phase 1: register SDL + resolver stub synchronously (before server starts).
+// `permission` is the door's rule; without one the field admits nobody.
 let register = (
   ~fieldName: string,
   ~externalInputSchema: S.t<unknown>,
+  ~permission: option<Reventless.Authorization.permission>=?,
   ~server: ReventlessGraphqlServer.GraphQL_ServerInstance.t,
 ) => {
-  // The mutation field returns CommandResult, so its union members must exist in
-  // this scope's document. Registered here rather than relying on a plugin's
-  // command handlers having registered them first — a plugin whose only mutation
-  // is an inbound translation must not depend on registration order.
+  // Registered here, so a plugin whose only mutation is inbound has its result union.
   CommandGeneratorResolvers_GraphQL.ensureCommandResultTypes(server)
 
   let sdlFields = switch GraphQL_FragmentGenerator.deriveMutationFieldFromObject(
@@ -46,28 +42,32 @@ let register = (
   | None => [`  ${fieldName}: CommandResult!`]
   }
 
-  // Queue of pending calls when receive is not yet bound.
   let pendingQueue: ref<array<pendingCall>> = ref([])
   pendingQueueRegistry->Dict.set(fieldName, pendingQueue)
 
-  // Queuing forwarder: parks calls until bindReceive populates receiveRegistry.
-  let queuingReceive = (inputJson: JSON.t) =>
+  let queuingReceive: receive = (inputJson, ~caller=?) =>
     Promise.make((resolve, _reject) => {
-      pendingQueue.contents->Array.push({inputJson, resolve})
+      pendingQueue.contents->Array.push({inputJson, caller, resolve})
     })
   receiveRegistry->Dict.set(fieldName, queuingReceive)
 
   let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
     _root,
     args,
-    _ctx,
+    ctx,
   ) => {
-    let inputJson: JSON.t = args->Obj.magic
-    let receive = receiveRegistry->Dict.getUnsafe(fieldName)
-    let result = await receive(inputJson)
-    result
-    ->InboundTranslationSlice_Callback.receiveResultToOutcome
-    ->CommandTopic.commandOutcomeToJson
+    let caller = CommandGeneratorResolvers_GraphQL.extractIdentity(ctx)
+    let admitted =
+      permission->Option.mapOr(false, rule => Reventless.Authorization.isAllowed(rule, caller))
+    if !admitted {
+      CommandGeneratorResolvers_GraphQL.rejectForbidden(~field=fieldName)
+    } else {
+      let receive = receiveRegistry->Dict.getUnsafe(fieldName)
+      let result = await receive(args->Obj.magic, ~caller)
+      result
+      ->InboundTranslationSlice_Callback.receiveResultToOutcome
+      ->CommandTopic.commandOutcomeToJson
+    }
   }
 
   let resolvers = Dict.make()
@@ -75,19 +75,15 @@ let register = (
   server.registerMutations(~sdlFields, ~resolvers)
 }
 
-// Phase 2: Bind the real receive function once Output.apply resolves.
-// Replaces the queuing forwarder in receiveRegistry and drains pending calls.
-let bindReceive = (
-  ~fieldName: string,
-  ~receive: JSON.t => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
-) => {
+// Phase 2: bind the real receive, replacing the forwarder and draining its queue.
+let bindReceive = (~fieldName: string, ~receive: receive) => {
   receiveRegistry->Dict.set(fieldName, receive)
   switch pendingQueueRegistry->Dict.get(fieldName) {
   | Some(pendingQueue) =>
     let pending = pendingQueue.contents
     pendingQueue.contents = []
-    pending->Array.forEach(({inputJson, resolve}) => {
-      let _ = receive(inputJson)->Promise.thenResolve(result => resolve(result))
+    pending->Array.forEach(({inputJson, caller, resolve}) => {
+      let _ = receive(inputJson, ~caller?)->Promise.thenResolve(result => resolve(result))
     })
   | None => ()
   }

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res.mjs

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
 import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
 import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
@@ -9,7 +11,7 @@ let receiveRegistry = {};
 
 let pendingQueueRegistry = {};
 
-function register(fieldName, externalInputSchema, server) {
+function register(fieldName, externalInputSchema, permission, server) {
   CommandGeneratorResolvers_GraphQL$ReventlessLocal.ensureCommandResultTypes(server);
   let field = GraphQL_FragmentGenerator$ReventlessCore.deriveMutationFieldFromObject(fieldName, [], new Set(), externalInputSchema);
   let sdlFields = field !== undefined ? [field] : [`  ` + fieldName + `: CommandResult!`];
@@ -17,16 +19,22 @@ function register(fieldName, externalInputSchema, server) {
     contents: []
   };
   pendingQueueRegistry[fieldName] = pendingQueue;
-  let queuingReceive = inputJson => new Promise((resolve, _reject) => {
+  let queuingReceive = (inputJson, caller) => new Promise((resolve, _reject) => {
     pendingQueue.contents.push({
       inputJson: inputJson,
+      caller: caller,
       resolve: resolve
     });
   });
   receiveRegistry[fieldName] = queuingReceive;
-  let resolver = async (_root, args, _ctx) => {
+  let resolver = async (_root, args, ctx) => {
+    let caller = CommandGeneratorResolvers_GraphQL$ReventlessLocal.extractIdentity(ctx);
+    let admitted = Stdlib_Option.mapOr(permission, false, rule => Authorization$Reventless.isAllowed(rule, caller));
+    if (!admitted) {
+      return CommandGeneratorResolvers_GraphQL$ReventlessLocal.rejectForbidden(fieldName);
+    }
     let receive = receiveRegistry[fieldName];
-    let result = await receive(args);
+    let result = await receive(args, caller);
     return CommandTopic$ReventlessCore.commandOutcomeToJson(InboundTranslationSlice_Callback$ReventlessCore.receiveResultToOutcome(result));
   };
   let resolvers = {};
@@ -44,7 +52,7 @@ function bindReceive(fieldName, receive) {
   pendingQueue.contents = [];
   pending.forEach(param => {
     let resolve = param.resolve;
-    receive(param.inputJson).then(result => resolve(result));
+    receive(param.inputJson, param.caller).then(result => resolve(result));
   });
 }
 
@@ -54,4 +62,4 @@ export {
   register,
   bindReceive,
 }
-/* CommandTopic-ReventlessCore Not a pure module */
+/* Authorization-Reventless Not a pure module */

package/tests/adapter/InboundTranslationMutationTest.res

@@ -44,16 +44,36 @@ let selection = `__typename
   ... on CommandAccepted { msgId entityId eventCount }
   ... on CommandRejected { msgId errorCode errorDetail }`
 
-let runMutation = async (~status: string) => {
-  let source = `mutation {
-    r: ${fieldName}(paymentId: "pay-1", orderId: "ord-1", status: "${status}") { ${selection} }
-  }`
+let signedIn = (groups): Reventless.Identity.t => {
+  userId: "u-1",
+  username: "alice",
+  groups,
+  provider: InMemory,
+}
+
+let contextOf = (identity: option<Reventless.Identity.t>): JSON.t =>
+  switch identity {
+  | Some(identity) =>
+    Dict.fromArray([
+      ("identity", identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)),
+    ])->JSON.Encode.object
+  | None => JSON.Encode.null
+  }
+
+let execute = async (~caller, source) =>
   await GraphqlYoga.graphql({
     "schema": DomainGraphQL_Server.composeSchema(),
     "source": source,
-    "contextValue": JSON.Encode.null,
+    "contextValue": contextOf(caller),
   })
-}
+
+let runMutation = async (~status: string) =>
+  await execute(
+    ~caller=Some(signedIn([])),
+    `mutation {
+    r: ${fieldName}(paymentId: "pay-1", orderId: "ord-1", status: "${status}") { ${selection} }
+  }`,
+  )
 
 let errorMessages = (result: GraphqlYoga.executionResult): array<string> =>
   result.errors
@@ -86,13 +106,14 @@ describe("InboundTranslationSlice mutation — response envelope", () => {
     InboundTranslationResolvers_GraphQL.register(
       ~fieldName,
       ~externalInputSchema=PaymentWebhookSpec.externalInputSchema->S.castToUnknown,
+      ~permission=AllowAuthenticated,
       ~server=DomainGraphQL_Server.asInterface,
     )
     DomainGraphQL_Server.resetScope()
 
     InboundTranslationResolvers_GraphQL.bindReceive(
       ~fieldName,
-      ~receive=inputJson => Callback.receive(publishJsons, inputJson),
+      ~receive=(inputJson, ~caller=?) => Callback.receive(publishJsons, inputJson, ~caller?),
     )
   })
 
@@ -140,3 +161,70 @@ describe("InboundTranslationSlice mutation — response envelope", () => {
     expect(fieldLine->Option.map(l => l->String.endsWith(": CommandResult!")))->toEqual(Some(true))
   })
 })
+
+module CatalogFeedTranslation = {
+  let translate = CatalogFeedSpec.translate
+  let moduleUrl = CatalogFeedSpec.moduleUrl
+}
+module CatalogFeedCallback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  CatalogFeedSpec,
+  CatalogFeedTranslation,
+)
+
+let feedField = "Catalog_CatalogFeed"
+
+let runFeed = async (~caller, ~kind) =>
+  await execute(
+    ~caller,
+    `mutation { r: ${feedField}(kind: "${kind}", id: "x-1") { ${selection} } }`,
+  )
+
+describe("InboundTranslationSlice mutation — the door", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.asInterface.reset()
+    published.contents = []
+
+    DomainGraphQL_Server.setScope("Catalog")
+    InboundTranslationResolvers_GraphQL.register(
+      ~fieldName=feedField,
+      ~externalInputSchema=CatalogFeedSpec.externalInputSchema->S.castToUnknown,
+      ~permission=?ReventlessCore.Dcb_Builder.inboundDoorPermission(
+        CatalogFeedSpec.commandSchema,
+        CatalogFeedSpec.commandAuthorization,
+      ),
+      ~server=DomainGraphQL_Server.asInterface,
+    )
+    DomainGraphQL_Server.resetScope()
+
+    InboundTranslationResolvers_GraphQL.bindReceive(
+      ~fieldName=feedField,
+      ~receive=(inputJson, ~caller=?) =>
+        CatalogFeedCallback.receive(publishJsons, inputJson, ~caller?),
+    )
+  })
+
+  testPromise("a caller holding none of the commands' roles is refused", async () => {
+    let node = payload(await runFeed(~caller=Some(signedIn(["Ops"])), ~kind="product"))
+    expect(node->str("errorCode"))->toEqual(Some("Forbidden"))
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("an unauthenticated caller is refused", async () => {
+    let node = payload(await runFeed(~caller=None, ~kind="product"))
+    expect(node->str("errorCode"))->toEqual(Some("Forbidden"))
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("a caller holding a command's role is let through", async () => {
+    let node = payload(await runFeed(~caller=Some(signedIn(["Merchandiser"])), ~kind="product"))
+    expect(node->str("__typename"))->toEqual(Some("CommandAccepted"))
+    expect(published.contents->Array.length)->toBe(1)
+  })
+
+  // The caller reaches `receive`, which refuses the command the door could not see.
+  testPromise("the caller reaches the per-command check", async () => {
+    let node = payload(await runFeed(~caller=Some(signedIn(["Merchandiser"])), ~kind="both"))
+    expect(node->str("errorCode"))->toEqual(Some("Forbidden"))
+    expect(published.contents->Array.length)->toBe(0)
+  })
+})

package/tests/adapter/InboundTranslationMutationTest.res.mjs

@@ -5,6 +5,9 @@ import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Dcb_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/Dcb/Dcb_Builder.res.mjs";
 import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
 import * as InboundTranslationSliceFixtures$ReventlessLocal from "../components/inboundtranslationslice/InboundTranslationSliceFixtures.res.mjs";
 import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
@@ -26,8 +29,7 @@ let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
   commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandSchema,
   targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
   externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalSystem,
-  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization,
-  commandTransition: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandTransition
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization
 })(PaymentWebhookTranslation);
 
 let scope = "Payments";
@@ -46,17 +48,40 @@ let selection = `__typename
   ... on CommandAccepted { msgId entityId eventCount }
   ... on CommandRejected { msgId errorCode errorDetail }`;
 
-async function runMutation(status) {
-  let source = `mutation {
-    r: ` + fieldName + `(paymentId: "pay-1", orderId: "ord-1", status: "` + status + `") { ` + selection + ` }
-  }`;
+function signedIn(groups) {
+  return {
+    userId: "u-1",
+    username: "alice",
+    groups: groups,
+    provider: "InMemory"
+  };
+}
+
+function contextOf(identity) {
+  if (identity !== undefined) {
+    return Object.fromEntries([[
+        "identity",
+        Util_Sury$Reventless.toJson(identity, Identity$Reventless.schema)
+      ]]);
+  } else {
+    return null;
+  }
+}
+
+async function execute(caller, source) {
   return await Graphql.graphql({
     schema: DomainGraphQL_Server$ReventlessLocal.composeSchema(),
     source: source,
-    contextValue: null
+    contextValue: contextOf(caller)
   });
 }
 
+async function runMutation(status) {
+  return await execute(signedIn([]), `mutation {
+    r: ` + fieldName + `(paymentId: "pay-1", orderId: "ord-1", status: "` + status + `") { ` + selection + ` }
+  }`);
+}
+
 function errorMessages(result) {
   return Stdlib_Option.getOr(result.errors, []).map(e => Stdlib_Option.getOr(Stdlib_JsExn.message(e), "unknown error"));
 }
@@ -79,9 +104,9 @@ globalThis.describe("InboundTranslationSlice mutation — response envelope", ()
     published.contents = [];
     Object.keys(Callback.auditLog).forEach(k => Stdlib_Dict.$$delete(Callback.auditLog, k));
     DomainGraphQL_Server$ReventlessLocal.setScope(scope);
-    InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema, DomainGraphQL_Server$ReventlessLocal.asInterface);
+    InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema, "AllowAuthenticated", DomainGraphQL_Server$ReventlessLocal.asInterface);
     DomainGraphQL_Server$ReventlessLocal.resetScope();
-    InboundTranslationResolvers_GraphQL$ReventlessLocal.bindReceive(fieldName, inputJson => Callback.receive(publishJsons, inputJson));
+    InboundTranslationResolvers_GraphQL$ReventlessLocal.bindReceive(fieldName, (inputJson, caller) => Callback.receive(publishJsons, inputJson, caller));
   });
   globalThis.test("a successful translation resolves as CommandAccepted, with no errors", async () => {
     let result = await runMutation("completed");
@@ -116,6 +141,62 @@ globalThis.describe("InboundTranslationSlice mutation — response envelope", ()
   });
 });
 
+let translate$1 = InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.translate;
+
+let moduleUrl$1 = InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.moduleUrl;
+
+let CatalogFeedTranslation = {
+  translate: translate$1,
+  moduleUrl: moduleUrl$1
+};
+
+let CatalogFeedCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.name,
+  moduleUrl: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.moduleUrl,
+  externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.externalInputSchema,
+  commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.commandSchema,
+  targetName: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.targetName,
+  externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.externalSystem,
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.commandAuthorization
+})(CatalogFeedTranslation);
+
+let feedField = "Catalog_CatalogFeed";
+
+async function runFeed(caller, kind) {
+  return await execute(caller, `mutation { r: ` + feedField + `(kind: "` + kind + `", id: "x-1") { ` + selection + ` } }`);
+}
+
+globalThis.describe("InboundTranslationSlice mutation — the door", () => {
+  globalThis.beforeEach(() => {
+    DomainGraphQL_Server$ReventlessLocal.asInterface.reset();
+    published.contents = [];
+    DomainGraphQL_Server$ReventlessLocal.setScope("Catalog");
+    InboundTranslationResolvers_GraphQL$ReventlessLocal.register(feedField, InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.externalInputSchema, Dcb_Builder$ReventlessCore.inboundDoorPermission(InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.commandSchema, InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.commandAuthorization), DomainGraphQL_Server$ReventlessLocal.asInterface);
+    DomainGraphQL_Server$ReventlessLocal.resetScope();
+    InboundTranslationResolvers_GraphQL$ReventlessLocal.bindReceive(feedField, (inputJson, caller) => CatalogFeedCallback.receive(publishJsons, inputJson, caller));
+  });
+  globalThis.test("a caller holding none of the commands' roles is refused", async () => {
+    let node = payload(await runFeed(signedIn(["Ops"]), "product"));
+    globalThis.expect(str(node, "errorCode")).toEqual("Forbidden");
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("an unauthenticated caller is refused", async () => {
+    let node = payload(await runFeed(undefined, "product"));
+    globalThis.expect(str(node, "errorCode")).toEqual("Forbidden");
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("a caller holding a command's role is let through", async () => {
+    let node = payload(await runFeed(signedIn(["Merchandiser"]), "product"));
+    globalThis.expect(str(node, "__typename")).toEqual("CommandAccepted");
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+  globalThis.test("the caller reaches the per-command check", async () => {
+    let node = payload(await runFeed(signedIn(["Merchandiser"]), "both"));
+    globalThis.expect(str(node, "errorCode")).toEqual("Forbidden");
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+});
+
 export {
   PaymentWebhookTranslation,
   Callback,
@@ -124,10 +205,17 @@ export {
   published,
   publishJsons,
   selection,
+  signedIn,
+  contextOf,
+  execute,
   runMutation,
   errorMessages,
   payload,
   str,
   num,
+  CatalogFeedTranslation,
+  CatalogFeedCallback,
+  feedField,
+  runFeed,
 }
 /* Callback Not a pure module */

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res

@@ -226,9 +226,6 @@ describe("InboundTranslationSlice Callback", () => {
 
           let commandAuthorization = (_: command): Reventless.Authorization.rule<role> =>
             AllowAuthenticated
-          type lifecycleState = unit
-          let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> =>
-            Unrestricted
         }
 
         module MultiTranslation = {
@@ -295,9 +292,6 @@ describe("InboundTranslationSlice Callback", () => {
 
           let commandAuthorization = (_: command): Reventless.Authorization.rule<role> =>
             AllowAuthenticated
-          type lifecycleState = unit
-          let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> =>
-            Unrestricted
         }
 
         module EmptyTranslation = {
@@ -329,3 +323,117 @@ describe("InboundTranslationSlice Callback", () => {
     )
   })
 })
+
+module CatalogFeedTranslation = {
+  let translate = CatalogFeedSpec.translate
+  let moduleUrl = CatalogFeedSpec.moduleUrl
+}
+module CatalogFeedCallback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  CatalogFeedSpec,
+  CatalogFeedTranslation,
+)
+
+let caller = (groups): Reventless.Identity.t => {
+  userId: "u-1",
+  username: "alice",
+  groups,
+  provider: InMemory,
+}
+
+let catalogInput = (kind): JSON.t =>
+  Dict.fromArray([
+    ("kind", JSON.Encode.string(kind)),
+    ("id", JSON.Encode.string("x-1")),
+  ])->JSON.Encode.object
+
+describe("receive checks each command against its own rule", () => {
+  let published = ref([])
+  let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+    published := published.contents->Array.concat(cmds)
+  let _ = beforeEach(() => published := [])
+
+  testPromise(
+    "a caller lacking one command's role is refused, and nothing is published",
+    async () => {
+      let result = await CatalogFeedCallback.receive(
+        publish,
+        catalogInput("both"),
+        ~caller=caller(["Merchandiser"]),
+      )
+      switch result {
+      | Error({requestId, ?errorCode}) =>
+        expect(errorCode)->toEqual(Some("Forbidden"))
+        let row = CatalogFeedCallback.auditLog->Dict.get(requestId)
+        expect(row->Option.map(r => r.status))->toEqual(
+          Some(ReventlessCore.InboundTranslationSlice_Callback.Failure),
+        )
+      | Ok(_) => expect(true)->toBe(false)
+      }
+      expect(published.contents->Array.length)->toBe(0)
+    },
+  )
+
+  testPromise("a caller holding every command's role publishes them all", async () => {
+    let result = await CatalogFeedCallback.receive(
+      publish,
+      catalogInput("both"),
+      ~caller=caller(["Merchandiser", "Admin"]),
+    )
+    expect(result->Result.isOk)->toBe(true)
+    expect(published.contents->Array.length)->toBe(2)
+  })
+
+  testPromise("the role one command needs is enough when the input yields only it", async () => {
+    let result = await CatalogFeedCallback.receive(
+      publish,
+      catalogInput("product"),
+      ~caller=caller(["Merchandiser"]),
+    )
+    expect(result->Result.isOk)->toBe(true)
+    expect(published.contents->Array.length)->toBe(1)
+  })
+
+  testPromise("no caller is the platform itself, and publishes", async () => {
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"))
+    expect(result->Result.isOk)->toBe(true)
+    expect(published.contents->Array.length)->toBe(2)
+  })
+
+  testPromise("a refusal answers CommandRejected with Forbidden", async () => {
+    let result = await CatalogFeedCallback.receive(
+      publish,
+      catalogInput("both"),
+      ~caller=Reventless.Identity.anonymous,
+    )
+    switch result->ReventlessCore.InboundTranslationSlice_Callback.receiveResultToOutcome {
+    | Rejected({errorCode}) => expect(errorCode)->toBe("Forbidden")
+    | _ => expect(true)->toBe(false)
+    }
+  })
+})
+
+module NoteFeedTranslation = {
+  let translate = NoteFeedSpec.translate
+  let moduleUrl = NoteFeedSpec.moduleUrl
+}
+module NoteFeedCallback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  NoteFeedSpec,
+  NoteFeedTranslation,
+)
+
+describe("receive encodes commands with their schema", () => {
+  testPromise("an absent option the schema writes as null decodes at the target", async () => {
+    let published = ref([])
+    let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds => published := cmds
+    let _ = await NoteFeedCallback.receive(
+      publish,
+      Dict.fromArray([("orderId", JSON.Encode.string("ord-1"))])->JSON.Encode.object,
+    )
+
+    let commandJson = (published.contents->Array.getUnsafe(0)).commandJson
+    // The target decodes with the same schema; the runtime value would omit `note`.
+    let decoded = commandJson->S.parseOrThrow(~to=NoteFeedSpec.commandSchema)
+    expect(decoded)->toEqual(NoteFeedSpec.Annotate({orderId: "ord-1", note: None}))
+    expect(commandJson->JSON.stringify->String.includes(`"note":null`))->toBe(true)
+  })
+})

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res.mjs

@@ -3,8 +3,10 @@
 import * as Sury from "sury";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
 import * as InboundTranslationSliceFixtures$ReventlessLocal from "./InboundTranslationSliceFixtures.res.mjs";
 import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
 
@@ -24,8 +26,7 @@ let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
   commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandSchema,
   targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
   externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalSystem,
-  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization,
-  commandTransition: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandTransition
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization
 })(PaymentWebhookTranslation);
 
 globalThis.describe("InboundTranslationSlice Callback", () => {
@@ -45,7 +46,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: "ord-1",
         status: "completed"
       };
-      let result = await Callback.receive(mockPublish, inputJson);
+      let result = await Callback.receive(mockPublish, inputJson, undefined);
       if (result.TAG === "Ok") {
         let match = result._0;
         globalThis.expect(match.targetIds).toEqual(["ord-1"]);
@@ -76,7 +77,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: "ord-1",
         status: "pending"
       };
-      let result = await Callback.receive(mockPublish, inputJson);
+      let result = await Callback.receive(mockPublish, inputJson, undefined);
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
@@ -93,7 +94,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       let inputJson = {
         unexpected: "data"
       };
-      let result = await Callback.receive(mockPublish, inputJson);
+      let result = await Callback.receive(mockPublish, inputJson, undefined);
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
@@ -111,7 +112,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: "ord-1",
         status: "completed"
       };
-      let result = await Callback.receive(failingPublish, inputJson);
+      let result = await Callback.receive(failingPublish, inputJson, undefined);
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
@@ -130,7 +131,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         paymentId: "pay-1",
         orderId: "ord-1",
         status: "completed"
-      });
+      }, undefined);
       let firstId = InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(first);
       globalThis.expect(Stdlib_Option.isSome(InboundTranslationSlice_Callback$ReventlessCore.takeAuditRow(Callback.auditLog, firstId))).toBe(true);
       globalThis.expect(Object.entries(Callback.auditLog).length).toBe(0);
@@ -138,7 +139,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         paymentId: "pay-1",
         orderId: "ord-1",
         status: "completed"
-      });
+      }, undefined);
       let secondId = InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(second);
       globalThis.expect(secondId === firstId).toBe(false);
       globalThis.expect(Object.entries(Callback.auditLog).length).toBe(1);
@@ -151,7 +152,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         paymentId: "pay-1",
         orderId: "ord-1",
         status: "pending"
-      });
+      }, undefined);
       let id = InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result);
       let row = InboundTranslationSlice_Callback$ReventlessCore.takeAuditRow(Callback.auditLog, id);
       if (row !== undefined) {
@@ -186,7 +187,6 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         ])
       });
       let commandAuthorization = param => "AllowAuthenticated";
-      let commandTransition = param => "Unrestricted";
       let MultiTranslation = {
         translate: translate,
         moduleUrl: moduleUrl
@@ -198,8 +198,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         commandSchema: commandSchema,
         targetName: "ConfirmPayment",
         externalSystem: undefined,
-        commandAuthorization: commandAuthorization,
-        commandTransition: commandTransition
+        commandAuthorization: commandAuthorization
       })(MultiTranslation);
       let publishedCommands = {
         contents: []
@@ -215,7 +214,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
           "pay-3"
         ]
       };
-      let result = await MultiCallback.receive(mockPublish, inputJson);
+      let result = await MultiCallback.receive(mockPublish, inputJson, undefined);
       if (result.TAG === "Ok") {
         let match = result._0;
         globalThis.expect(match.targetIds).toEqual([
@@ -250,7 +249,6 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         _0: []
       });
       let commandAuthorization = param => "AllowAuthenticated";
-      let commandTransition = param => "Unrestricted";
       let EmptyTranslation = {
         translate: translate,
         moduleUrl: moduleUrl
@@ -262,8 +260,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         commandSchema: commandSchema,
         targetName: "ConfirmPayment",
         externalSystem: undefined,
-        commandAuthorization: commandAuthorization,
-        commandTransition: commandTransition
+        commandAuthorization: commandAuthorization
       })(EmptyTranslation);
       let publishedCommands = {
         contents: []
@@ -274,7 +271,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       let inputJson = {
         orderId: "ord-1"
       };
-      let result = await EmptyCallback.receive(mockPublish, inputJson);
+      let result = await EmptyCallback.receive(mockPublish, inputJson, undefined);
       if (result.TAG === "Ok") {
         let match = result._0;
         globalThis.expect(match.targetIds).toEqual([]);
@@ -287,8 +284,152 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
   });
 });
 
+let translate$1 = InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.translate;
+
+let moduleUrl$1 = InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.moduleUrl;
+
+let CatalogFeedTranslation = {
+  translate: translate$1,
+  moduleUrl: moduleUrl$1
+};
+
+let CatalogFeedCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.name,
+  moduleUrl: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.moduleUrl,
+  externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.externalInputSchema,
+  commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.commandSchema,
+  targetName: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.targetName,
+  externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.externalSystem,
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.commandAuthorization
+})(CatalogFeedTranslation);
+
+function caller(groups) {
+  return {
+    userId: "u-1",
+    username: "alice",
+    groups: groups,
+    provider: "InMemory"
+  };
+}
+
+function catalogInput(kind) {
+  return Object.fromEntries([
+    [
+      "kind",
+      kind
+    ],
+    [
+      "id",
+      "x-1"
+    ]
+  ]);
+}
+
+globalThis.describe("receive checks each command against its own rule", () => {
+  let published = {
+    contents: []
+  };
+  let publish = async cmds => {
+    published.contents = published.contents.concat(cmds);
+  };
+  globalThis.beforeEach(() => {
+    published.contents = [];
+  });
+  globalThis.test("a caller lacking one command's role is refused, and nothing is published", async () => {
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), caller(["Merchandiser"]));
+    if (result.TAG === "Ok") {
+      globalThis.expect(true).toBe(false);
+    } else {
+      let match = result._0;
+      globalThis.expect(match.errorCode).toEqual("Forbidden");
+      let row = CatalogFeedCallback.auditLog[match.requestId];
+      globalThis.expect(Stdlib_Option.map(row, r => r.status)).toEqual("Failure");
+    }
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("a caller holding every command's role publishes them all", async () => {
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), caller([
+      "Merchandiser",
+      "Admin"
+    ]));
+    globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    globalThis.expect(published.contents.length).toBe(2);
+  });
+  globalThis.test("the role one command needs is enough when the input yields only it", async () => {
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("product"), caller(["Merchandiser"]));
+    globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+  globalThis.test("no caller is the platform itself, and publishes", async () => {
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), undefined);
+    globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    globalThis.expect(published.contents.length).toBe(2);
+  });
+  globalThis.test("a refusal answers CommandRejected with Forbidden", async () => {
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), Identity$Reventless.anonymous);
+    let match = InboundTranslationSlice_Callback$ReventlessCore.receiveResultToOutcome(result);
+    switch (match.TAG) {
+      case "Rejected" :
+        globalThis.expect(match.errorCode).toBe("Forbidden");
+        return;
+      case "Accepted" :
+      case "Pending" :
+        globalThis.expect(true).toBe(false);
+        return;
+    }
+  });
+});
+
+let translate$2 = InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.translate;
+
+let moduleUrl$2 = InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.moduleUrl;
+
+let NoteFeedTranslation = {
+  translate: translate$2,
+  moduleUrl: moduleUrl$2
+};
+
+let NoteFeedCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.name,
+  moduleUrl: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.moduleUrl,
+  externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.externalInputSchema,
+  commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.commandSchema,
+  targetName: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.targetName,
+  externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.externalSystem,
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.commandAuthorization
+})(NoteFeedTranslation);
+
+globalThis.describe("receive encodes commands with their schema", () => {
+  globalThis.test("an absent option the schema writes as null decodes at the target", async () => {
+    let published = {
+      contents: []
+    };
+    let publish = async cmds => {
+      published.contents = cmds;
+    };
+    await NoteFeedCallback.receive(publish, Object.fromEntries([[
+        "orderId",
+        "ord-1"
+      ]]), undefined);
+    let commandJson = published.contents[0].commandJson;
+    let decoded = Sury.parseOrThrow(commandJson, InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.commandSchema);
+    globalThis.expect(decoded).toEqual({
+      TAG: "Annotate",
+      orderId: "ord-1",
+      note: undefined
+    });
+    globalThis.expect(JSON.stringify(commandJson).includes(`"note":null`)).toBe(true);
+  });
+});
+
 export {
   PaymentWebhookTranslation,
   Callback,
+  CatalogFeedTranslation,
+  CatalogFeedCallback,
+  caller,
+  catalogInput,
+  NoteFeedTranslation,
+  NoteFeedCallback,
 }
 /* Callback Not a pure module */

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res

@@ -36,3 +36,60 @@ module PaymentWebhookSpec = {
     | status => Error("Unknown payment status: " ++ status)
     }
 }
+
+// Two constructors under different roles; `kind` picks which the input becomes.
+module CatalogFeedSpec = {
+  let name = "CatalogFeed"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type externalInput = {kind: string, id: string}
+
+  @schema
+  type command =
+    | AddProduct({productId: @s.matches(Reventless.DcbTag.string) string})
+    | AddCategory({categoryId: @s.matches(Reventless.DcbTag.string) string})
+
+  let targetName = "AddProduct"
+  let externalSystem = None
+
+  type role = Reventless.Role.name
+  let merchandiser = Reventless.Role.make("Merchandiser")
+  let admin = Reventless.Role.make("Admin")
+  let commandAuthorization = (command: command): Reventless.Authorization.rule<role> =>
+    switch command {
+    | AddProduct(_) => AllowRoles([merchandiser])
+    | AddCategory(_) => AllowRoles([admin])
+    }
+
+  let translate = (input: externalInput) =>
+    switch input.kind {
+    | "product" => Ok([(input.id, AddProduct({productId: input.id}))])
+    | "both" =>
+      Ok([
+        (input.id, AddProduct({productId: input.id})),
+        (input.id, AddCategory({categoryId: input.id})),
+      ])
+    | kind => Error("Unknown kind: " ++ kind)
+    }
+}
+
+// A command whose schema writes an absent note as `null`, which the runtime value does not.
+module NoteFeedSpec = {
+  let name = "NoteFeed"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type externalInput = {orderId: string}
+
+  @schema
+  type command =
+    Annotate({orderId: @s.matches(Reventless.DcbTag.string) string, note: @s.null option<string>})
+
+  let targetName = "Annotate"
+  let externalSystem = None
+
+  let translate = (input: externalInput) => Ok([
+    (input.orderId, Annotate({orderId: input.orderId, note: None})),
+  ])
+}

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res.mjs

@@ -56,10 +56,6 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
-function commandTransition(param) {
-  return "Undeclared";
-}
-
 let traits = [];
 
 let PaymentWebhookSpec = {
@@ -71,12 +67,151 @@ let PaymentWebhookSpec = {
   externalSystem: undefined,
   translate: translate,
   commandAuthorization: commandAuthorization,
-  commandTransition: commandTransition,
   traits: traits
 };
 
+let moduleUrl$2 = import.meta.url;
+
+let externalInputSchema$1 = Sury.$schema(s => ({
+  kind: s.m(Sury.string),
+  id: s.m(Sury.string)
+}));
+
+let commandSchema$1 = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "AddProduct",
+    productId: s.m(DcbTag$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "AddCategory",
+    categoryId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let merchandiser = "Merchandiser";
+
+let admin = "Admin";
+
+function commandAuthorization$1(command) {
+  if (command.TAG === "AddProduct") {
+    return {
+      TAG: "AllowRoles",
+      _0: [merchandiser]
+    };
+  } else {
+    return {
+      TAG: "AllowRoles",
+      _0: [admin]
+    };
+  }
+}
+
+function translate$1(input) {
+  let kind = input.kind;
+  switch (kind) {
+    case "both" :
+      return {
+        TAG: "Ok",
+        _0: [
+          [
+            input.id,
+            {
+              TAG: "AddProduct",
+              productId: input.id
+            }
+          ],
+          [
+            input.id,
+            {
+              TAG: "AddCategory",
+              categoryId: input.id
+            }
+          ]
+        ]
+      };
+    case "product" :
+      return {
+        TAG: "Ok",
+        _0: [[
+            input.id,
+            {
+              TAG: "AddProduct",
+              productId: input.id
+            }
+          ]]
+      };
+    default:
+      return {
+        TAG: "Error",
+        _0: "Unknown kind: " + kind
+      };
+  }
+}
+
+let traits$1 = [];
+
+let CatalogFeedSpec = {
+  name: "CatalogFeed",
+  moduleUrl: moduleUrl$2,
+  externalInputSchema: externalInputSchema$1,
+  commandSchema: commandSchema$1,
+  targetName: "AddProduct",
+  externalSystem: undefined,
+  merchandiser: merchandiser,
+  admin: admin,
+  commandAuthorization: commandAuthorization$1,
+  translate: translate$1,
+  traits: traits$1
+};
+
+let moduleUrl$3 = import.meta.url;
+
+let externalInputSchema$2 = Sury.$schema(s => ({
+  orderId: s.m(Sury.string)
+}));
+
+let commandSchema$2 = Sury.$schema(s => ({
+  TAG: "Annotate",
+  orderId: s.m(DcbTag$Reventless.string),
+  note: s.m(Sury.$nullAsOption(Sury.string))
+}));
+
+function translate$2(input) {
+  return {
+    TAG: "Ok",
+    _0: [[
+        input.orderId,
+        {
+          TAG: "Annotate",
+          orderId: input.orderId,
+          note: undefined
+        }
+      ]]
+  };
+}
+
+function commandAuthorization$2(param) {
+  return "AllowAuthenticated";
+}
+
+let traits$2 = [];
+
+let NoteFeedSpec = {
+  name: "NoteFeed",
+  moduleUrl: moduleUrl$3,
+  externalInputSchema: externalInputSchema$2,
+  commandSchema: commandSchema$2,
+  targetName: "Annotate",
+  externalSystem: undefined,
+  translate: translate$2,
+  commandAuthorization: commandAuthorization$2,
+  traits: traits$2
+};
+
 export {
   OrderEventLog,
   PaymentWebhookSpec,
+  CatalogFeedSpec,
+  NoteFeedSpec,
 }
 /* moduleUrl Not a pure module */