@reventlessdev/reventless-gwt 1.0.0-alpha.199 → 1.0.0-alpha.201

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.201 (2026-09-02)
+
+### Features
+
+* **dcb:** a boundary that cannot derive its scope says so ([db79969](https://github.com/ReventlessDev/reventless-core/commit/db79969df36bd90607425f6a22b4624227cfc4a0))
+
+
+# 1.0.0-alpha.200 (2026-09-01)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
 # 1.0.0-alpha.199 (2026-09-01)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.199",
+  "version": "1.0.0-alpha.201",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -15,16 +15,16 @@
   "dependencies": {
     "sury": "11.0.0-rc.2",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.252",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.153",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.125"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.254",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.155",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.127"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.75"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.76"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Flow_GWT.res

@@ -218,6 +218,45 @@ let test = (name, ~timeout=?, body: unit => flow) =>
     s.outcome
   })
 
+// -- Boundary scope ----------------------------------------------------------
+
+// Assert that a DCB consistency boundary derives its tag scope.
+//
+// Every other step here tests slices; this one tests the set of them, and it is
+// in the flow DSL because a flow is the only test kind that already reasons
+// about more than one slice at a time. The rest of the harness derives scope
+// per slice (`DcbScopeInference.crossPartitionForSlice`), which cannot fail the
+// way a boundary fails: a single slice always resolves, so the all-or-nothing
+// fallback in `deriveEffectiveScope` — one unresolvable slice discarding the
+// derived scope for every slice beside it — has no per-slice symptom at all. The
+// slices keep passing their own tests and the platform rejects valid commands.
+//
+// Takes the generated `<Plugin>.Plugin.dcbSliceSchemas`, so it asserts over the
+// boundary as deployed rather than over the steps a given flow happens to name.
+let thenBoundaryScopeResolves = async (
+  flowP: flow,
+  ~name: string,
+  slices: array<Reventless.DcbTag.sliceSchemas>,
+) => {
+  let s = await flowP
+  let scope = Reventless.DcbTag.deriveEffectiveScope(slices)
+  // An ambiguity that costs nothing is not a failure: a boundary whose fallback
+  // carries every derived key reads exactly as the derivation would. What fails
+  // is losing a key, because that is the case where the runtime answers wrongly.
+  let outcome = if scope.droppedCrossPartitionTagKeys->Array.length > 0 {
+    Outcome.fail(
+      ScopeDegraded({
+        boundary: name,
+        dropped: scope.droppedCrossPartitionTagKeys,
+        ambiguities: scope.ambiguities->Array.map(((slice, reason)) => `${slice}: ${reason}`),
+      }),
+    )
+  } else {
+    Outcome.pass
+  }
+  s->recordOutcome(outcome)
+}
+
 // -- CommandStep: a StateChangeSlice / Aggregate decider ---------------------
 
 module CommandStep = (

package/src/Flow_GWT.res.mjs

@@ -131,6 +131,18 @@ function test(name, timeout, body) {
   JestBind$ReventlessGwt.testPromise("Flow", name, timeout, async () => (await body()).outcome);
 }
 
+async function thenBoundaryScopeResolves(flowP, name, slices) {
+  let s = await flowP;
+  let scope = DcbTag$Reventless.deriveEffectiveScope(slices);
+  let outcome = scope.droppedCrossPartitionTagKeys.length !== 0 ? Outcome$ReventlessGwt.fail({
+      TAG: "ScopeDegraded",
+      boundary: name,
+      dropped: scope.droppedCrossPartitionTagKeys,
+      ambiguities: scope.ambiguities.map(param => param[0] + `: ` + param[1])
+    }) : Outcome$ReventlessGwt.pass;
+  return recordOutcome(s, outcome);
+}
+
 function CommandStep(Spec) {
   return Behavior => {
     let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
@@ -589,6 +601,7 @@ export {
   decodeAggregateMatching,
   describe,
   test,
+  thenBoundaryScopeResolves,
   CommandStep,
   AggregateCommandStep,
   AutomationStep,

package/src/Hint.res

@@ -93,6 +93,13 @@ let forMismatch = (~slice="<slice>", m: Outcome.mismatch): t =>
       branch: None,
       message: "The ExtensionPoint mapping / Extension delegate published a different set of events or commands than expected. Check the variant match arms and the one-to-many fan-out.",
     }
+  | ScopeDegraded({dropped}) => {
+      locus: `${slice} (DCB boundary)`,
+      branch: None,
+      message: `A slice in this boundary has no derivable partition key, so the derived DCB scope was discarded for all of them and the cross-partition reads of [${dropped->Array.join(
+          ", ",
+        )}] were lost. A slice referencing another entity by one of these keys now decides against an empty history and rejects valid commands. Fix the named slice — usually a consumed arm declaring the id the slice is already partitioned by.`,
+    }
   | Throw({error}) => {
       locus: `${slice}`,
       branch: None,

package/src/Hint.res.mjs

@@ -89,6 +89,12 @@ function forMismatch(sliceOpt, m) {
         branch: undefined,
         message: "The ExtensionPoint mapping / Extension delegate published a different set of events or commands than expected. Check the variant match arms and the one-to-many fan-out."
       };
+    case "ScopeDegraded" :
+      return {
+        locus: slice + ` (DCB boundary)`,
+        branch: undefined,
+        message: `A slice in this boundary has no derivable partition key, so the derived DCB scope was discarded for all of them and the cross-partition reads of [` + m.dropped.join(", ") + `] were lost. A slice referencing another entity by one of these keys now decides against an empty history and rejects valid commands. Fix the named slice — usually a consumed arm declaring the id the slice is already partitioned by.`
+      };
     case "Throw" :
       return {
         locus: slice,

package/src/MismatchRender.res

@@ -66,6 +66,10 @@ let normalize = (m: Outcome.mismatch): normalized => {
       Expected(renderMany(expected)),
       Actual(renderMany(actual)),
     ]
+  | ScopeDegraded({boundary, dropped, ambiguities}) => [
+      Expected(`${boundary}: cross-partition reads [${dropped->Array.join(", ")}] derived`),
+      Actual(ambiguities->Array.join(" | ")),
+    ]
   | Throw({error, stack}) => [Error(error), Stack(stack)]
   }
   {kind: Outcome.kindName(m), fields}

package/src/MismatchRender.res.mjs

@@ -82,6 +82,18 @@ function normalize(m) {
         }
       ];
       break;
+    case "ScopeDegraded" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: m.boundary + `: cross-partition reads [` + m.dropped.join(", ") + `] derived`
+        },
+        {
+          TAG: "Actual",
+          _0: m.ambiguities.join(" | ")
+        }
+      ];
+      break;
     case "Throw" :
       fields = [
         {

package/src/Outcome.res

@@ -26,6 +26,13 @@ type mismatch =
   // one-to-many fan-out (one inbound message → N published actions). Used by
   // `Delegate_GWT` and the cross-plugin `Flow_GWT` boundary steps.
   | PublishedActionsMismatch({expected: array<JSON.t>, actual: array<JSON.t>})
+  // A DCB consistency boundary could not derive its tag scope, so the runtime
+  // falls back to `@crossPartition` annotations and loses the cross-partition
+  // reference reads named in `dropped`. Not a mismatch between an expectation
+  // and a value — every slice in it still behaves correctly in isolation, which
+  // is exactly why it needs its own outcome: the defect is in the composition,
+  // and nothing that tests one slice can see it.
+  | ScopeDegraded({boundary: string, dropped: array<string>, ambiguities: array<string>})
   | Throw({error: string, stack: string})
 
 type outcome = result<unit, mismatch>
@@ -44,6 +51,7 @@ let kindName = (m: mismatch) =>
   | TranslateError(_) => "TranslateError"
   | QueryRowsMismatch(_) => "QueryRowsMismatch"
   | PublishedActionsMismatch(_) => "PublishedActionsMismatch"
+  | ScopeDegraded(_) => "ScopeDegraded"
   | Throw(_) => "Throw"
   }
 
@@ -93,5 +101,7 @@ let format = (m: mismatch) =>
     `PublishedActionsMismatch:\n  expected: ${stringifyJsonArray(expected)}\n  actual:   ${stringifyJsonArray(
         actual,
       )}`
+  | ScopeDegraded({boundary, dropped, ambiguities}) =>
+    `ScopeDegraded:\n  boundary: ${boundary}\n  dropped:  ${dropped->Array.join(", ")}\n  cause:    ${ambiguities->Array.join(" | ")}`
   | Throw({error, stack}) => `Throw: ${error}\n${stack}`
   }

package/src/Outcome.res.mjs

@@ -29,6 +29,8 @@ function kindName(m) {
       return "QueryRowsMismatch";
     case "PublishedActionsMismatch" :
       return "PublishedActionsMismatch";
+    case "ScopeDegraded" :
+      return "ScopeDegraded";
     case "Throw" :
       return "Throw";
   }
@@ -71,6 +73,8 @@ function format(m) {
       return `QueryRowsMismatch:\n  expected: ` + stringifyJsonArray(m.expected) + `\n  actual:   ` + stringifyJsonArray(m.actual);
     case "PublishedActionsMismatch" :
       return `PublishedActionsMismatch:\n  expected: ` + stringifyJsonArray(m.expected) + `\n  actual:   ` + stringifyJsonArray(m.actual);
+    case "ScopeDegraded" :
+      return `ScopeDegraded:\n  boundary: ` + m.boundary + `\n  dropped:  ` + m.dropped.join(", ") + `\n  cause:    ` + m.ambiguities.join(" | ");
     case "Throw" :
       return `Throw: ` + m.error + `\n` + m.stack;
   }