@reventlessdev/reventless-gwt 1.0.0-alpha.225 → 1.0.0-alpha.227

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.227 (2026-09-28)
+
+### Features
+
+* **gwt:** a view's failing scenario points at project, not evolve ([1cb5cd3](https://github.com/ReventlessDev/reventless-core/commit/1cb5cd3651ec9830abac2676142a40d311d0b77c))
+
+
+# 1.0.0-alpha.226 (2026-09-27)
+
+### Features
+
+* **gwt:** a view's failing scenario points at project, not evolve ([1cb5cd3](https://github.com/ReventlessDev/reventless-core/commit/1cb5cd3651ec9830abac2676142a40d311d0b77c))
+
+
 # 1.0.0-alpha.225 (2026-09-25)
 
 **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.225",
+  "version": "1.0.0-alpha.227",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "sury": "11.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.15",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.278",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.177",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.149"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.17",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.280",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.179",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.151"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/Hint.res

@@ -6,9 +6,9 @@
 // and §3.3 (JSON `hint` field).
 //
 // `locus` is a dotted pointer like "CategoryBehavior.decide" filled in by
-// the DSL at `then*` call time when the slice module name is in scope. If the
-// DSL can't provide it (e.g. Projection has no single "locus" function name
-// the user controls), `locus` falls back to a generic pointer.
+// the DSL at `then*` call time when the slice module name is in scope, else a
+// generic pointer. A `StateMismatch` names its fold, so a view's points at
+// `project` rather than `evolve`.
 
 type t = {
   locus: string,
@@ -58,6 +58,11 @@ let forMismatch = (~slice="<slice>", m: Outcome.mismatch): t =>
         message,
       }
     }
+  | StateMismatch({fold: Project}) => {
+      locus: `${slice}.project`,
+      branch: None,
+      message: "project() filed a different row than expected. Check the arm for the event and the key it sets.",
+    }
   | StateMismatch(_) => {
       locus: `${slice}.evolve`,
       branch: None,

package/src/Hint.res.mjs

@@ -48,6 +48,14 @@ function forMismatch(sliceOpt, m) {
         message: message
       };
     case "StateMismatch" :
+      let match$2 = m.fold;
+      if (match$2 !== undefined && match$2 !== "Evolve") {
+        return {
+          locus: slice + `.project`,
+          branch: undefined,
+          message: "project() filed a different row than expected. Check the arm for the event and the key it sets."
+        };
+      }
       return {
         locus: slice + `.evolve`,
         branch: undefined,

package/src/MultiSourceProjection_GWT.res

@@ -239,6 +239,7 @@ module Make = (Projection: Reventless.Projection.Mapping): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: testId.contents,
           expected: Some(JSON.Encode.array(expectedStates->encStates)),
           actual: Some(encStore(store)),
@@ -257,6 +258,7 @@ module Make = (Projection: Reventless.Projection.Mapping): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: id,
           expected: Some(JSON.Encode.array(expectedStates->encStates)),
           actual: Some(encStore(store)),
@@ -272,6 +274,7 @@ module Make = (Projection: Reventless.Projection.Mapping): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: "<all>",
           expected: Some(encStore(expectedStore)),
           actual: Some(encStore(store)),
@@ -293,6 +296,7 @@ module Make = (Projection: Reventless.Projection.Mapping): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: "<any>",
           expected: None,
           actual: Some(encStore(store)),

package/src/MultiSourceProjection_GWT.res.mjs

@@ -248,7 +248,8 @@ function Make(Projection) {
         TAG: "StateMismatch",
         key: testId.contents,
         expected: expectedStates.map(encState),
-        actual: encStore(store)
+        actual: encStore(store),
+        fold: "Project"
       });
     }
   };
@@ -264,7 +265,8 @@ function Make(Projection) {
         TAG: "StateMismatch",
         key: id,
         expected: expectedStates.map(encState),
-        actual: encStore(store)
+        actual: encStore(store),
+        fold: "Project"
       });
     }
   };
@@ -277,7 +279,8 @@ function Make(Projection) {
         TAG: "StateMismatch",
         key: "<all>",
         expected: encStore(expectedStore),
-        actual: encStore(store)
+        actual: encStore(store),
+        fold: "Project"
       });
     }
   };
@@ -293,7 +296,8 @@ function Make(Projection) {
         TAG: "StateMismatch",
         key: "<any>",
         expected: undefined,
-        actual: encStore(store)
+        actual: encStore(store),
+        fold: "Project"
       });
     }
   };

package/src/Outcome.res

@@ -8,10 +8,14 @@
 // shape and §3.3 for the JSON rendering. Stage 7 adds sury-aware rendering and
 // structural `fieldDiff`. Stage 4 added `AppendConditionMismatch`.
 
+// The function whose fold produced a state: a behavior's `evolve`, or a view's
+// `project`. Absent means `Evolve`, so a harness that does not say keeps its hint.
+type fold = Evolve | Project
+
 type mismatch =
   | EventsMismatch({expected: array<JSON.t>, actual: array<JSON.t>})
   | ErrorMismatch({expected: JSON.t, actual: option<JSON.t>, actualEvents: array<JSON.t>})
-  | StateMismatch({key: string, expected: option<JSON.t>, actual: option<JSON.t>})
+  | StateMismatch({key: string, expected: option<JSON.t>, actual: option<JSON.t>, fold?: fold})
   | NoEventExpected({actual: array<JSON.t>})
   | TodoMismatch({expected: array<(string, JSON.t)>, actual: array<(string, JSON.t)>})
   | AppendConditionMismatch({expected: JSON.t, actual: JSON.t})

package/src/Projection_GWT.res

@@ -243,6 +243,7 @@ module Make = (Spec: Spec, Projection: Projection with module Spec := Spec): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: testId.contents,
           expected: Some(JSON.Encode.array(expectedStates->encStates)),
           actual: Some(encStore(store)),
@@ -261,6 +262,7 @@ module Make = (Spec: Spec, Projection: Projection with module Spec := Spec): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: id,
           expected: Some(JSON.Encode.array(expectedStates->encStates)),
           actual: Some(encStore(store)),
@@ -276,6 +278,7 @@ module Make = (Spec: Spec, Projection: Projection with module Spec := Spec): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: "<all>",
           expected: Some(encStore(expectedStore)),
           actual: Some(encStore(store)),
@@ -296,6 +299,7 @@ module Make = (Spec: Spec, Projection: Projection with module Spec := Spec): (
     } else {
       Outcome.fail(
         StateMismatch({
+          fold: Project,
           key: "<any>",
           expected: None,
           actual: Some(encStore(store)),

package/src/Projection_GWT.res.mjs

@@ -231,7 +231,8 @@ function Make(Spec) {
           TAG: "StateMismatch",
           key: testId.contents,
           expected: expectedStates.map(encState),
-          actual: encStore(store)
+          actual: encStore(store),
+          fold: "Project"
         });
       }
     };
@@ -247,7 +248,8 @@ function Make(Spec) {
           TAG: "StateMismatch",
           key: id,
           expected: expectedStates.map(encState),
-          actual: encStore(store)
+          actual: encStore(store),
+          fold: "Project"
         });
       }
     };
@@ -260,7 +262,8 @@ function Make(Spec) {
           TAG: "StateMismatch",
           key: "<all>",
           expected: encStore(expectedStore),
-          actual: encStore(store)
+          actual: encStore(store),
+          fold: "Project"
         });
       }
     };
@@ -276,7 +279,8 @@ function Make(Spec) {
           TAG: "StateMismatch",
           key: "<any>",
           expected: undefined,
-          actual: encStore(store)
+          actual: encStore(store),
+          fold: "Project"
         });
       }
     };

package/tests/HintTest.res

@@ -0,0 +1,56 @@
+// A state mismatch's hint names the fold that produced the state: `project` for
+// a view's scenario, `evolve` for a behavior's.
+
+open JestGlobals
+
+module CategoriesView = {
+  module Key = Reventless.Id.StringPure
+  let name = "CategoriesView"
+
+  @schema
+  type state = {categoryId: string, name: string}
+
+  @schema
+  type consumedEvent = CategoryAdded({categoryId: string, name: string})
+
+  let subIdConfig = None
+}
+
+module CategoriesViewProjection = {
+  module Spec = CategoriesView
+  open CategoriesView
+
+  let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
+    switch event {
+    | CategoryAdded({categoryId, name}) => [
+        Reventless.Projection.Set(categoryId, {categoryId, name}),
+      ]
+    }
+}
+
+module View = Projection_GWT.Make(CategoriesView, CategoriesViewProjection)
+
+describe("Hint for a StateMismatch", () => {
+  testPromise("a view's differing row points at project", async () => {
+    let outcome = await View.givenEvents([])
+    ->View.whenEvent(CategoryAdded({categoryId: "c1", name: "Electronics"}))
+    ->View.thenStateWithId("c1", {categoryId: "c1", name: "Books"})
+    switch outcome {
+    | Error(m) =>
+      let hint = Hint.forMismatch(~slice=CategoriesView.name, m)
+      expect(hint.locus)->toBe("CategoriesView.project")
+      expect(hint.message)->toBe(
+        "project() filed a different row than expected. Check the arm for the event and the key it sets.",
+      )
+    | Ok() => JsError.throwWithMessage("expected a StateMismatch")
+    }
+  })
+
+  testSync("a behavior's differing state still points at evolve", () => {
+    let hint = Hint.forMismatch(
+      ~slice="AddCategory",
+      Outcome.StateMismatch({key: "c1", expected: None, actual: None}),
+    )
+    expect(hint.locus)->toBe("AddCategory.evolve")
+  })
+})

package/tests/HintTest.res.mjs

@@ -0,0 +1,99 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Hint$ReventlessGwt from "../src/Hint.res.mjs";
+import * as Projection_GWT$ReventlessGwt from "../src/Projection_GWT.res.mjs";
+
+let name = "CategoriesView";
+
+let stateSchema = Sury.$schema(s => ({
+  categoryId: s.m(Sury.string),
+  name: s.m(Sury.string)
+}));
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(Sury.string),
+  name: s.m(Sury.string)
+}));
+
+let CategoriesView = {
+  Key: undefined,
+  name: name,
+  stateSchema: stateSchema,
+  consumedEventSchema: consumedEventSchema,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function project(param) {
+  let event = param.event;
+  let categoryId = event.categoryId;
+  return [{
+      TAG: "Set",
+      _0: categoryId,
+      _1: {
+        categoryId: categoryId,
+        name: event.name
+      }
+    }];
+}
+
+let CategoriesViewProjection = {
+  Spec: undefined,
+  project: project
+};
+
+let View = Projection_GWT$ReventlessGwt.Make({
+  name: name,
+  stateSchema: stateSchema,
+  Key: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  consumedEventSchema: consumedEventSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+globalThis.describe("Hint for a StateMismatch", () => {
+  globalThis.test("a view's differing row points at project", async () => {
+    let outcome = await View.thenStateWithId(View.whenEvent(View.givenEvents([]), {
+      TAG: "CategoryAdded",
+      categoryId: "c1",
+      name: "Electronics"
+    }), "c1", {
+      categoryId: "c1",
+      name: "Books"
+    });
+    if (outcome.TAG === "Ok") {
+      return Stdlib_JsError.throwWithMessage("expected a StateMismatch");
+    }
+    let hint = Hint$ReventlessGwt.forMismatch(name, outcome._0);
+    globalThis.expect(hint.locus).toBe("CategoriesView.project");
+    globalThis.expect(hint.message).toBe("project() filed a different row than expected. Check the arm for the event and the key it sets.");
+  });
+  globalThis.test("a behavior's differing state still points at evolve", () => {
+    let hint = Hint$ReventlessGwt.forMismatch("AddCategory", {
+      TAG: "StateMismatch",
+      key: "c1",
+      expected: undefined,
+      actual: undefined
+    });
+    globalThis.expect(hint.locus).toBe("AddCategory.evolve");
+  });
+});
+
+export {
+  CategoriesView,
+  CategoriesViewProjection,
+  View,
+}
+/* stateSchema Not a pure module */