@reventlessdev/reventless-core 3.0.0-alpha.250 → 3.0.0-alpha.252

package/tests/plugin/PluginStructureTest.res.mjs

@@ -30,6 +30,7 @@ import * as PsShipmentsView$ReventlessCore from "./StateViewSlice/PsShipmentsVie
 import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
 import * as PsCategoriesView$ReventlessCore from "./StateViewSlice/PsCategoriesView.res.mjs";
 import * as PsDispatchShipment$ReventlessCore from "./StateChangeSlice/PsDispatchShipment.res.mjs";
+import * as PsTransitionSwitch$ReventlessCore from "./StateChangeSlice/PsTransitionSwitch.res.mjs";
 import * as Capability_Inference$ReventlessCore from "../../src/plugin/component/Capability_Inference.res.mjs";
 import * as PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
 
@@ -53,6 +54,8 @@ let PsPlaceOrderSlice_Spec = {
   eventSchema: PsPlaceOrder$ReventlessCore.eventSchema,
   commandSchema: PsPlaceOrder$ReventlessCore.commandSchema,
   commandAuthorization: PsPlaceOrder$ReventlessCore.commandAuthorization,
+  commandTransition: PsPlaceOrder$ReventlessCore.commandTransition,
+  traits: PsPlaceOrder$ReventlessCore.traits,
   readConsistency: PsPlaceOrder$ReventlessCore.readConsistency
 };
 
@@ -83,6 +86,8 @@ let PsShipOrderSlice_Spec = {
   eventSchema: PsShipOrder$ReventlessCore.eventSchema,
   commandSchema: PsShipOrder$ReventlessCore.commandSchema,
   commandAuthorization: PsShipOrder$ReventlessCore.commandAuthorization,
+  commandTransition: PsShipOrder$ReventlessCore.commandTransition,
+  traits: PsShipOrder$ReventlessCore.traits,
   readConsistency: PsShipOrder$ReventlessCore.readConsistency
 };
 
@@ -243,6 +248,8 @@ let PsAttachInvoiceSlice_Spec = {
   eventSchema: PsAttachInvoice$ReventlessCore.eventSchema,
   commandSchema: PsAttachInvoice$ReventlessCore.commandSchema,
   commandAuthorization: PsAttachInvoice$ReventlessCore.commandAuthorization,
+  commandTransition: PsAttachInvoice$ReventlessCore.commandTransition,
+  traits: PsAttachInvoice$ReventlessCore.traits,
   readConsistency: PsAttachInvoice$ReventlessCore.readConsistency
 };
 
@@ -273,6 +280,8 @@ let PsUploadAvatarSlice_Spec = {
   eventSchema: PsUploadAvatar$ReventlessCore.eventSchema,
   commandSchema: PsUploadAvatar$ReventlessCore.commandSchema,
   commandAuthorization: PsUploadAvatar$ReventlessCore.commandAuthorization,
+  commandTransition: PsUploadAvatar$ReventlessCore.commandTransition,
+  traits: PsUploadAvatar$ReventlessCore.traits,
   readConsistency: PsUploadAvatar$ReventlessCore.readConsistency
 };
 
@@ -303,6 +312,8 @@ let PsUploadImagesSlice_Spec = {
   eventSchema: PsUploadImages$ReventlessCore.eventSchema,
   commandSchema: PsUploadImages$ReventlessCore.commandSchema,
   commandAuthorization: PsUploadImages$ReventlessCore.commandAuthorization,
+  commandTransition: PsUploadImages$ReventlessCore.commandTransition,
+  traits: PsUploadImages$ReventlessCore.traits,
   readConsistency: PsUploadImages$ReventlessCore.readConsistency
 };
 
@@ -333,6 +344,8 @@ let PsTypoStoreSlice_Spec = {
   eventSchema: PsTypoStore$ReventlessCore.eventSchema,
   commandSchema: PsTypoStore$ReventlessCore.commandSchema,
   commandAuthorization: PsTypoStore$ReventlessCore.commandAuthorization,
+  commandTransition: PsTypoStore$ReventlessCore.commandTransition,
+  traits: PsTypoStore$ReventlessCore.traits,
   readConsistency: PsTypoStore$ReventlessCore.readConsistency
 };
 
@@ -363,6 +376,8 @@ let PsChangePhotoSlice_Spec = {
   eventSchema: PsChangePhoto$ReventlessCore.eventSchema,
   commandSchema: PsChangePhoto$ReventlessCore.commandSchema,
   commandAuthorization: PsChangePhoto$ReventlessCore.commandAuthorization,
+  commandTransition: PsChangePhoto$ReventlessCore.commandTransition,
+  traits: PsChangePhoto$ReventlessCore.traits,
   readConsistency: PsChangePhoto$ReventlessCore.readConsistency
 };
 
@@ -393,6 +408,8 @@ let PsReserveStockSlice_Spec = {
   eventSchema: PsReserveStock$ReventlessCore.eventSchema,
   commandSchema: PsReserveStock$ReventlessCore.commandSchema,
   commandAuthorization: PsReserveStock$ReventlessCore.commandAuthorization,
+  commandTransition: PsReserveStock$ReventlessCore.commandTransition,
+  traits: PsReserveStock$ReventlessCore.traits,
   readConsistency: PsReserveStock$ReventlessCore.readConsistency
 };
 
@@ -423,6 +440,8 @@ let PsDispatchShipmentSlice_Spec = {
   eventSchema: PsDispatchShipment$ReventlessCore.eventSchema,
   commandSchema: PsDispatchShipment$ReventlessCore.commandSchema,
   commandAuthorization: PsDispatchShipment$ReventlessCore.commandAuthorization,
+  commandTransition: PsDispatchShipment$ReventlessCore.commandTransition,
+  traits: PsDispatchShipment$ReventlessCore.traits,
   readConsistency: PsDispatchShipment$ReventlessCore.readConsistency
 };
 
@@ -433,12 +452,44 @@ let PsDispatchShipmentSlice = {
   make: make$13
 };
 
+let Behavior$9 = {
+  initialState: false,
+  evolve: PsTransitionSwitch$ReventlessCore.evolve,
+  decide: PsTransitionSwitch$ReventlessCore.decide,
+  moduleUrl: PsTransitionSwitch$ReventlessCore.moduleUrl
+};
+
+function make$14(param, param$1, param$2, param$3, param$4, param$5) {
+  return 0;
+}
+
+let PsTransitionSwitchSlice_Spec = {
+  name: PsTransitionSwitch$ReventlessCore.name,
+  moduleUrl: PsTransitionSwitch$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsTransitionSwitch$ReventlessCore.consumedEventSchema,
+  errorSchema: PsTransitionSwitch$ReventlessCore.errorSchema,
+  eventSchema: PsTransitionSwitch$ReventlessCore.eventSchema,
+  commandSchema: PsTransitionSwitch$ReventlessCore.commandSchema,
+  commandAuthorization: PsTransitionSwitch$ReventlessCore.commandAuthorization,
+  commandTransition: PsTransitionSwitch$ReventlessCore.commandTransition,
+  traits: PsTransitionSwitch$ReventlessCore.traits,
+  readConsistency: PsTransitionSwitch$ReventlessCore.readConsistency
+};
+
+let PsTransitionSwitchSlice = {
+  Spec: PsTransitionSwitchSlice_Spec,
+  Behavior: Behavior$9,
+  isAsync: false,
+  make: make$14
+};
+
 let Projection$5 = {
   project: PsShipmentsView$ReventlessCore.project,
   moduleUrl: PsShipmentsView$ReventlessCore.moduleUrl
 };
 
-function make$14(param, param$1, param$2) {
+function make$15(param, param$1, param$2) {
   return 0;
 }
 
@@ -456,7 +507,7 @@ let PsShipmentsViewSlice_Spec = {
 let PsShipmentsViewSlice = {
   Spec: PsShipmentsViewSlice_Spec,
   Projection: Projection$5,
-  make: make$14
+  make: make$15
 };
 
 let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
@@ -529,6 +580,72 @@ globalThis.describe("lifecycle topology", () => {
   });
 });
 
+globalThis.describe("commandTransition — the edge as a switch", () => {
+  let structure = Plugin_Structure$ReventlessCore.make("TransitionSwitchPlugin", undefined, undefined, [], [PsTransitionSwitchSlice], undefined, undefined, undefined, undefined, undefined, undefined);
+  let slice = structure.stateChangeSlices[0];
+  let byName = name => slice.commands.find(c => c.name === name);
+  globalThis.test("the switch fills allowedStates and targetState", () => {
+    globalThis.expect([
+      Stdlib_Option.flatMap(byName("Book"), c => c.allowedStates),
+      Stdlib_Option.flatMap(byName("Book"), c => c.targetState)
+    ]).toEqual([
+      ["Draft"],
+      "Booked"
+    ]);
+  });
+  globalThis.test("a guard declares its from-set and no target", () => {
+    globalThis.expect([
+      Stdlib_Option.flatMap(byName("Rebook"), c => c.allowedStates),
+      Stdlib_Option.flatMap(byName("Rebook"), c => c.targetState)
+    ]).toEqual([
+      ["Booked"],
+      undefined
+    ]);
+  });
+  globalThis.test("the switch wins over an @transition on the same command", () => {
+    globalThis.expect(Stdlib_Option.flatMap(byName("Rebook"), c => c.allowedStates)).toEqual(["Booked"]);
+  });
+  globalThis.test("Unrestricted declares nothing, leaving the command unconstrained", () => {
+    globalThis.expect([
+      Stdlib_Option.flatMap(byName("Abandon"), c => c.allowedStates),
+      Stdlib_Option.flatMap(byName("Abandon"), c => c.targetState)
+    ]).toEqual([
+      undefined,
+      undefined
+    ]);
+  });
+});
+
+globalThis.describe("traitDeclarations — a graft leaves a trace", () => {
+  let structure = Plugin_Structure$ReventlessCore.make("TraitPlugin", undefined, undefined, [], [
+    PsTransitionSwitchSlice,
+    PsShipOrderSlice
+  ], undefined, undefined, undefined, undefined, undefined, undefined);
+  globalThis.test("a declaring component's trait reaches the structure", () => {
+    globalThis.expect(Stdlib_Option.getOr(structure.traitDeclarations, []).map(d => [
+      d.trait,
+      d.component
+    ])).toEqual([[
+        "@reventlessdev/trait-booking",
+        "TransitionSwitch"
+      ]]);
+  });
+  globalThis.test("the component name is filled in by the structure, not declared", () => {
+    globalThis.expect(Stdlib_Option.getOr(structure.traitDeclarations, []).map(d => [
+      d.version,
+      d.posture,
+      d.component
+    ])).toEqual([[
+        "9.9.9",
+        "SelfContained",
+        "TransitionSwitch"
+      ]]);
+  });
+  globalThis.test("a component that is nobody's graft contributes nothing", () => {
+    globalThis.expect(Stdlib_Option.getOr(structure.traitDeclarations, []).length).toBe(1);
+  });
+});
+
 globalThis.describe("@transition cross-check", () => {
   let buildBad = () => {
     try {
@@ -1448,6 +1565,78 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.test("a structure declaring nothing yields an empty list, not a missing manifest", () => {
         globalThis.expect(CapabilityManifest$Reventless.fromStructure(structure).capabilities).toEqual([]);
       });
+      globalThis.describe("declared capabilities", () => {
+        let withCapability_readModels = structure.readModels;
+        let withCapability_stateViewSlices = structure.stateViewSlices;
+        let withCapability_stateChangeSlices = structure.stateChangeSlices;
+        let withCapability_aggregates = structure.aggregates;
+        let withCapability_automationSlices = structure.automationSlices;
+        let withCapability_outboundTranslationSlices = structure.outboundTranslationSlices;
+        let withCapability_inboundTranslationSlices = structure.inboundTranslationSlices;
+        let withCapability_extensions = structure.extensions;
+        let withCapability_extensionPoints = structure.extensionPoints;
+        let withCapability_requiredStores = structure.requiredStores;
+        let withCapability_requiredStoreDeclarations = structure.requiredStoreDeclarations;
+        let withCapability_requiredCapabilities = [
+          {
+            capability: "Geocoding",
+            component: "GeocodeAddress"
+          },
+          {
+            capability: "Geocoding",
+            component: "GeocodeDropOff"
+          }
+        ];
+        let withCapability = {
+          readModels: withCapability_readModels,
+          stateViewSlices: withCapability_stateViewSlices,
+          stateChangeSlices: withCapability_stateChangeSlices,
+          aggregates: withCapability_aggregates,
+          automationSlices: withCapability_automationSlices,
+          outboundTranslationSlices: withCapability_outboundTranslationSlices,
+          inboundTranslationSlices: withCapability_inboundTranslationSlices,
+          extensions: withCapability_extensions,
+          extensionPoints: withCapability_extensionPoints,
+          requiredStores: withCapability_requiredStores,
+          requiredStoreDeclarations: withCapability_requiredStoreDeclarations,
+          requiredCapabilities: withCapability_requiredCapabilities,
+          traitDeclarations: undefined
+        };
+        let entries = CapabilityManifest$Reventless.fromStructure(withCapability).capabilities;
+        globalThis.test("two components needing one capability yield one entry", () => {
+          globalThis.expect(entries.map(e => e.key)).toEqual(["Geocoding"]);
+        });
+        globalThis.test("both declaring components are kept, with no field", () => {
+          globalThis.expect(entries[0].declaredBy).toEqual([
+            {
+              component: "GeocodeAddress"
+            },
+            {
+              component: "GeocodeDropOff"
+            }
+          ]);
+        });
+        globalThis.test("a capability this build does not know is dropped", () => {
+          globalThis.expect(CapabilityManifest$Reventless.fromStructure({
+            readModels: structure.readModels,
+            stateViewSlices: structure.stateViewSlices,
+            stateChangeSlices: structure.stateChangeSlices,
+            aggregates: structure.aggregates,
+            automationSlices: structure.automationSlices,
+            outboundTranslationSlices: structure.outboundTranslationSlices,
+            inboundTranslationSlices: structure.inboundTranslationSlices,
+            extensions: structure.extensions,
+            extensionPoints: structure.extensionPoints,
+            requiredStores: structure.requiredStores,
+            requiredStoreDeclarations: structure.requiredStoreDeclarations,
+            requiredCapabilities: [{
+                capability: "Telepathy",
+                component: "Guess"
+              }],
+            traitDeclarations: undefined
+          }).capabilities).toEqual([]);
+        });
+      });
       globalThis.test("rendering is deterministic and newline-terminated", () => {
         let rendered = CapabilityManifest$Reventless.renderForStructure(withStores);
         globalThis.expect(rendered).toBe(`{
@@ -1662,7 +1851,7 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       let withHeuristicField = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [PsChangePhotoSlice], undefined, undefined, undefined, undefined, undefined, undefined);
       globalThis.expect(withHeuristicField.requiredStores).toEqual(["TestPlugin.productPhotos"]);
       let manifest = CapabilityManifest$Reventless.fromStructure(withHeuristicField);
-      globalThis.expect(manifest.capabilities.every(entry => entry.declaredBy.every(site => site.field !== "photoUrl"))).toBe(true);
+      globalThis.expect(manifest.capabilities.every(entry => entry.declaredBy.every(site => Primitive_object.notequal(site.field, "photoUrl")))).toBe(true);
     });
     globalThis.test("the warning names the field and the settling annotation", () => {
       let text = Capability_Inference$ReventlessCore.message(commandWarnings[0]);
@@ -1731,6 +1920,186 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
   });
 });
 
+globalThis.describe("the port's translation table", () => {
+  let failures = declared => Plugin_Structure$ReventlessCore.translationTableFailures("Catalog.Products ← Product", declared, [
+    "ProductBecameAvailable",
+    "ProductWithdrawn"
+  ], [
+    "Added",
+    "Archived",
+    "Discontinued",
+    "Renamed"
+  ]);
+  globalThis.test("accepts a many-to-one declaration", () => {
+    globalThis.expect(failures([{
+        name: "ProductWithdrawn",
+        fromEventTypes: [
+          "Archived",
+          "Discontinued"
+        ]
+      }]).length).toBe(0);
+  });
+  globalThis.test("rejects a published name the extension point does not declare", () => {
+    globalThis.expect(failures([{
+        name: "ProductRetired",
+        fromEventTypes: ["Archived"]
+      }]).length).toBe(1);
+  });
+  globalThis.test("rejects a source name the delegate does not declare", () => {
+    globalThis.expect(failures([{
+        name: "ProductWithdrawn",
+        fromEventTypes: ["Archivd"]
+      }]).length).toBe(1);
+  });
+});
+
+globalThis.describe("the translation table against the probe", () => {
+  let declared = [{
+      name: "ProductWithdrawn",
+      fromEventTypes: [
+        "Archived",
+        "Discontinued"
+      ]
+    }];
+  let drift = (observed, followed) => Plugin_Structure$ReventlessCore.translationTableDrift("EP", declared, observed, followed);
+  globalThis.test("says nothing when the arms produce what was declared", () => {
+    let match = drift([
+      [
+        "Archived",
+        "ProductWithdrawn"
+      ],
+      [
+        "Discontinued",
+        "ProductWithdrawn"
+      ]
+    ], [
+      "Archived",
+      "Discontinued"
+    ]);
+    globalThis.expect([
+      match[0].length,
+      match[1].length
+    ]).toEqual([
+      0,
+      0
+    ]);
+  });
+  globalThis.test("fails on an edge the probe saw and the declaration omits", () => {
+    let match = drift([[
+        "Archived",
+        "ProductRelisted"
+      ]], ["Archived"]);
+    globalThis.expect(match[0].length).toBe(1);
+  });
+  globalThis.test("only warns on a declared edge the probe did not see", () => {
+    let match = drift([[
+        "Archived",
+        "ProductWithdrawn"
+      ]], [
+      "Archived",
+      "Discontinued"
+    ]);
+    globalThis.expect([
+      match[0].length,
+      match[1].length
+    ]).toEqual([
+      0,
+      1
+    ]);
+  });
+  globalThis.test("judges nothing about a source the probe could not follow", () => {
+    let match = drift([], []);
+    globalThis.expect([
+      match[0].length,
+      match[1].length
+    ]).toEqual([
+      0,
+      0
+    ]);
+  });
+});
+
+globalThis.describe("the subscriber's half of the table", () => {
+  let failures = declared => Plugin_Structure$ReventlessCore.handledTableFailures("Catalog.Products → SyncCatalogProduct", declared, ["ProductBecameAvailable"], [
+    "SyncNewProduct",
+    "AckProduct"
+  ]);
+  globalThis.test("accepts a delegate command and an extension point command alike", () => {
+    globalThis.expect(failures([{
+        name: "ProductBecameAvailable",
+        toCommandTypes: [
+          "SyncNewProduct",
+          "AckProduct"
+        ]
+      }]).length).toBe(0);
+  });
+  globalThis.test("rejects a handled event the extension point does not publish", () => {
+    globalThis.expect(failures([{
+        name: "ProductAdded",
+        toCommandTypes: ["SyncNewProduct"]
+      }]).length).toBe(1);
+  });
+  globalThis.test("rejects a command neither side declares", () => {
+    globalThis.expect(failures([{
+        name: "ProductBecameAvailable",
+        toCommandTypes: ["SyncNewProdct"]
+      }]).length).toBe(1);
+  });
+});
+
+globalThis.describe("duplicate DCB command names", () => {
+  globalThis.test("two slices declaring one command are refused", () => {
+    let tmp;
+    try {
+      Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [
+        PsShipOrderSlice,
+        PsShipOrderSlice
+      ], undefined, undefined, undefined, undefined, undefined, undefined);
+      tmp = false;
+    } catch (exn) {
+      tmp = true;
+    }
+    globalThis.expect(tmp).toBe(true);
+  });
+  globalThis.test("the refusal names the command and both slices", () => {
+    let val;
+    try {
+      val = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [
+        PsShipOrderSlice,
+        PsShipOrderSlice
+      ], undefined, undefined, undefined, undefined, undefined, undefined);
+    } catch (raw_e) {
+      let e = Primitive_exceptions.internalToException(raw_e);
+      if (e.RE_EXN_ID === "JsExn") {
+        let message = Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "");
+        globalThis.expect([
+          message.includes("ShipOrder"),
+          message.includes("routes a command by its bare name")
+        ]).toEqual([
+          true,
+          true
+        ]);
+        return;
+      }
+      throw e;
+    }
+    globalThis.expect("no refusal").toBe("a refusal naming the command");
+  });
+  globalThis.test("distinct command names are fine", () => {
+    let tmp;
+    try {
+      Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [
+        PsPlaceOrderSlice,
+        PsShipOrderSlice
+      ], undefined, undefined, undefined, undefined, undefined, undefined);
+      tmp = true;
+    } catch (exn) {
+      tmp = false;
+    }
+    globalThis.expect(tmp).toBe(true);
+  });
+});
+
 export {
   PsPlaceOrderSlice,
   PsShipOrderSlice,
@@ -1746,6 +2115,7 @@ export {
   PsChangePhotoSlice,
   PsReserveStockSlice,
   PsDispatchShipmentSlice,
+  PsTransitionSwitchSlice,
   PsShipmentsViewSlice,
   structure,
 }

package/tests/plugin/StateChangeSlice/PsAttachInvoice.res.mjs

@@ -36,6 +36,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "AttachInvoice";
 
 let Id;
@@ -59,5 +65,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsChangePhoto.res.mjs

@@ -37,6 +37,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "ChangePhoto";
 
 let Id;
@@ -60,5 +66,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsDispatchShipment.res.mjs

@@ -46,6 +46,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "DispatchShipment";
 
 let Id;
@@ -69,5 +75,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsGatedCommands.res.mjs

@@ -57,6 +57,12 @@ function commandAuthorization(command) {
   }
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "GatedCommands";
 
 let Id;
@@ -80,5 +86,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsPlaceOrder.res.mjs

@@ -35,6 +35,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "PlaceOrder";
 
 let Id;
@@ -58,5 +64,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsReserveStock.res.mjs

@@ -40,6 +40,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "ReserveStock";
 
 let Id;
@@ -63,5 +69,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsShipOrder.res.mjs

@@ -61,6 +61,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "ShipOrder";
 
 let Id;
@@ -84,5 +90,7 @@ export {
   moduleUrl,
   commandAuthorization,
   readConsistency,
+  commandTransition,
+  traits,
 }
 /* consumedEventSchema Not a pure module */