@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/tests/SideEffect/MockEmail.res.mjs

@@ -0,0 +1,47 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let callSchema = S.schema(s => ({
+  TAG: "SendConfirmation",
+  email: s.m(S.string),
+  orderId: s.m(S.string)
+}));
+
+let calls = {
+  contents: []
+};
+
+function reset() {
+  calls.contents = [];
+}
+
+function recordSend(email, orderId) {
+  calls.contents = calls.contents.concat([{
+      TAG: "SendConfirmation",
+      email: email,
+      orderId: orderId
+    }]);
+}
+
+function mock_snapshot() {
+  return calls.contents;
+}
+
+function mock_encode(c) {
+  return S.reverseConvertToJsonOrThrow(c, callSchema);
+}
+
+let mock = {
+  snapshot: mock_snapshot,
+  encode: mock_encode
+};
+
+export {
+  callSchema,
+  calls,
+  reset,
+  recordSend,
+  mock,
+}
+/* callSchema Not a pure module */

package/tests/StateChange/ExternalAddCategorySlice_GWT.res

@@ -0,0 +1,27 @@
+// External-Spec verification test for @@reventless.gwt.
+//
+// Zero payload, no local module, no alias. The PPX resolves:
+//   - Kind from the folder segment "StateChange" -> Behavior
+//   - Spec from the filename stem (strip "_GWT") -> ExternalAddCategorySlice
+//   - Impl derived as ExternalAddCategorySlice_Behavior
+//   - open ExternalAddCategorySlice +
+//     include Behavior_GWT.Make(ExternalAddCategorySlice, ExternalAddCategorySlice_Behavior)
+//
+// Mirrors the canonical consumer pattern documented in
+// docs/guides/given-when-then.md § 4.10.
+
+@@reventless.gwt
+
+describe("ExternalAddCategory StateChangeSlice (external Spec)", () => {
+  test("empty event log produces CategoryAdded", () =>
+    givenEvents([])
+    ->whenCmd(AddCategory({categoryId: "c1", name: "Electronics"}))
+    ->thenEvent(CategoryAdded({categoryId: "c1", name: "Electronics"}))
+  )
+
+  test("existing category returns CategoryAlreadyExists", () =>
+    givenEvents([CategoryAdded])
+    ->whenCmd(AddCategory({categoryId: "c1", name: "X"}))
+    ->thenError(CategoryAlreadyExists)
+  )
+})

package/tests/StateChange/ExternalAddCategorySlice_GWT.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "../../src/Behavior_GWT.res.mjs";
+import * as ExternalAddCategorySlice$ReventlessGwt from "../../src/StateChange/ExternalAddCategorySlice.res.mjs";
+import * as ExternalAddCategorySlice_Behavior$ReventlessGwt from "../../src/StateChange/ExternalAddCategorySlice_Behavior.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.Make(ExternalAddCategorySlice$ReventlessGwt)(ExternalAddCategorySlice_Behavior$ReventlessGwt);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+let thenError = include.thenError;
+
+describe("ExternalAddCategory StateChangeSlice (external Spec)", () => {
+  test("empty event log produces CategoryAdded", () => thenEvent(whenCmd(givenEvents([]), {
+    TAG: "AddCategory",
+    categoryId: "c1",
+    name: "Electronics"
+  }), {
+    TAG: "CategoryAdded",
+    categoryId: "c1",
+    name: "Electronics"
+  }));
+  test("existing category returns CategoryAlreadyExists", () => thenError(whenCmd(givenEvents(["CategoryAdded"]), {
+    TAG: "AddCategory",
+    categoryId: "c1",
+    name: "X"
+  }), "CategoryAlreadyExists"));
+});
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+export {
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+}
+/* include Not a pure module */

package/tests/StateChange/WithFixtures_Fixtures.res

@@ -0,0 +1,9 @@
+// Companion fixtures module for [WithFixtures_GWT.res]. The PPX detects this
+// sibling by filename and auto-injects [open WithFixtures_Fixtures] into the
+// GWT test body, so the test can reference [addCategoryElectronics] /
+// [electronicsCategoryAdded] unqualified.
+
+open WithFixtures
+
+let addCategoryElectronics = AddCategory({categoryId: "c1", name: "Electronics"})
+let electronicsCategoryAdded = CategoryAdded({categoryId: "c1", name: "Electronics"})

package/tests/StateChange/WithFixtures_Fixtures.res.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let addCategoryElectronics = {
+  TAG: "AddCategory",
+  categoryId: "c1",
+  name: "Electronics"
+};
+
+let electronicsCategoryAdded = {
+  TAG: "CategoryAdded",
+  categoryId: "c1",
+  name: "Electronics"
+};
+
+export {
+  addCategoryElectronics,
+  electronicsCategoryAdded,
+}
+/* No side effect */

package/tests/StateChange/WithFixtures_GWT.res

@@ -0,0 +1,23 @@
+// Companion-fixtures auto-open verification test for @@reventless.gwt.
+//
+// Zero payload, no local module, no manual open. The PPX resolves:
+//   - Kind from the folder segment "StateChange" -> StateChangeSlice
+//   - Spec from the filename stem (strip "_GWT") -> WithFixtures
+//   - Companion fixtures: sibling [WithFixtures_Fixtures.res] is detected on
+//     disk, so the PPX emits both [open WithFixtures] and
+//     [open WithFixtures_Fixtures] before the [include].
+//
+// The test body uses [addCategoryElectronics] / [electronicsCategoryAdded]
+// unqualified — resolution only succeeds if the companion fixtures open was
+// injected.
+
+@@reventless.gwt
+
+describe("WithFixtures StateChangeSlice (companion fixtures auto-open)", () => {
+  test("uses companion fixtures unqualified", () =>
+    givenEvents([])
+    ->whenCmd(addCategoryElectronics)
+    ->thenEvent((electronicsCategoryAdded :> event))
+  )
+})
+

package/tests/StateChange/WithFixtures_GWT.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "../../src/Behavior_GWT.res.mjs";
+import * as WithFixtures$ReventlessGwt from "../../src/StateChange/WithFixtures.res.mjs";
+import * as WithFixtures_Behavior$ReventlessGwt from "../../src/StateChange/WithFixtures_Behavior.res.mjs";
+import * as WithFixtures_Fixtures$ReventlessGwt from "./WithFixtures_Fixtures.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.Make(WithFixtures$ReventlessGwt)(WithFixtures_Behavior$ReventlessGwt);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+describe("WithFixtures StateChangeSlice (companion fixtures auto-open)", () => test("uses companion fixtures unqualified", () => thenEvent(whenCmd(givenEvents([]), WithFixtures_Fixtures$ReventlessGwt.addCategoryElectronics), WithFixtures_Fixtures$ReventlessGwt.electronicsCategoryAdded)));
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenError = include.thenError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+export {
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+}
+/* include Not a pure module */

package/tests/StateChange/WithManualOpen_Fixtures.res

@@ -0,0 +1,7 @@
+// Companion fixtures module for [WithManualOpen_GWT.res]. The test file
+// opens this module manually, so the PPX must NOT duplicate the open.
+
+open WithManualOpen
+
+let addCategoryBooks = AddCategory({categoryId: "c2", name: "Books"})
+let booksCategoryAdded = CategoryAdded({categoryId: "c2", name: "Books"})

package/tests/StateChange/WithManualOpen_Fixtures.res.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let addCategoryBooks = {
+  TAG: "AddCategory",
+  categoryId: "c2",
+  name: "Books"
+};
+
+let booksCategoryAdded = {
+  TAG: "CategoryAdded",
+  categoryId: "c2",
+  name: "Books"
+};
+
+export {
+  addCategoryBooks,
+  booksCategoryAdded,
+}
+/* No side effect */

package/tests/StateChange/WithManualOpen_GWT.res

@@ -0,0 +1,17 @@
+// Manual-open dedup verification for @@reventless.gwt companion fixtures.
+//
+// The sibling [WithManualOpen_Fixtures.res] exists AND the test body opens
+// it manually. The PPX detects the existing open via [Util.has_open] and
+// skips the duplicate injection — the file compiles without shadow warnings.
+
+@@reventless.gwt
+
+open WithManualOpen_Fixtures
+
+describe("WithManualOpen (manual open not duplicated by PPX)", () => {
+  test("manual open resolves fixture identifiers", () =>
+    givenEvents([])
+    ->whenCmd(addCategoryBooks)
+    ->thenEvent((booksCategoryAdded :> event))
+  )
+})

package/tests/StateChange/WithManualOpen_GWT.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "../../src/Behavior_GWT.res.mjs";
+import * as WithManualOpen$ReventlessGwt from "../../src/StateChange/WithManualOpen.res.mjs";
+import * as WithManualOpen_Behavior$ReventlessGwt from "../../src/StateChange/WithManualOpen_Behavior.res.mjs";
+import * as WithManualOpen_Fixtures$ReventlessGwt from "./WithManualOpen_Fixtures.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.Make(WithManualOpen$ReventlessGwt)(WithManualOpen_Behavior$ReventlessGwt);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+describe("WithManualOpen (manual open not duplicated by PPX)", () => test("manual open resolves fixture identifiers", () => thenEvent(whenCmd(givenEvents([]), WithManualOpen_Fixtures$ReventlessGwt.addCategoryBooks), WithManualOpen_Fixtures$ReventlessGwt.booksCategoryAdded)));
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenError = include.thenError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+export {
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+}
+/* include Not a pure module */

package/tests/StateChangeSliceGwtTest.res

@@ -0,0 +1,160 @@
+// Worked example for Behavior_GWT (slice flavor).
+// Uses the canonical "AddCategory" DCB slice shape — payload-less consumed
+// events, decide that appends `CategoryAdded` unless the category already
+// exists. Command carries a `@s.matches(DcbTag.string)` annotated ID so the
+// DCB optimistic-concurrency query resolves to a single-entity read.
+//
+// Plan 02 Phase 6: split-form Spec/Behavior; PPX inference resolves the
+// folder kind from the test path's "StateChangeSlice" substring → Behavior
+// DSL → emits [include Behavior_GWT.Make(Spec, Behavior)].
+
+@@reventless.gwt
+
+module AddCategorySlice = {
+  let name = "AddCategory"
+
+  @schema
+  type consumedEvent =
+    | CategoryAdded
+    | CategoryArchived
+
+  @schema
+  type command =
+    AddCategory({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+  @schema
+  type error = CategoryAlreadyExists
+
+  @schema
+  type event =
+    CategoryAdded({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+}
+
+module AddCategorySliceBehavior = {
+  module Spec = AddCategorySlice
+  open AddCategorySlice
+
+  type state = {exists: bool, archived: bool}
+  let initialState: state = {exists: false, archived: false}
+
+  let evolve = (state: state, event: consumedEvent): state =>
+    switch event {
+    | CategoryAdded => {exists: true, archived: false}
+    | CategoryArchived => {...state, archived: true}
+    }
+
+  let decide = (state: state, command: command): result<array<event>, error> =>
+    switch command {
+    | AddCategory({categoryId, name}) =>
+      state.exists ? Error(CategoryAlreadyExists) : Ok([CategoryAdded({categoryId, name})])
+    }
+}
+
+describe("AddCategory StateChangeSlice", () => {
+  test("on empty event log produces CategoryAdded", () =>
+    givenEvents([])
+    ->whenCmd(AddCategory({categoryId: "c1", name: "Electronics"}))
+    ->thenEvent(CategoryAdded({categoryId: "c1", name: "Electronics"}))
+  )
+
+  test("on existing category returns CategoryAlreadyExists", () =>
+    givenEvents([CategoryAdded])
+    ->whenCmd(AddCategory({categoryId: "c1", name: "X"}))
+    ->thenError(CategoryAlreadyExists)
+  )
+
+  test("append condition is single-entity query over consumed event types", () =>
+    givenEvents([])
+    ->whenCmd(AddCategory({categoryId: "c1", name: "Electronics"}))
+    ->thenAppendsConditionedOn([
+      {
+        eventTypes: ["CategoryAdded", "CategoryArchived"],
+        tags: [{key: "categoryId", value: "c1"}],
+      },
+    ])
+  )
+
+  test("exact condition matches no prior position (new entity)", () =>
+    givenEvents([])
+    ->whenCmd(AddCategory({categoryId: "c2", name: "Books"}))
+    ->thenAppendsConditionedOnExactly({
+      query: [
+        {
+          eventTypes: ["CategoryAdded", "CategoryArchived"],
+          tags: [{key: "categoryId", value: "c2"}],
+        },
+      ],
+    })
+  )
+})
+
+// A second slice whose command has no `@s.matches(DcbTag.string)` annotation —
+// verifies the implicit Stage 4 check fires with `AppendConditionMismatch`
+// before any subsequent `then*` runs its own assertion.
+module MissingTagSlice = {
+  let name = "MissingTagSlice"
+
+  @schema
+  type consumedEvent = Noop
+
+  @schema
+  type command = Do({id: string})
+
+  @schema
+  type error = Rejected
+
+  @schema
+  type event = Done({id: string})
+}
+
+module MissingTagBehavior = {
+  // Qualify references through [Spec] to avoid shadowing the file-scope
+  // [consumedEvent] / [command] / [event] / [error] brought in by the PPX-
+  // injected [open AddCategorySlice].
+  module Spec = MissingTagSlice
+
+  type state = unit
+  let initialState: state = ()
+
+  let evolve = (state: state, _event: Spec.consumedEvent): state => state
+
+  let decide = (
+    _state: state,
+    cmd: Spec.command,
+  ): result<array<Spec.event>, Spec.error> =>
+    switch cmd {
+    | Do({id}) => Ok([Spec.Done({id: id})])
+    }
+}
+
+module MissingTagGwt = Behavior_GWT.Make(MissingTagSlice, MissingTagBehavior)
+
+MissingTagGwt.describe("MissingTag slice implicit check", () => {
+  MissingTagGwt.test("thenEvent surfaces AppendConditionMismatch when command lacks DCB tag", () => {
+    let outcome =
+      MissingTagGwt.givenEvents([])
+      ->MissingTagGwt.whenCmd(Do({id: "x1"}))
+      ->MissingTagGwt.thenEvent(Done({id: "x1"}))
+    switch outcome {
+    | Error(AppendConditionMismatch(_)) => Outcome.pass
+    | Error(other) =>
+      Outcome.fail(
+        Throw({error: "expected AppendConditionMismatch, got: " ++ Outcome.kindName(other), stack: ""}),
+      )
+    | Ok() =>
+      Outcome.fail(
+        Throw({error: "expected AppendConditionMismatch, got pass", stack: ""}),
+      )
+    }
+  })
+
+  MissingTagGwt.test(
+    "thenAppendsConditionedOnExactly bypasses implicit check (still passes with derived)",
+    () =>
+      MissingTagGwt.givenEvents([])
+      ->MissingTagGwt.whenCmd(Do({id: "x1"}))
+      ->MissingTagGwt.thenAppendsConditionedOnExactly({
+        query: [{eventTypes: ["Noop"], tags: []}],
+      }),
+  )
+})