@reventlessdev/reventless-gwt 1.0.0-alpha.219 → 1.0.0-alpha.220

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.220 (2026-09-24)
+
+### Features
+
+* **dcb:** a command reference no decision reads by stays out of the query ([3ae149a](https://github.com/ReventlessDev/reventless-core/commit/3ae149ae91ebab63413be57df5827c5fd4390160))
+
+
 # 1.0.0-alpha.219 (2026-09-23)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.219",
+  "version": "1.0.0-alpha.220",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -16,15 +16,15 @@
     "sury": "11.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.173",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.273",
     "@reventlessdev/rescript-node": "2.0.0-alpha.15",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.272",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.172",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.144"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.145"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.89"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.92"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/Behavior_GWT.res

@@ -280,6 +280,14 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
   // emitted event (payload, not a read key) is narrowed out of a cross-partition
   // clause — the same dead-clause removal the runtime threads.
   let tagKeysByEventType = Reventless.DcbScopeInference.infer([scopeShape]).tagKeysByEventType
+  // Command keys this slice does not decide by stay out of the query (rule 4),
+  // judged against the partition the slice resolves to on its own.
+  let payloadTagKeys = scopeShape->Reventless.DcbTag.commandPayloadTagKeys(
+    ~partitionTag=Reventless.DcbScopeInference.resolvePartitions([scopeShape]).partitionBySlice
+    ->Dict.get("")
+    ->Option.map(key => Reventless.DcbTag.Simple({key: key})),
+    ~crossPartitionTagKeys,
+  )
 
   // Reachability guard inputs. The event types this slice *emits* are its own
   // history — read with composite AND clauses, which is fine. A *foreign* event
@@ -338,6 +346,7 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
       ~value=command,
       ~tagKeysByEventType,
       ~crossPartitionTagKeys,
+      ~payloadTagKeys,
     )
     let condition: Reventless.DcbTag.appendCondition = {query: query}
     derivedCondition := Some(condition)

package/src/Behavior_GWT.res.mjs

@@ -205,6 +205,12 @@ function Make(Spec) {
     });
     let crossPartitionTagKeys = Array.from(set.values()).toSorted(Primitive_string.compare);
     let tagKeysByEventType = DcbScopeInference$Reventless.infer([scopeShape]).tagKeysByEventType;
+    let payloadTagKeys = DcbTag$Reventless.commandPayloadTagKeys(scopeShape, Stdlib_Option.map(DcbScopeInference$Reventless.resolvePartitions([scopeShape]).partitionBySlice[""], key => ({
+      TAG: "Simple",
+      _0: {
+        key: key
+      }
+    })), crossPartitionTagKeys);
     let emittedEventTypes = DcbDecode$Reventless.makeDecoder(Spec.eventSchema).eventTypes;
     let consumedTagKeysByType = DcbTag$Reventless.extractTagKeysByEventType(Spec.consumedEventSchema);
     let queryTagKeys = query => query.flatMap(qi => Stdlib_Option.mapOr(qi.tags, [], tags => tags.map(t => t.key)));
@@ -241,7 +247,7 @@ function Make(Spec) {
     let whenCmd = (history, cmd) => {
       errors.contents = [];
       appendConditionFailure.contents = undefined;
-      let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, cmd, tagKeysByEventType, crossPartitionTagKeys);
+      let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, cmd, tagKeysByEventType, crossPartitionTagKeys, payloadTagKeys);
       let condition = {
         query: query
       };

package/src/Flow_GWT.res

@@ -312,6 +312,14 @@ module CommandStep = (
     Array.fromIterator(set->Set.values)->Array.toSorted((a, b) => String.compare(a, b))
   }
   let tagKeysByEventType = Reventless.DcbScopeInference.infer([scopeShape]).tagKeysByEventType
+  // Command keys this slice does not decide by stay out of the query (rule 4),
+  // judged against the partition the slice resolves to on its own.
+  let payloadTagKeys = scopeShape->Reventless.DcbTag.commandPayloadTagKeys(
+    ~partitionTag=Reventless.DcbScopeInference.resolvePartitions([scopeShape]).partitionBySlice
+    ->Dict.get("")
+    ->Option.map(key => Reventless.DcbTag.Simple({key: key})),
+    ~crossPartitionTagKeys,
+  )
 
   let whenCommand = async (flowP: flow, command: Spec.command) => {
     let s = await flowP
@@ -321,6 +329,7 @@ module CommandStep = (
       ~value=command,
       ~tagKeysByEventType,
       ~crossPartitionTagKeys,
+      ~payloadTagKeys,
     )
     let history = decodeMatching(s.log, consumedDecoder, query)
     let state = history->Array.reduce(Behavior.initialState, Behavior.evolve)

package/src/Flow_GWT.res.mjs

@@ -192,9 +192,15 @@ function CommandStep(Spec) {
     });
     let crossPartitionTagKeys = Array.from(set.values()).toSorted(Primitive_string.compare);
     let tagKeysByEventType = DcbScopeInference$Reventless.infer([scopeShape]).tagKeysByEventType;
+    let payloadTagKeys = DcbTag$Reventless.commandPayloadTagKeys(scopeShape, Stdlib_Option.map(DcbScopeInference$Reventless.resolvePartitions([scopeShape]).partitionBySlice[""], key => ({
+      TAG: "Simple",
+      _0: {
+        key: key
+      }
+    })), crossPartitionTagKeys);
     let whenCommand = async (flowP, command) => {
       let s = await flowP;
-      let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, command, tagKeysByEventType, crossPartitionTagKeys);
+      let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, command, tagKeysByEventType, crossPartitionTagKeys, payloadTagKeys);
       let history = decodeMatching(s.log, consumedDecoder, query);
       let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
       let events = Behavior.decide(state, command);
@@ -265,6 +271,7 @@ function CommandStep(Spec) {
       scopeShape: scopeShape,
       crossPartitionTagKeys: crossPartitionTagKeys,
       tagKeysByEventType: tagKeysByEventType,
+      payloadTagKeys: payloadTagKeys,
       whenCommand: whenCommand,
       thenEvents: thenEvents,
       thenEvent: thenEvent,

package/tests/StateChangeSliceGwtTest.res

@@ -159,3 +159,83 @@ MissingTagGwt.describe("MissingTag slice implicit check", () => {
       }),
   )
 })
+
+// A command naming a second thing only as information: `carrierId` is tagged by
+// its name, but no decision is made per carrier. Its tag stays on the command and
+// out of the query, so the order's own history — which never carries the carrier —
+// is still selected.
+module ShipOrderSlice = {
+  let name = "ShipOrder"
+
+  @schema
+  type consumedEvent =
+    | OrderPlaced({orderId: @s.matches(Reventless.DcbTag.string) string})
+    | OrderShipped({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type command =
+    | ShipOrder({
+        orderId: @s.matches(Reventless.DcbTag.string) string,
+        carrierId: @s.matches(Reventless.DcbTag.string) string,
+      })
+
+  @schema
+  type error = OrderNotPlaced | AlreadyShipped
+
+  // Seen alone the slice has no chapter to say that two ids on its event mean
+  // "the order", so the partition is named, as `@partitionTag` would.
+  @schema
+  type event =
+    | OrderShipped({
+        orderId: @s.matches(Reventless.DcbTag.partition) string,
+        carrierId: @s.matches(Reventless.DcbTag.string) string,
+      })
+}
+
+module ShipOrderBehavior = {
+  module Spec = ShipOrderSlice
+
+  type state = {placed: bool, shipped: bool}
+  let initialState: state = {placed: false, shipped: false}
+
+  let evolve = (state: state, event: Spec.consumedEvent): state =>
+    switch event {
+    | Spec.OrderPlaced(_) => {...state, placed: true}
+    | Spec.OrderShipped(_) => {...state, shipped: true}
+    }
+
+  let decide = (state: state, cmd: Spec.command): result<array<Spec.event>, Spec.error> =>
+    switch cmd {
+    | Spec.ShipOrder({orderId, carrierId}) =>
+      if !state.placed {
+        Error(Spec.OrderNotPlaced)
+      } else if state.shipped {
+        Error(Spec.AlreadyShipped)
+      } else {
+        Ok([Spec.OrderShipped({orderId, carrierId})])
+      }
+    }
+}
+
+module ShipOrderGwt = Behavior_GWT.Make(ShipOrderSlice, ShipOrderBehavior)
+
+ShipOrderGwt.describe("ShipOrder — a command reference no decision reads by", () => {
+  ShipOrderGwt.test("reads the order's history without the carrier", () =>
+    ShipOrderGwt.givenEvents([ShipOrderSlice.OrderPlaced({orderId: "o1"})])
+    ->ShipOrderGwt.whenCmd(ShipOrderSlice.ShipOrder({orderId: "o1", carrierId: "c1"}))
+    ->ShipOrderGwt.thenEvent(ShipOrderSlice.OrderShipped({orderId: "o1", carrierId: "c1"}))
+  )
+
+  ShipOrderGwt.test("the append condition is the order alone", () =>
+    ShipOrderGwt.givenEvents([ShipOrderSlice.OrderPlaced({orderId: "o1"})])
+    ->ShipOrderGwt.whenCmd(ShipOrderSlice.ShipOrder({orderId: "o1", carrierId: "c1"}))
+    ->ShipOrderGwt.thenAppendsConditionedOnExactly({
+      query: [
+        {
+          eventTypes: ["OrderPlaced", "OrderShipped"],
+          tags: [{key: "orderId", value: "o1"}],
+        },
+      ],
+    })
+  )
+})

package/tests/StateChangeSliceGwtTest.res.mjs

@@ -260,6 +260,147 @@ MissingTagGwt.describe("MissingTag slice implicit check", () => {
   }));
 });
 
+let consumedEventSchema$2 = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let commandSchema$2 = Sury.$schema(s => ({
+  TAG: "ShipOrder",
+  orderId: s.m(DcbTag$Reventless.string),
+  carrierId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema$2 = Sury.union([
+  Sury.literal("OrderNotPlaced"),
+  Sury.literal("AlreadyShipped")
+]);
+
+let eventSchema$2 = Sury.$schema(s => ({
+  TAG: "OrderShipped",
+  orderId: s.m(DcbTag$Reventless.partition),
+  carrierId: s.m(DcbTag$Reventless.string)
+}));
+
+function commandAuthorization$2(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition$2(param) {
+  return "Undeclared";
+}
+
+let traits$2 = [];
+
+let ShipOrderSlice = {
+  name: "ShipOrder",
+  consumedEventSchema: consumedEventSchema$2,
+  commandSchema: commandSchema$2,
+  errorSchema: errorSchema$2,
+  eventSchema: eventSchema$2,
+  commandAuthorization: commandAuthorization$2,
+  commandTransition: commandTransition$2,
+  traits: traits$2,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState$1 = {
+  placed: false,
+  shipped: false
+};
+
+function evolve$2(state, event) {
+  if (event.TAG === "OrderPlaced") {
+    return {
+      placed: true,
+      shipped: state.shipped
+    };
+  } else {
+    return {
+      placed: state.placed,
+      shipped: true
+    };
+  }
+}
+
+function decide$2(state, cmd) {
+  if (state.placed) {
+    if (state.shipped) {
+      return {
+        TAG: "Error",
+        _0: "AlreadyShipped"
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "OrderShipped",
+            orderId: cmd.orderId,
+            carrierId: cmd.carrierId
+          }]
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "OrderNotPlaced"
+    };
+  }
+}
+
+let ShipOrderBehavior = {
+  Spec: undefined,
+  initialState: initialState$1,
+  evolve: evolve$2,
+  decide: decide$2
+};
+
+let ShipOrderGwt = Behavior_GWT$ReventlessGwt.Make(ShipOrderSlice)({
+  initialState: initialState$1,
+  evolve: evolve$2,
+  decide: decide$2
+});
+
+ShipOrderGwt.describe("ShipOrder — a command reference no decision reads by", () => {
+  ShipOrderGwt.test("reads the order's history without the carrier", () => ShipOrderGwt.thenEvent(ShipOrderGwt.whenCmd(ShipOrderGwt.givenEvents([{
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }]), {
+    TAG: "ShipOrder",
+    orderId: "o1",
+    carrierId: "c1"
+  }), {
+    TAG: "OrderShipped",
+    orderId: "o1",
+    carrierId: "c1"
+  }));
+  ShipOrderGwt.test("the append condition is the order alone", () => ShipOrderGwt.thenAppendsConditionedOnExactly(ShipOrderGwt.whenCmd(ShipOrderGwt.givenEvents([{
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }]), {
+    TAG: "ShipOrder",
+    orderId: "o1",
+    carrierId: "c1"
+  }), {
+    query: [{
+        eventTypes: [
+          "OrderPlaced",
+          "OrderShipped"
+        ],
+        tags: [{
+            key: "orderId",
+            value: "o1"
+          }]
+      }]
+  }));
+});
+
 let Spec = include.Spec;
 
 let todo = include.todo;
@@ -292,5 +433,8 @@ export {
   MissingTagSlice,
   MissingTagBehavior,
   MissingTagGwt,
+  ShipOrderSlice,
+  ShipOrderBehavior,
+  ShipOrderGwt,
 }
 /* consumedEventSchema Not a pure module */