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

package/tests/commandtopic/CommandOutcomeHookTest.res.mjs

@@ -65,6 +65,8 @@ let SliceHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,
   commandSchema: DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema,
   commandAuthorization: DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization,
+  commandTransition: DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition,
+  traits: DcbFixtures$ReventlessCore.TestCommandSpec.traits,
   readConsistency: DcbFixtures$ReventlessCore.TestCommandSpec.readConsistency
 })(SliceBehavior);
 

package/tests/commandtopic/CommandTopicCallbackFixtures.res.mjs

@@ -25,11 +25,19 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let TestSpec = {
   Id: undefined,
   name: name,
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let capturedItems = {
@@ -64,7 +72,9 @@ let TestOps_Spec = {
   Id: Id$Reventless.StringPure,
   name: name,
   commandSchema: commandSchema,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let TestOps = {

package/tests/dcb/DcbFixtures.res.mjs

@@ -156,6 +156,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let TestCommandSpec_initialState = {
   exists: false,
   currentName: undefined
@@ -173,6 +179,8 @@ let TestCommandSpec = {
   evolve: evolve,
   decide: decide,
   commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
   readConsistency: "EscalateOnRetry"
 };
 

package/tests/dcb/DcbStateChangeSliceTest.res.mjs

@@ -61,6 +61,8 @@ let TestHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: DcbFixtures$ReventlessCore.TestCommandSpec.eventSchema,
   commandSchema: DcbFixtures$ReventlessCore.TestCommandSpec.commandSchema,
   commandAuthorization: DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization,
+  commandTransition: DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition,
+  traits: DcbFixtures$ReventlessCore.TestCommandSpec.traits,
   readConsistency: DcbFixtures$ReventlessCore.TestCommandSpec.readConsistency
 })(TestCommandBehavior);
 
@@ -78,6 +80,10 @@ let errorSchema = DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema;
 
 let commandAuthorization = DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization;
 
+let commandTransition = DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition;
+
+let traits = DcbFixtures$ReventlessCore.TestCommandSpec.traits;
+
 let StrongSpec_Id = DcbFixtures$ReventlessCore.TestCommandSpec.Id;
 
 let StrongSpec_initialState = DcbFixtures$ReventlessCore.TestCommandSpec.initialState;
@@ -98,6 +104,8 @@ let StrongSpec = {
   evolve: StrongSpec_evolve,
   decide: StrongSpec_decide,
   commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
   readConsistency: "AlwaysStrong"
 };
 
@@ -115,6 +123,10 @@ let errorSchema$1 = DcbFixtures$ReventlessCore.TestCommandSpec.errorSchema;
 
 let commandAuthorization$1 = DcbFixtures$ReventlessCore.TestCommandSpec.commandAuthorization;
 
+let commandTransition$1 = DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition;
+
+let traits$1 = DcbFixtures$ReventlessCore.TestCommandSpec.traits;
+
 let EventualSpec_Id = DcbFixtures$ReventlessCore.TestCommandSpec.Id;
 
 let EventualSpec_initialState = DcbFixtures$ReventlessCore.TestCommandSpec.initialState;
@@ -135,6 +147,8 @@ let EventualSpec = {
   evolve: EventualSpec_evolve,
   decide: EventualSpec_decide,
   commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
   readConsistency: "AlwaysEventual"
 };
 
@@ -147,6 +161,8 @@ let StrongHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: eventSchema,
   commandSchema: commandSchema,
   commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits,
   readConsistency: "AlwaysStrong"
 })(TestCommandBehavior);
 
@@ -159,6 +175,8 @@ let EventualHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   eventSchema: eventSchema$1,
   commandSchema: commandSchema$1,
   commandAuthorization: commandAuthorization$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1,
   readConsistency: "AlwaysEventual"
 })(TestCommandBehavior);
 

package/tests/eventmapper/EventMapperFixtures.res.mjs

@@ -153,12 +153,20 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let CmdTargetSpec = {
   Id: undefined,
   name: name$3,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl$2,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 function map(id, event, _queryEngine) {
@@ -233,7 +241,9 @@ let OrderMappings_Target = {
   name: name$3,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl$2,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let OrderMappings = {
@@ -262,7 +272,9 @@ let CountOrderMappings_Target = {
   name: name$3,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl$2,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let CountOrderMappings = {

package/tests/extensionpoint/ExtensionPointFixtures.res.mjs

@@ -30,13 +30,21 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let TestEPSpec = {
   name: name,
   commandSchema: commandSchema,
   eventSchema: eventSchema,
   directiveSchema: directiveSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let capturedPublishedCmds = {

package/tests/extensionpoint/ExtensionPointOperationsTest.res.mjs

@@ -25,13 +25,21 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let OpsEPSpec = {
   name: name,
   commandSchema: commandSchema,
   eventSchema: eventSchema,
   directiveSchema: directiveSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 let capturedPublished = {

package/tests/message/MessageTest.res

@@ -133,6 +133,8 @@ describe("Message should", () => {
         extensionPoints: None,
         requiredStores: None,
         requiredStoreDeclarations: None,
+        requiredCapabilities: None,
+        traitDeclarations: None,
       })),
       dcbEventLog: None,
       kind: Domain,

package/tests/message/MessageTest.res.mjs

@@ -124,7 +124,9 @@ globalThis.describe("Message should", () => {
           extensions: [],
           extensionPoints: undefined,
           requiredStores: undefined,
-          requiredStoreDeclarations: undefined
+          requiredStoreDeclarations: undefined,
+          requiredCapabilities: undefined,
+          traitDeclarations: undefined
         }
       },
       dcbEventLog: undefined,

package/tests/plugin/PluginStructureAccessTest.res.mjs

@@ -28,6 +28,8 @@ let PsGatedCommandsSlice_Spec = {
   eventSchema: PsGatedCommands$ReventlessCore.eventSchema,
   commandSchema: PsGatedCommands$ReventlessCore.commandSchema,
   commandAuthorization: PsGatedCommands$ReventlessCore.commandAuthorization,
+  commandTransition: PsGatedCommands$ReventlessCore.commandTransition,
+  traits: PsGatedCommands$ReventlessCore.traits,
   readConsistency: PsGatedCommands$ReventlessCore.readConsistency
 };
 

package/tests/plugin/PluginStructureTest.res

@@ -185,6 +185,19 @@ module PsDispatchShipmentSlice: ReventlessInfra.StateChangeSlice.T = {
   type component = scsComponent
   let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
 }
+module PsTransitionSwitchSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsTransitionSwitch
+  module Behavior = {
+    type state = PsTransitionSwitch.state
+    let initialState = PsTransitionSwitch.initialState
+    let evolve = PsTransitionSwitch.evolve
+    let decide = PsTransitionSwitch.decide
+    let moduleUrl = PsTransitionSwitch.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
+}
 module PsShipmentsViewSlice: ReventlessInfra.StateViewSlice.T = {
   module Spec = PsShipmentsView
   module Projection = {
@@ -290,6 +303,87 @@ describe("lifecycle topology", () => {
   })
 })
 
+describe("commandTransition — the edge as a switch", () => {
+  // The seam a variant spread needs. `@transition` lowers to a dict on the
+  // parent union keyed by variant name, and a spread splices members, so a
+  // command a host did not declare cannot be annotated at all. A switch over the
+  // command reaches every constructor, spliced or not, and the compiler makes
+  // it exhaustive.
+  let structure = Plugin_Structure.make(
+    ~name="TransitionSwitchPlugin",
+    ~stateChangeSlices=[module(PsTransitionSwitchSlice)],
+    ~stateViewSlices=[],
+  )
+  let slice = structure.stateChangeSlices->Array.getUnsafe(0)
+  let byName = name => slice.commands->Array.find(c => c.name == name)
+
+  testSync("the switch fills allowedStates and targetState", () => {
+    expect((
+      byName("Book")->Option.flatMap(c => c.allowedStates),
+      byName("Book")->Option.flatMap(c => c.targetState),
+    ))->toEqual((Some(["Draft"]), Some("Booked")))
+  })
+
+  testSync("a guard declares its from-set and no target", () => {
+    // The same positive claim the one-sided `@transition` makes: legal in these
+    // states, and it moves the row nowhere.
+    expect((
+      byName("Rebook")->Option.flatMap(c => c.allowedStates),
+      byName("Rebook")->Option.flatMap(c => c.targetState),
+    ))->toEqual((Some(["Booked"]), None))
+  })
+
+  testSync("the switch wins over an @transition on the same command", () => {
+    // `Rebook` carries both, and they disagree on purpose: the attribute says
+    // Draft. Two sources of truth need a stated winner, and it is the one the
+    // compiler checked.
+    expect(byName("Rebook")->Option.flatMap(c => c.allowedStates))->toEqual(Some(["Booked"]))
+  })
+
+  testSync("Unrestricted declares nothing, leaving the command unconstrained", () => {
+    // Distinct from a from-set naming every state, which says the same thing to
+    // a menu and something different to a reader.
+    expect((
+      byName("Abandon")->Option.flatMap(c => c.allowedStates),
+      byName("Abandon")->Option.flatMap(c => c.targetState),
+    ))->toEqual((None, None))
+  })
+})
+
+describe("traitDeclarations — a graft leaves a trace", () => {
+  // The one signal a graft leaves that survives into a deployed plugin. Every
+  // other one — the package dependency, the variant spread, the rules alias, the
+  // conformance binding — is source-side and invisible to a running estate.
+  let structure = Plugin_Structure.make(
+    ~name="TraitPlugin",
+    ~stateChangeSlices=[module(PsTransitionSwitchSlice), module(PsShipOrderSlice)],
+    ~stateViewSlices=[],
+  )
+
+  testSync("a declaring component's trait reaches the structure", () => {
+    expect(
+      structure.traitDeclarations->Option.getOr([])->Array.map(d => (d.trait, d.component)),
+    )->toEqual([("@reventlessdev/trait-booking", "TransitionSwitch")])
+  })
+
+  testSync("the component name is filled in by the structure, not declared", () => {
+    // The trait exports its identity and posture; it cannot know which component a
+    // host grafted it onto, and a host writing that name down would be the one
+    // hand-typed string this mechanism exists to avoid.
+    expect(
+      structure.traitDeclarations
+      ->Option.getOr([])
+      ->Array.map(d => (d.version, d.posture, d.component)),
+    )->toEqual([("9.9.9", "SelfContained", "TransitionSwitch")])
+  })
+
+  testSync("a component that is nobody's graft contributes nothing", () => {
+    // `PsShipOrder` declares no traits, and the injected default is empty — so the
+    // absence of a graft is silence rather than a row.
+    expect(structure.traitDeclarations->Option.getOr([])->Array.length)->toBe(1)
+  })
+})
+
 describe("@transition cross-check", () => {
   // The exit criterion: a state no linked view declares stops the build, and the
   // message says which command, which state, and what it was checked against.
@@ -1366,6 +1460,45 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         expect(Reventless.CapabilityManifest.fromStructure(structure).capabilities)->toEqual([])
       )
 
+      // A capability a slice declares rides the same manifest as the stores, so
+      // the platform generator reads one file. It carries no `field`: nothing
+      // annotated it, and naming one would be a fiction.
+      describe("declared capabilities", () => {
+        let withCapability = {
+          ...structure,
+          requiredCapabilities: Some([
+            ({capability: "Geocoding", component: "GeocodeAddress"}: Reventless.Plugin.requiredCapabilityDeclaration),
+            {capability: "Geocoding", component: "GeocodeDropOff"},
+          ]),
+          traitDeclarations: None,
+        }
+        let entries = Reventless.CapabilityManifest.fromStructure(withCapability).capabilities
+
+        testSync("two components needing one capability yield one entry", () =>
+          expect(entries->Array.map(e => e.key))->toEqual(["Geocoding"])
+        )
+
+        testSync("both declaring components are kept, with no field", () =>
+          expect((entries->Array.getUnsafe(0)).declaredBy)->toEqual([
+            ({component: "GeocodeAddress"}: Reventless.CapabilityManifest.provenance),
+            {component: "GeocodeDropOff"},
+          ])
+        )
+
+        // The generator downstream renders a real `Platform.capability` arm, and
+        // a name this build cannot map has no arm to render — so it is dropped
+        // here rather than passed through as an unrenderable key.
+        testSync("a capability this build does not know is dropped", () =>
+          expect(
+            Reventless.CapabilityManifest.fromStructure({
+              ...structure,
+              requiredCapabilities: Some([{capability: "Telepathy", component: "Guess"}]),
+              traitDeclarations: None,
+            }).capabilities,
+          )->toEqual([])
+        )
+      })
+
       testSync("rendering is deterministic and newline-terminated", () => {
         let rendered = Reventless.CapabilityManifest.renderForStructure(withStores)
         expect(rendered)->toBe(
@@ -1671,7 +1804,7 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       let manifest = Reventless.CapabilityManifest.fromStructure(withHeuristicField)
       expect(
         manifest.capabilities->Array.every(entry =>
-          entry.declaredBy->Array.every(site => site.field != "photoUrl")
+          entry.declaredBy->Array.every(site => site.field != Some("photoUrl"))
         ),
       )->toBe(true)
     })
@@ -1747,3 +1880,163 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     })
   })
 })
+
+// The port's translation table — the pure halves of the check. The probe itself
+// needs a mapping module and is exercised by the examples' own build.
+describe("the port's translation table", () => {
+  let published = (name, fromEventTypes): ReventlessInfra.ExtensionPointMapping.publishedEvent => {
+    name,
+    fromEventTypes,
+  }
+  let failures = (~declared) =>
+    Plugin_Structure.translationTableFailures(
+      ~label="Catalog.Products ← Product",
+      ~declared,
+      ~publishedNames=["ProductBecameAvailable", "ProductWithdrawn"],
+      ~sourceNames=["Added", "Archived", "Discontinued", "Renamed"],
+    )
+
+  testSync("accepts a many-to-one declaration", () =>
+    expect(
+      failures(~declared=[published("ProductWithdrawn", ["Archived", "Discontinued"])])->Array.length,
+    )->toBe(0)
+  )
+
+  testSync("rejects a published name the extension point does not declare", () =>
+    expect(
+      failures(~declared=[published("ProductRetired", ["Archived"])])->Array.length,
+    )->toBe(1)
+  )
+
+  testSync("rejects a source name the delegate does not declare", () =>
+    expect(
+      failures(~declared=[published("ProductWithdrawn", ["Archivd"])])->Array.length,
+    )->toBe(1)
+  )
+
+})
+
+describe("the translation table against the probe", () => {
+  let declared = [
+    ({
+      ReventlessInfra.ExtensionPointMapping.name: "ProductWithdrawn",
+      fromEventTypes: ["Archived", "Discontinued"],
+    }: ReventlessInfra.ExtensionPointMapping.publishedEvent),
+  ]
+  let drift = (~observed, ~followed) =>
+    Plugin_Structure.translationTableDrift(~label="EP", ~declared, ~observed, ~followed)
+
+  testSync("says nothing when the arms produce what was declared", () => {
+    let (failures, warnings) = drift(
+      ~observed=[("Archived", "ProductWithdrawn"), ("Discontinued", "ProductWithdrawn")],
+      ~followed=["Archived", "Discontinued"],
+    )
+    expect((failures->Array.length, warnings->Array.length))->toEqual((0, 0))
+  })
+
+  // The probe watched the arm publish it, so the declaration is stale.
+  testSync("fails on an edge the probe saw and the declaration omits", () => {
+    let (failures, _) = drift(
+      ~observed=[("Archived", "ProductRelisted")],
+      ~followed=["Archived"],
+    )
+    expect(failures->Array.length)->toBe(1)
+  })
+
+  // The arm may branch on a payload the probe cannot synthesise.
+  testSync("only warns on a declared edge the probe did not see", () => {
+    let (failures, warnings) = drift(
+      ~observed=[("Archived", "ProductWithdrawn")],
+      ~followed=["Archived", "Discontinued"],
+    )
+    expect((failures->Array.length, warnings->Array.length))->toEqual((0, 1))
+  })
+
+  // "Did not look" must not read as "no edge".
+  testSync("judges nothing about a source the probe could not follow", () => {
+    let (failures, warnings) = drift(~observed=[], ~followed=[])
+    expect((failures->Array.length, warnings->Array.length))->toEqual((0, 0))
+  })
+})
+
+describe("the subscriber's half of the table", () => {
+  let handled = (name, toCommandTypes): ReventlessInfra.ExtensionMapping.handledEvent => {
+    name,
+    toCommandTypes,
+  }
+  let failures = declared =>
+    Plugin_Structure.handledTableFailures(
+      ~label="Catalog.Products → SyncCatalogProduct",
+      ~declared,
+      ~eventNames=["ProductBecameAvailable"],
+      // The delegate's commands and the extension point's own, resolved as one set.
+      ~commandNames=["SyncNewProduct", "AckProduct"],
+    )
+
+  testSync("accepts a delegate command and an extension point command alike", () =>
+    expect(
+      failures([handled("ProductBecameAvailable", ["SyncNewProduct", "AckProduct"])])->Array.length,
+    )->toBe(0)
+  )
+
+  testSync("rejects a handled event the extension point does not publish", () =>
+    expect(failures([handled("ProductAdded", ["SyncNewProduct"])])->Array.length)->toBe(1)
+  )
+
+  testSync("rejects a command neither side declares", () =>
+    expect(
+      failures([handled("ProductBecameAvailable", ["SyncNewProdct"])])->Array.length,
+    )->toBe(1)
+  )
+})
+
+// ── One command name, one handler ────────────────────────────────────────────
+//
+// A DCB plugin routes a command by its bare type name, so two slices declaring
+// one name have one handler between them. The runtime notices only when it goes
+// to stamp owner fields — by which point the deploy has succeeded and the losing
+// slice is silently unreachable — so the structure refuses it instead.
+
+describe("duplicate DCB command names", () => {
+  // The same slice twice is the smallest possible collision, and it needs no
+  // fixture that exists only to collide.
+  testSync("two slices declaring one command are refused", () =>
+    expect(
+      switch Plugin_Structure.make(
+        ~name="TestPlugin",
+        ~stateChangeSlices=[module(PsShipOrderSlice), module(PsShipOrderSlice)],
+      ) {
+      | _ => false
+      | exception _ => true
+      },
+    )->toBe(true)
+  )
+
+  testSync("the refusal names the command and both slices", () =>
+    switch Plugin_Structure.make(
+      ~name="TestPlugin",
+      ~stateChangeSlices=[module(PsShipOrderSlice), module(PsShipOrderSlice)],
+    ) {
+    | _ => expect("no refusal")->toBe("a refusal naming the command")
+    | exception JsExn(e) =>
+      let message = e->JsExn.message->Option.getOr("")
+      expect((
+        message->String.includes("ShipOrder"),
+        message->String.includes("routes a command by its bare name"),
+      ))->toEqual((true, true))
+    }
+  )
+
+  // Distinct names are the ordinary case and must stay silent.
+  testSync("distinct command names are fine", () =>
+    expect(
+      switch Plugin_Structure.make(
+        ~name="TestPlugin",
+        ~stateChangeSlices=[module(PsPlaceOrderSlice), module(PsShipOrderSlice)],
+      ) {
+      | _ => true
+      | exception _ => false
+      },
+    )->toBe(true)
+  )
+})