@reventlessdev/reventless-local 3.0.0-alpha.298 → 3.0.0-alpha.299

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res

@@ -32,7 +32,11 @@ describe("InboundTranslationSlice Callback", () => {
           "status": "completed",
         }->Obj.magic
 
-        let result = await Callback.receive(mockPublish, inputJson)
+        let result = await Callback.receive(
+          mockPublish,
+          inputJson,
+          ~capabilities=Reventless.Capabilities.none,
+        )
 
         switch result {
         | Ok({requestId, targetIds, commandCount}) =>
@@ -69,7 +73,11 @@ describe("InboundTranslationSlice Callback", () => {
           "status": "pending",
         }->Obj.magic
 
-        let result = await Callback.receive(mockPublish, inputJson)
+        let result = await Callback.receive(
+          mockPublish,
+          inputJson,
+          ~capabilities=Reventless.Capabilities.none,
+        )
 
         switch result {
         | Error({error}) => expect(error)->toBe("Unknown payment status: pending")
@@ -92,7 +100,11 @@ describe("InboundTranslationSlice Callback", () => {
         // Missing required fields
         let inputJson = {"unexpected": "data"}->Obj.magic
 
-        let result = await Callback.receive(mockPublish, inputJson)
+        let result = await Callback.receive(
+          mockPublish,
+          inputJson,
+          ~capabilities=Reventless.Capabilities.none,
+        )
 
         switch result {
         | Error(_) => expect(true)->toBe(true)
@@ -119,7 +131,11 @@ describe("InboundTranslationSlice Callback", () => {
           "status": "completed",
         }->Obj.magic
 
-        let result = await Callback.receive(failingPublish, inputJson)
+        let result = await Callback.receive(
+          failingPublish,
+          inputJson,
+          ~capabilities=Reventless.Capabilities.none,
+        )
 
         switch result {
         | Error({error}) => expect(error)->toBe("publish failed")
@@ -147,7 +163,11 @@ describe("InboundTranslationSlice Callback", () => {
         let input = status =>
           {"paymentId": "pay-1", "orderId": "ord-1", "status": status}->Obj.magic
 
-        let first = await Callback.receive(mockPublish, input("completed"))
+        let first = await Callback.receive(
+          mockPublish,
+          input("completed"),
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let firstId = first->ReventlessCore.InboundTranslationSlice_Callback.requestIdOf
         expect(
           Callback.auditLog
@@ -158,7 +178,11 @@ describe("InboundTranslationSlice Callback", () => {
 
         // A second request drains only its own row — the first one is gone, so it
         // cannot be written a second time.
-        let second = await Callback.receive(mockPublish, input("completed"))
+        let second = await Callback.receive(
+          mockPublish,
+          input("completed"),
+          ~capabilities=Reventless.Capabilities.none,
+        )
         let secondId = second->ReventlessCore.InboundTranslationSlice_Callback.requestIdOf
         expect(secondId == firstId)->toBe(false)
         expect(Callback.auditLog->Dict.toArray->Array.length)->toBe(1)
@@ -182,6 +206,7 @@ describe("InboundTranslationSlice Callback", () => {
         let result = await Callback.receive(
           mockPublish,
           {"paymentId": "pay-1", "orderId": "ord-1", "status": "pending"}->Obj.magic,
+          ~capabilities=Reventless.Capabilities.none,
         )
         let id = result->ReventlessCore.InboundTranslationSlice_Callback.requestIdOf
         switch Callback.auditLog->ReventlessCore.InboundTranslationSlice_Callback.takeAuditRow(id) {
@@ -215,9 +240,14 @@ describe("InboundTranslationSlice Callback", () => {
 
           let targetName = "ConfirmPayment"
           let externalSystem = None
+          let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
           let endpoint = None
 
-          let translate = (input: externalInput) => Ok(
+          let translate = async (
+            input: externalInput,
+            ~capabilities as _: Reventless.Capabilities.t,
+            ~caller as _: option<Reventless.Identity.t>,
+          ) => Ok(
             input.items->Array.map(
               item => (input.orderId, ConfirmPayment({orderId: input.orderId, paymentId: item})),
             ),
@@ -248,7 +278,11 @@ describe("InboundTranslationSlice Callback", () => {
           "items": ["pay-1", "pay-2", "pay-3"],
         }->Obj.magic
 
-        let result = await MultiCallback.receive(mockPublish, inputJson)
+        let result = await MultiCallback.receive(
+          mockPublish,
+          inputJson,
+          ~capabilities=Reventless.Capabilities.none,
+        )
 
         switch result {
         | Ok({targetIds, commandCount}) =>
@@ -286,9 +320,14 @@ describe("InboundTranslationSlice Callback", () => {
 
           let targetName = "ConfirmPayment"
           let externalSystem = None
+          let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
           let endpoint = None
 
-          let translate = (_input: externalInput) => Ok([])
+          let translate = async (
+            _input: externalInput,
+            ~capabilities as _: Reventless.Capabilities.t,
+            ~caller as _: option<Reventless.Identity.t>,
+          ) => Ok([])
 
           type role = Reventless.Role.name
 
@@ -312,7 +351,11 @@ describe("InboundTranslationSlice Callback", () => {
 
         let inputJson = {"orderId": "ord-1"}->Obj.magic
 
-        let result = await EmptyCallback.receive(mockPublish, inputJson)
+        let result = await EmptyCallback.receive(
+          mockPublish,
+          inputJson,
+          ~capabilities=Reventless.Capabilities.none,
+        )
 
         switch result {
         | Ok({targetIds, commandCount}) =>
@@ -360,6 +403,7 @@ describe("receive checks each command against its own rule", () => {
       let result = await CatalogFeedCallback.receive(
         publish,
         catalogInput("both"),
+        ~capabilities=Reventless.Capabilities.none,
         ~caller=caller(["Merchandiser"]),
       )
       switch result {
@@ -379,6 +423,7 @@ describe("receive checks each command against its own rule", () => {
     let result = await CatalogFeedCallback.receive(
       publish,
       catalogInput("both"),
+      ~capabilities=Reventless.Capabilities.none,
       ~caller=caller(["Merchandiser", "Admin"]),
     )
     expect(result->Result.isOk)->toBe(true)
@@ -389,6 +434,7 @@ describe("receive checks each command against its own rule", () => {
     let result = await CatalogFeedCallback.receive(
       publish,
       catalogInput("product"),
+      ~capabilities=Reventless.Capabilities.none,
       ~caller=caller(["Merchandiser"]),
     )
     expect(result->Result.isOk)->toBe(true)
@@ -396,7 +442,11 @@ describe("receive checks each command against its own rule", () => {
   })
 
   testPromise("no caller is the platform itself, and publishes", async () => {
-    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"))
+    let result = await CatalogFeedCallback.receive(
+      publish,
+      catalogInput("both"),
+      ~capabilities=Reventless.Capabilities.none,
+    )
     expect(result->Result.isOk)->toBe(true)
     expect(published.contents->Array.length)->toBe(2)
   })
@@ -405,6 +455,7 @@ describe("receive checks each command against its own rule", () => {
     let result = await CatalogFeedCallback.receive(
       publish,
       catalogInput("both"),
+      ~capabilities=Reventless.Capabilities.none,
       ~caller=Reventless.Identity.anonymous,
     )
     switch result->ReventlessCore.InboundTranslationSlice_Callback.receiveResultToOutcome {
@@ -430,6 +481,7 @@ describe("receive encodes commands with their schema", () => {
     let _ = await NoteFeedCallback.receive(
       publish,
       Dict.fromArray([("orderId", JSON.Encode.string("ord-1"))])->JSON.Encode.object,
+      ~capabilities=Reventless.Capabilities.none,
     )
 
     let commandJson = (published.contents->Array.getUnsafe(0)).commandJson
@@ -439,3 +491,83 @@ describe("receive encodes commands with their schema", () => {
     expect(commandJson->JSON.stringify->String.includes(`"note":null`))->toBe(true)
   })
 })
+
+// A door that looks at its caller before it decides: only an administrator may
+// send it. It refuses before reaching a capability, and the refusal is recorded
+// like any other translation error, naming who was refused.
+module AdminOnlyTranslation = {
+  let translate = async (input, ~capabilities, ~caller: option<Reventless.Identity.t>) =>
+    switch caller {
+    | None => Error("this door needs a caller")
+    | Some(identity) if !(identity->Reventless.Identity.hasGroup("Admin")) =>
+      Error("only an administrator may send this")
+    | Some(_) => await PaymentWebhookSpec.translate(input, ~capabilities, ~caller)
+    }
+  let moduleUrl = PaymentWebhookSpec.moduleUrl
+}
+module AdminOnlyCallback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  PaymentWebhookSpec,
+  AdminOnlyTranslation,
+)
+
+describe("receive hands the door its caller", () => {
+  let payment = {"paymentId": "pay-1", "orderId": "ord-1", "status": "completed"}->Obj.magic
+  let identity = (~userId, ~groups): Reventless.Identity.t => {
+    ...Reventless.Identity.anonymous,
+    userId,
+    groups,
+  }
+
+  let receive = async (~caller=?) => {
+    AdminOnlyCallback.auditLog
+    ->Dict.keysToArray
+    ->Array.forEach(k => AdminOnlyCallback.auditLog->Dict.delete(k))
+    let published = ref([])
+    let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds => published := cmds
+    let result = await AdminOnlyCallback.receive(
+      publish,
+      payment,
+      ~capabilities=Reventless.Capabilities.none,
+      ~caller?,
+    )
+    let row = AdminOnlyCallback.auditLog->Dict.valuesToArray->Array.getUnsafe(0)
+    (result, published.contents, row)
+  }
+
+  testPromise("with no caller, the door refuses and nothing is published", async () => {
+    let (result, published, row) = await receive()
+    expect(result->Result.isError)->toBe(true)
+    expect(published)->toEqual([])
+    expect(row.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Failure)
+    expect(row.error)->toEqual(Some("this door needs a caller"))
+    expect(row.caller)->toEqual(None)
+  })
+
+  testPromise(
+    "a caller lacking the role is refused, and the row names who was refused",
+    async () => {
+      let (result, published, row) = await receive(
+        ~caller=identity(~userId="u_visitor", ~groups=["Shopper"]),
+      )
+      switch result {
+      | Error({error, ?errorCode}) =>
+        expect(error)->toBe("only an administrator may send this")
+        // The door's refusal, not the platform's per-command gate.
+        expect(errorCode)->toEqual(None)
+      | Ok(_) => expect(true)->toBe(false)
+      }
+      expect(published)->toEqual([])
+      expect(row.caller)->toEqual(Some("u_visitor"))
+    },
+  )
+
+  testPromise("a caller holding the role is let through, and named", async () => {
+    let (result, published, row) = await receive(
+      ~caller=identity(~userId="u_admin", ~groups=["Admin"]),
+    )
+    expect(result->Result.isOk)->toBe(true)
+    expect(published->Array.length)->toBe(1)
+    expect(row.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Success)
+    expect(row.caller)->toEqual(Some("u_admin"))
+  })
+})

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

@@ -7,6 +7,7 @@ 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 Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.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";
 
@@ -27,7 +28,8 @@ let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
   targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
   externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalSystem,
   authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.authorizationOf,
-  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.endpoint
+  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.endpoint,
+  capabilityNeeds: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.capabilityNeeds
 })(PaymentWebhookTranslation);
 
 globalThis.describe("InboundTranslationSlice Callback", () => {
@@ -47,7 +49,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: "ord-1",
         status: "completed"
       };
-      let result = await Callback.receive(mockPublish, inputJson, undefined, undefined);
+      let result = await Callback.receive(mockPublish, inputJson, Capabilities$Reventless.none, undefined, undefined);
       if (result.TAG === "Ok") {
         let match = result._0;
         globalThis.expect(match.targetIds).toEqual(["ord-1"]);
@@ -78,7 +80,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: "ord-1",
         status: "pending"
       };
-      let result = await Callback.receive(mockPublish, inputJson, undefined, undefined);
+      let result = await Callback.receive(mockPublish, inputJson, Capabilities$Reventless.none, undefined, undefined);
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
@@ -95,7 +97,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       let inputJson = {
         unexpected: "data"
       };
-      let result = await Callback.receive(mockPublish, inputJson, undefined, undefined);
+      let result = await Callback.receive(mockPublish, inputJson, Capabilities$Reventless.none, undefined, undefined);
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
@@ -113,7 +115,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: "ord-1",
         status: "completed"
       };
-      let result = await Callback.receive(failingPublish, inputJson, undefined, undefined);
+      let result = await Callback.receive(failingPublish, inputJson, Capabilities$Reventless.none, undefined, undefined);
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
@@ -132,7 +134,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         paymentId: "pay-1",
         orderId: "ord-1",
         status: "completed"
-      }, undefined, undefined);
+      }, Capabilities$Reventless.none, undefined, 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);
@@ -140,7 +142,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         paymentId: "pay-1",
         orderId: "ord-1",
         status: "completed"
-      }, undefined, undefined);
+      }, Capabilities$Reventless.none, undefined, undefined);
       let secondId = InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(second);
       globalThis.expect(secondId === firstId).toBe(false);
       globalThis.expect(Object.entries(Callback.auditLog).length).toBe(1);
@@ -153,7 +155,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         paymentId: "pay-1",
         orderId: "ord-1",
         status: "pending"
-      }, undefined, undefined);
+      }, Capabilities$Reventless.none, undefined, undefined);
       let id = InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result);
       let row = InboundTranslationSlice_Callback$ReventlessCore.takeAuditRow(Callback.auditLog, id);
       if (row !== undefined) {
@@ -176,7 +178,8 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: s.m(DcbTag$Reventless.string),
         paymentId: s.m(Sury.string)
       }));
-      let translate = input => ({
+      let capabilityNeeds = [];
+      let translate = async (input, param, param$1) => ({
         TAG: "Ok",
         _0: input.items.map(item => [
           input.orderId,
@@ -200,7 +203,8 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         targetName: "ConfirmPayment",
         externalSystem: undefined,
         authorizationOf: authorizationOf,
-        endpoint: undefined
+        endpoint: undefined,
+        capabilityNeeds: capabilityNeeds
       })(MultiTranslation);
       let publishedCommands = {
         contents: []
@@ -216,7 +220,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
           "pay-3"
         ]
       };
-      let result = await MultiCallback.receive(mockPublish, inputJson, undefined, undefined);
+      let result = await MultiCallback.receive(mockPublish, inputJson, Capabilities$Reventless.none, undefined, undefined);
       if (result.TAG === "Ok") {
         let match = result._0;
         globalThis.expect(match.targetIds).toEqual([
@@ -246,7 +250,8 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         orderId: s.m(DcbTag$Reventless.string),
         paymentId: s.m(Sury.string)
       }));
-      let translate = _input => ({
+      let capabilityNeeds = [];
+      let translate = async (_input, param, param$1) => ({
         TAG: "Ok",
         _0: []
       });
@@ -263,7 +268,8 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         targetName: "ConfirmPayment",
         externalSystem: undefined,
         authorizationOf: authorizationOf,
-        endpoint: undefined
+        endpoint: undefined,
+        capabilityNeeds: capabilityNeeds
       })(EmptyTranslation);
       let publishedCommands = {
         contents: []
@@ -274,7 +280,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       let inputJson = {
         orderId: "ord-1"
       };
-      let result = await EmptyCallback.receive(mockPublish, inputJson, undefined, undefined);
+      let result = await EmptyCallback.receive(mockPublish, inputJson, Capabilities$Reventless.none, undefined, undefined);
       if (result.TAG === "Ok") {
         let match = result._0;
         globalThis.expect(match.targetIds).toEqual([]);
@@ -304,7 +310,8 @@ let CatalogFeedCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
   targetName: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.targetName,
   externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.externalSystem,
   authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.authorizationOf,
-  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.endpoint
+  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.endpoint,
+  capabilityNeeds: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.capabilityNeeds
 })(CatalogFeedTranslation);
 
 function caller(groups) {
@@ -340,7 +347,7 @@ globalThis.describe("receive checks each command against its own rule", () => {
     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"]), undefined);
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), Capabilities$Reventless.none, caller(["Merchandiser"]), undefined);
     if (result.TAG === "Ok") {
       globalThis.expect(true).toBe(false);
     } else {
@@ -352,7 +359,7 @@ globalThis.describe("receive checks each command against its own rule", () => {
     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([
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), Capabilities$Reventless.none, caller([
       "Merchandiser",
       "Admin"
     ]), undefined);
@@ -360,17 +367,17 @@ globalThis.describe("receive checks each command against its own rule", () => {
     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"]), undefined);
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("product"), Capabilities$Reventless.none, caller(["Merchandiser"]), undefined);
     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, undefined);
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), Capabilities$Reventless.none, undefined, 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, undefined);
+    let result = await CatalogFeedCallback.receive(publish, catalogInput("both"), Capabilities$Reventless.none, Identity$Reventless.anonymous, undefined);
     let match = InboundTranslationSlice_Callback$ReventlessCore.receiveResultToOutcome(result);
     switch (match.TAG) {
       case "Rejected" :
@@ -401,7 +408,8 @@ let NoteFeedCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
   targetName: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.targetName,
   externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.externalSystem,
   authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.authorizationOf,
-  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.endpoint
+  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.endpoint,
+  capabilityNeeds: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.capabilityNeeds
 })(NoteFeedTranslation);
 
 globalThis.describe("receive encodes commands with their schema", () => {
@@ -415,7 +423,7 @@ globalThis.describe("receive encodes commands with their schema", () => {
     await NoteFeedCallback.receive(publish, Object.fromEntries([[
         "orderId",
         "ord-1"
-      ]]), undefined, undefined);
+      ]]), Capabilities$Reventless.none, undefined, undefined);
     let commandJson = published.contents[0].commandJson;
     let decoded = Sury.parseOrThrow(commandJson, InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.commandSchema);
     globalThis.expect(decoded).toEqual({
@@ -427,6 +435,103 @@ globalThis.describe("receive encodes commands with their schema", () => {
   });
 });
 
+async function translate$3(input, capabilities, caller) {
+  if (caller !== undefined) {
+    if (Identity$Reventless.hasGroup(caller, "Admin")) {
+      return await InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.translate(input, capabilities, caller);
+    } else {
+      return {
+        TAG: "Error",
+        _0: "only an administrator may send this"
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "this door needs a caller"
+    };
+  }
+}
+
+let moduleUrl$3 = InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.moduleUrl;
+
+let AdminOnlyTranslation = {
+  translate: translate$3,
+  moduleUrl: moduleUrl$3
+};
+
+let AdminOnlyCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.name,
+  moduleUrl: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.moduleUrl,
+  externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema,
+  commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandSchema,
+  targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
+  externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalSystem,
+  authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.authorizationOf,
+  endpoint: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.endpoint,
+  capabilityNeeds: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.capabilityNeeds
+})(AdminOnlyTranslation);
+
+globalThis.describe("receive hands the door its caller", () => {
+  let payment = {
+    paymentId: "pay-1",
+    orderId: "ord-1",
+    status: "completed"
+  };
+  let identity = (userId, groups) => {
+    let newrecord = {...Identity$Reventless.anonymous};
+    newrecord.groups = groups;
+    newrecord.userId = userId;
+    return newrecord;
+  };
+  let receive = async caller => {
+    Object.keys(AdminOnlyCallback.auditLog).forEach(k => Stdlib_Dict.$$delete(AdminOnlyCallback.auditLog, k));
+    let published = {
+      contents: []
+    };
+    let publish = async cmds => {
+      published.contents = cmds;
+    };
+    let result = await AdminOnlyCallback.receive(publish, payment, Capabilities$Reventless.none, caller, undefined);
+    let row = Object.values(AdminOnlyCallback.auditLog)[0];
+    return [
+      result,
+      published.contents,
+      row
+    ];
+  };
+  globalThis.test("with no caller, the door refuses and nothing is published", async () => {
+    let match = await receive(undefined);
+    let row = match[2];
+    globalThis.expect(Stdlib_Result.isError(match[0])).toBe(true);
+    globalThis.expect(match[1]).toEqual([]);
+    globalThis.expect(row.status).toBe("Failure");
+    globalThis.expect(row.error).toEqual("this door needs a caller");
+    globalThis.expect(row.caller).toEqual(undefined);
+  });
+  globalThis.test("a caller lacking the role is refused, and the row names who was refused", async () => {
+    let match = await receive(identity("u_visitor", ["Shopper"]));
+    let result = match[0];
+    if (result.TAG === "Ok") {
+      globalThis.expect(true).toBe(false);
+    } else {
+      let match$1 = result._0;
+      globalThis.expect(match$1.error).toBe("only an administrator may send this");
+      globalThis.expect(match$1.errorCode).toEqual(undefined);
+    }
+    globalThis.expect(match[1]).toEqual([]);
+    globalThis.expect(match[2].caller).toEqual("u_visitor");
+  });
+  globalThis.test("a caller holding the role is let through, and named", async () => {
+    let match = await receive(identity("u_admin", ["Admin"]));
+    let row = match[2];
+    globalThis.expect(Stdlib_Result.isOk(match[0])).toBe(true);
+    globalThis.expect(match[1].length).toBe(1);
+    globalThis.expect(row.status).toBe("Success");
+    globalThis.expect(row.caller).toEqual("u_admin");
+  });
+});
+
 export {
   PaymentWebhookTranslation,
   Callback,
@@ -436,5 +541,7 @@ export {
   catalogInput,
   NoteFeedTranslation,
   NoteFeedCallback,
+  AdminOnlyTranslation,
+  AdminOnlyCallback,
 }
 /* Callback Not a pure module */

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res

@@ -28,9 +28,14 @@ module PaymentWebhookSpec = {
 
   let targetName = "ConfirmPayment"
   let externalSystem = None
+  let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
   let endpoint = None
 
-  let translate = (input: externalInput) =>
+  let translate = async (
+    input: externalInput,
+    ~capabilities as _: Reventless.Capabilities.t,
+    ~caller as _: option<Reventless.Identity.t>,
+  ) =>
     switch input.status {
     | "completed" =>
       Ok([(input.orderId, ConfirmPayment({orderId: input.orderId, paymentId: input.paymentId}))])
@@ -53,6 +58,7 @@ module CatalogFeedSpec = {
 
   let targetName = "AddProduct"
   let externalSystem = None
+  let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
   let endpoint = None
 
   type role = Reventless.Role.name
@@ -65,7 +71,11 @@ module CatalogFeedSpec = {
     | _ => DenyAll
     }
 
-  let translate = (input: externalInput) =>
+  let translate = async (
+    input: externalInput,
+    ~capabilities as _: Reventless.Capabilities.t,
+    ~caller as _: option<Reventless.Identity.t>,
+  ) =>
     switch input.kind {
     | "product" => Ok([(input.id, AddProduct({productId: input.id}))])
     | "both" =>
@@ -91,9 +101,12 @@ module NoteFeedSpec = {
 
   let targetName = "Annotate"
   let externalSystem = None
+  let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
   let endpoint = None
 
-  let translate = (input: externalInput) => Ok([
-    (input.orderId, Annotate({orderId: input.orderId, note: None})),
-  ])
+  let translate = async (
+    input: externalInput,
+    ~capabilities as _: Reventless.Capabilities.t,
+    ~caller as _: option<Reventless.Identity.t>,
+  ) => Ok([(input.orderId, Annotate({orderId: input.orderId, note: None}))])
 }