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

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res

@@ -224,11 +224,8 @@ describe("InboundTranslationSlice Callback", () => {
 
           type role = Reventless.Role.name
 
-          let commandAuthorization = (_: command): Reventless.Authorization.rule<role> =>
+          let authorizationOf = (_: string): Reventless.Authorization.rule<role> =>
             AllowAuthenticated
-          type lifecycleState = unit
-          let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> =>
-            Unrestricted
         }
 
         module MultiTranslation = {
@@ -293,11 +290,8 @@ describe("InboundTranslationSlice Callback", () => {
 
           type role = Reventless.Role.name
 
-          let commandAuthorization = (_: command): Reventless.Authorization.rule<role> =>
+          let authorizationOf = (_: string): 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
+  authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.authorizationOf
 })(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) {
@@ -185,8 +186,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
           }
         ])
       });
-      let commandAuthorization = param => "AllowAuthenticated";
-      let commandTransition = param => "Unrestricted";
+      let authorizationOf = param => "AllowAuthenticated";
       let MultiTranslation = {
         translate: translate,
         moduleUrl: moduleUrl
@@ -198,8 +198,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         commandSchema: commandSchema,
         targetName: "ConfirmPayment",
         externalSystem: undefined,
-        commandAuthorization: commandAuthorization,
-        commandTransition: commandTransition
+        authorizationOf: authorizationOf
       })(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([
@@ -249,8 +248,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         TAG: "Ok",
         _0: []
       });
-      let commandAuthorization = param => "AllowAuthenticated";
-      let commandTransition = param => "Unrestricted";
+      let authorizationOf = param => "AllowAuthenticated";
       let EmptyTranslation = {
         translate: translate,
         moduleUrl: moduleUrl
@@ -262,8 +260,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
         commandSchema: commandSchema,
         targetName: "ConfirmPayment",
         externalSystem: undefined,
-        commandAuthorization: commandAuthorization,
-        commandTransition: commandTransition
+        authorizationOf: authorizationOf
       })(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,
+  authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.CatalogFeedSpec.authorizationOf
+})(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,
+  authorizationOf: InboundTranslationSliceFixtures$ReventlessLocal.NoteFeedSpec.authorizationOf
+})(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,61 @@ 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 authorizationOf = (name: string): Reventless.Authorization.rule<role> =>
+    switch name {
+    | "AddProduct" => AllowRoles([merchandiser])
+    | "AddCategory" => AllowRoles([admin])
+    | _ => DenyAll
+    }
+
+  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

@@ -52,14 +52,10 @@ function translate(input) {
   }
 }
 
-function commandAuthorization(param) {
+function authorizationOf(param) {
   return "AllowAuthenticated";
 }
 
-function commandTransition(param) {
-  return "Undeclared";
-}
-
 let traits = [];
 
 let PaymentWebhookSpec = {
@@ -70,13 +66,155 @@ let PaymentWebhookSpec = {
   targetName: "ConfirmPayment",
   externalSystem: undefined,
   translate: translate,
-  commandAuthorization: commandAuthorization,
-  commandTransition: commandTransition,
+  authorizationOf: authorizationOf,
   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 authorizationOf$1(name) {
+  switch (name) {
+    case "AddCategory" :
+      return {
+        TAG: "AllowRoles",
+        _0: [admin]
+      };
+    case "AddProduct" :
+      return {
+        TAG: "AllowRoles",
+        _0: [merchandiser]
+      };
+    default:
+      return "DenyAll";
+  }
+}
+
+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,
+  authorizationOf: authorizationOf$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 authorizationOf$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,
+  authorizationOf: authorizationOf$2,
+  traits: traits$2
+};
+
 export {
   OrderEventLog,
   PaymentWebhookSpec,
+  CatalogFeedSpec,
+  NoteFeedSpec,
 }
 /* moduleUrl Not a pure module */

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformFixtures.res.mjs

@@ -37,7 +37,7 @@ let commandSchema = Sury.$schema(s => ({
 
 let errorSchema = Sury.literal("AlreadyPlaced");
 
-function commandAuthorization(param) {
+function authorizationOf(param) {
   return "AllowAuthenticated";
 }
 
@@ -55,7 +55,7 @@ let PlaceSpec = {
   consumedEventSchema: consumedEventSchema,
   errorSchema: errorSchema,
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization,
+  authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits,
   readConsistency: "EscalateOnRetry"
@@ -222,7 +222,7 @@ let PlaceMaker = StateChangeSlice_Builder$ReventlessLocal.Make({
   errorSchema: errorSchema,
   eventSchema: eventSchema,
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization,
+  authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits,
   readConsistency: "EscalateOnRetry"