@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/tests/StateChangeSliceGwtTest.res.mjs

@@ -0,0 +1,280 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Behavior_GWT$ReventlessGwt from "../src/Behavior_GWT.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.literal("CategoryAdded"),
+  S.literal("CategoryArchived")
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddCategory",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("CategoryAlreadyExists");
+
+let eventSchema = S.schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let AddCategorySlice = {
+  name: "AddCategory",
+  consumedEventSchema: consumedEventSchema,
+  commandSchema: commandSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema,
+  commandAuthorization: commandAuthorization,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState = {
+  exists: false,
+  archived: false
+};
+
+function evolve(state, event) {
+  if (event === "CategoryAdded") {
+    return {
+      exists: true,
+      archived: false
+    };
+  } else {
+    return {
+      exists: state.exists,
+      archived: true
+    };
+  }
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "CategoryAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CategoryAdded",
+          categoryId: command.categoryId,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let AddCategorySliceBehavior = {
+  Spec: undefined,
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide
+};
+
+let include = Behavior_GWT$ReventlessGwt.Make(AddCategorySlice)({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+let thenError = include.thenError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+describe("AddCategory StateChangeSlice", () => {
+  test("on empty event log produces CategoryAdded", () => thenEvent(whenCmd(givenEvents([]), {
+    TAG: "AddCategory",
+    categoryId: "c1",
+    name: "Electronics"
+  }), {
+    TAG: "CategoryAdded",
+    categoryId: "c1",
+    name: "Electronics"
+  }));
+  test("on existing category returns CategoryAlreadyExists", () => thenError(whenCmd(givenEvents(["CategoryAdded"]), {
+    TAG: "AddCategory",
+    categoryId: "c1",
+    name: "X"
+  }), "CategoryAlreadyExists"));
+  test("append condition is single-entity query over consumed event types", () => thenAppendsConditionedOn(whenCmd(givenEvents([]), {
+    TAG: "AddCategory",
+    categoryId: "c1",
+    name: "Electronics"
+  }), [{
+      eventTypes: [
+        "CategoryAdded",
+        "CategoryArchived"
+      ],
+      tags: [{
+          key: "categoryId",
+          value: "c1"
+        }]
+    }]));
+  test("exact condition matches no prior position (new entity)", () => thenAppendsConditionedOnExactly(whenCmd(givenEvents([]), {
+    TAG: "AddCategory",
+    categoryId: "c2",
+    name: "Books"
+  }), {
+    query: [{
+        eventTypes: [
+          "CategoryAdded",
+          "CategoryArchived"
+        ],
+        tags: [{
+            key: "categoryId",
+            value: "c2"
+          }]
+      }]
+  }));
+});
+
+let consumedEventSchema$1 = S.literal("Noop");
+
+let commandSchema$1 = S.schema(s => ({
+  TAG: "Do",
+  id: s.m(S.string)
+}));
+
+let errorSchema$1 = S.literal("Rejected");
+
+let eventSchema$1 = S.schema(s => ({
+  TAG: "Done",
+  id: s.m(S.string)
+}));
+
+function commandAuthorization$1(param) {
+  return "AllowAuthenticated";
+}
+
+let MissingTagSlice = {
+  name: "MissingTagSlice",
+  consumedEventSchema: consumedEventSchema$1,
+  commandSchema: commandSchema$1,
+  errorSchema: errorSchema$1,
+  eventSchema: eventSchema$1,
+  commandAuthorization: commandAuthorization$1,
+  readConsistency: "EscalateOnRetry"
+};
+
+function evolve$1(state, _event) {
+  
+}
+
+function decide$1(_state, cmd) {
+  return {
+    TAG: "Ok",
+    _0: [{
+        TAG: "Done",
+        id: cmd.id
+      }]
+  };
+}
+
+let MissingTagBehavior = {
+  Spec: undefined,
+  initialState: undefined,
+  evolve: evolve$1,
+  decide: decide$1
+};
+
+let MissingTagGwt = Behavior_GWT$ReventlessGwt.Make(MissingTagSlice)({
+  initialState: undefined,
+  evolve: evolve$1,
+  decide: decide$1
+});
+
+MissingTagGwt.describe("MissingTag slice implicit check", () => {
+  MissingTagGwt.test("thenEvent surfaces AppendConditionMismatch when command lacks DCB tag", () => {
+    let outcome = MissingTagGwt.thenEvent(MissingTagGwt.whenCmd(MissingTagGwt.givenEvents([]), {
+      TAG: "Do",
+      id: "x1"
+    }), {
+      TAG: "Done",
+      id: "x1"
+    });
+    if (outcome.TAG === "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "Throw",
+        error: "expected AppendConditionMismatch, got pass",
+        stack: ""
+      });
+    }
+    let other = outcome._0;
+    if (other.TAG === "AppendConditionMismatch") {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "Throw",
+        error: "expected AppendConditionMismatch, got: " + Outcome$ReventlessGwt.kindName(other),
+        stack: ""
+      });
+    }
+  });
+  MissingTagGwt.test("thenAppendsConditionedOnExactly bypasses implicit check (still passes with derived)", () => MissingTagGwt.thenAppendsConditionedOnExactly(MissingTagGwt.whenCmd(MissingTagGwt.givenEvents([]), {
+    TAG: "Do",
+    id: "x1"
+  }), {
+    query: [{
+        eventTypes: ["Noop"],
+        tags: []
+      }]
+  }));
+});
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+export {
+  AddCategorySlice,
+  AddCategorySliceBehavior,
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+  MissingTagSlice,
+  MissingTagBehavior,
+  MissingTagGwt,
+}
+/* consumedEventSchema Not a pure module */

package/tests/StateViewSliceGwtTest.res

@@ -0,0 +1,64 @@
+// Worked example for Projection_GWT (single-source StateViewSlice flavor).
+// Projects a small category event stream into a `{categoryId, name, archived}`
+// read model, exercising Set / Update actions.
+//
+// Plan 02 Phase 6: split-form Spec/Projection; PPX inference resolves the
+// "StateViewSlice" filename substring → Projection DSL → emits
+// [include Projection_GWT.Make(Spec, Projection)].
+
+@@reventless.gwt
+
+open Reventless.Projection
+
+module CategoriesView = {
+  let name = "CategoriesView"
+
+  @schema
+  type state = {categoryId: string, name: string, archived: bool}
+
+  @schema
+  type consumedEvent =
+    | CategoryAdded({categoryId: string, name: string})
+    | CategoryRenamed({categoryId: string, name: string})
+    | CategoryArchived({categoryId: string})
+
+  let subIdConfig = None
+}
+
+module CategoriesViewProjection = {
+  module Spec = CategoriesView
+  open CategoriesView
+
+  let project = (event: consumedEvent) =>
+    switch event {
+    | CategoryAdded({categoryId, name}) => [
+        Set(categoryId, {categoryId, name, archived: false}),
+      ]
+    | CategoryRenamed({categoryId, name}) => [
+        Update(categoryId, state => {...state, name}),
+      ]
+    | CategoryArchived({categoryId}) => [
+        Update(categoryId, state => {...state, archived: true}),
+      ]
+    }
+}
+
+describe("CategoriesView StateViewSlice", () => {
+  test("projects CategoryAdded into a new row", () =>
+    givenEvents([])
+    ->whenEvent(CategoryAdded({categoryId: "c1", name: "Electronics"}))
+    ->thenStateWithId(
+      "c1",
+      {categoryId: "c1", name: "Electronics", archived: false},
+    )
+  )
+
+  test("CategoryRenamed updates the name", () =>
+    givenEvents([CategoryAdded({categoryId: "c1", name: "Electronics"})])
+    ->whenEvent(CategoryRenamed({categoryId: "c1", name: "Consumer Electronics"}))
+    ->thenStateWithId(
+      "c1",
+      {categoryId: "c1", name: "Consumer Electronics", archived: false},
+    )
+  )
+})

package/tests/StateViewSliceGwtTest.res.mjs

@@ -0,0 +1,161 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Projection_GWT$ReventlessGwt from "../src/Projection_GWT.res.mjs";
+
+let stateSchema = S.schema(s => ({
+  categoryId: s.m(S.string),
+  name: s.m(S.string),
+  archived: s.m(S.bool)
+}));
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "CategoryAdded",
+    categoryId: s.m(S.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "CategoryRenamed",
+    categoryId: s.m(S.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "CategoryArchived",
+    categoryId: s.m(S.string)
+  }))
+]);
+
+let CategoriesView = {
+  name: "CategoriesView",
+  stateSchema: stateSchema,
+  consumedEventSchema: consumedEventSchema,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function project(event) {
+  switch (event.TAG) {
+    case "CategoryAdded" :
+      let categoryId = event.categoryId;
+      return [{
+          TAG: "Set",
+          _0: categoryId,
+          _1: {
+            categoryId: categoryId,
+            name: event.name,
+            archived: false
+          }
+        }];
+    case "CategoryRenamed" :
+      let name = event.name;
+      return [{
+          TAG: "Update",
+          _0: event.categoryId,
+          _1: state => ({
+            categoryId: state.categoryId,
+            name: name,
+            archived: state.archived
+          })
+        }];
+    case "CategoryArchived" :
+      return [{
+          TAG: "Update",
+          _0: event.categoryId,
+          _1: state => ({
+            categoryId: state.categoryId,
+            name: state.name,
+            archived: true
+          })
+        }];
+  }
+}
+
+let CategoriesViewProjection = {
+  Spec: undefined,
+  project: project
+};
+
+let include = Projection_GWT$ReventlessGwt.Make(CategoriesView)({
+  project: project
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenEvent = include.whenEvent;
+
+let thenStateWithId = include.thenStateWithId;
+
+describe("CategoriesView StateViewSlice", () => {
+  test("projects CategoryAdded into a new row", undefined, () => thenStateWithId(whenEvent(givenEvents([]), {
+    TAG: "CategoryAdded",
+    categoryId: "c1",
+    name: "Electronics"
+  }), "c1", {
+    categoryId: "c1",
+    name: "Electronics",
+    archived: false
+  }));
+  test("CategoryRenamed updates the name", undefined, () => thenStateWithId(whenEvent(givenEvents([{
+      TAG: "CategoryAdded",
+      categoryId: "c1",
+      name: "Electronics"
+    }]), {
+    TAG: "CategoryRenamed",
+    categoryId: "c1",
+    name: "Consumer Electronics"
+  }), "c1", {
+    categoryId: "c1",
+    name: "Consumer Electronics",
+    archived: false
+  }));
+});
+
+let Spec = include.Spec;
+
+let describeWithId = include.describeWithId;
+
+let todo = include.todo;
+
+let whenEvents = include.whenEvents;
+
+let thenStates = include.thenStates;
+
+let thenStatesWithId = include.thenStatesWithId;
+
+let thenAllStates = include.thenAllStates;
+
+let thenState = include.thenState;
+
+let thenNoState = include.thenNoState;
+
+let thenThrow = include.thenThrow;
+
+let thenFail = include.thenFail;
+
+export {
+  CategoriesView,
+  CategoriesViewProjection,
+  Spec,
+  describe,
+  describeWithId,
+  todo,
+  test,
+  givenEvents,
+  whenEvent,
+  whenEvents,
+  thenStates,
+  thenStatesWithId,
+  thenAllStates,
+  thenState,
+  thenStateWithId,
+  thenNoState,
+  thenThrow,
+  thenFail,
+}
+/* stateSchema Not a pure module */

package/tests/WatchDebounceTest.res

@@ -0,0 +1,106 @@
+// Unit tests for Watch's event coalescing — the part Phase 12 added so a
+// relocation's structural `unlink` survives a debounce window that also carries
+// the trailing `add`/`change` of the same `mv`. The debounce uses real
+// setTimeout(120ms), so these await past the window.
+
+open JestGlobals
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+let delay = (ms: int): promise<unit> =>
+  Promise.make((resolve, _reject) => setTimeout(() => resolve(), ms))
+
+describe("Watch.isStructuralSource", () => {
+  testPromise("an unlink of a .res source is structural", async () =>
+    expect(Watch.isStructuralSource(Unlink, "/p/src/Foo/Bar.res"))->toEqual(true)
+  )
+  testPromise("a generated .res.mjs unlink is NOT structural (ends in .mjs)", async () =>
+    expect(Watch.isStructuralSource(Unlink, "/p/src/Foo/Bar.res.mjs"))->toEqual(false)
+  )
+  testPromise("an add of a .res source is not structural (incremental handles it)", async () =>
+    expect(Watch.isStructuralSource(Add, "/p/src/Foo/Bar.res"))->toEqual(false)
+  )
+  testPromise("a change of a .res source is not structural", async () =>
+    expect(Watch.isStructuralSource(Change, "/p/src/Foo/Bar.res"))->toEqual(false)
+  )
+})
+
+describe("Watch.debounce coalescing", () => {
+  testPromise("a burst collapses to one call carrying the strongest event", async () => {
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
+    // A move/ungroup: the new file is created, an edit lands, then the old file
+    // is unlinked — all inside one window. The unlink must win.
+    fire(Watch.Change, "/p/src/A.res")
+    fire(Watch.Add, "/p/src/new/A.res")
+    fire(Watch.Unlink, "/p/src/old/A.res")
+    await delay(120)
+    expect(calls.contents->Array.length)->toEqual(1)
+    let (e, p) = calls.contents->Array.getUnsafe(0)
+    expect(e)->toEqual(Watch.Unlink)
+    expect(p)->toEqual("/p/src/old/A.res")
+  })
+
+  testPromise("a later weaker event does not mask an earlier unlink", async () => {
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
+    fire(Watch.Unlink, "/p/src/old/A.res")
+    fire(Watch.Change, "/p/src/A.res")
+    await delay(120)
+    expect(calls.contents)->toEqual([Watch.Unlink])
+  })
+
+  testPromise("interleaved .res.mjs unlinks never surface; each distinct .res source does", async () => {
+    // The real directory-mv burst chokidar emits: source AND generated files
+    // unlink interleaved. Only `.res` sources are emitted (never a `.res.mjs`),
+    // and every *distinct* source is emitted — two moved modules must both drive
+    // a rebuild, not collapse to one representative.
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
+    fire(Watch.Unlink, "/p/src/old/A.res")
+    fire(Watch.Unlink, "/p/src/old/A.res.mjs")
+    fire(Watch.Unlink, "/p/src/old/A_Behavior.res")
+    fire(Watch.Unlink, "/p/src/old/A_Behavior.res.mjs")
+    fire(Watch.Add, "/p/src/new/A.res")
+    fire(Watch.Add, "/p/src/new/A.res.mjs")
+    await delay(120)
+    let paths = calls.contents->Array.map(((_, p)) => p)
+    expect(calls.contents->Array.every(((e, p)) => Watch.isStructuralSource(e, p)))->toEqual(true)
+    expect(paths->Array.includes("/p/src/old/A.res"))->toEqual(true)
+    expect(paths->Array.includes("/p/src/old/A_Behavior.res"))->toEqual(true)
+    expect(paths->Array.some(p => p->String.endsWith(".mjs")))->toEqual(false)
+    expect(calls.contents->Array.length)->toEqual(2)
+  })
+
+  testPromise("a burst spanning two packages emits an unlink per package (A4.1)", async () => {
+    // Regression: the old single-`bestPath` debounce clean-rebuilt only one
+    // package on a multi-package burst, stranding the other with stale .res.mjs.
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, p) => calls := Array.concat(calls.contents, [(e, p)]))
+    fire(Watch.Unlink, "/pkgA/src/Foo.res")
+    fire(Watch.Unlink, "/pkgB/src/Bar.res")
+    await delay(120)
+    let paths = calls.contents->Array.map(((_, p)) => p)
+    expect(paths->Array.includes("/pkgA/src/Foo.res"))->toEqual(true)
+    expect(paths->Array.includes("/pkgB/src/Bar.res"))->toEqual(true)
+    expect(calls.contents->Array.length)->toEqual(2)
+  })
+
+  testPromise("a structural signal suppresses a co-occurring plain change", async () => {
+    // A structural rebuild does its own re-run, so a plain edit in the same
+    // window must not also emit a separate Change (which would double-run).
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
+    fire(Watch.Change, "/p/src/Edited.res")
+    fire(Watch.Unlink, "/p/src/old/Moved.res")
+    await delay(120)
+    expect(calls.contents)->toEqual([Watch.Unlink])
+  })
+
+  testPromise("a lone change stays a change (incremental re-run)", async () => {
+    let calls = ref([])
+    let fire = Watch.debounce(40, (e, _p) => calls := Array.concat(calls.contents, [e]))
+    fire(Watch.Change, "/p/src/A.res")
+    await delay(120)
+    expect(calls.contents)->toEqual([Watch.Change])
+  })
+})