@reventlessdev/reventless-gwt 1.0.0-alpha.74

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,78 @@
+// 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 don't steal the representative path", async () => {
+    // The real directory-mv burst chokidar emits: source AND generated files
+    // unlink interleaved. The coalesced path must be a `.res` source, not the
+    // last-seen `.res.mjs` (which would misclassify as a non-structural change).
+    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)
+    expect(calls.contents->Array.length)->toEqual(1)
+    let (e, p) = calls.contents->Array.getUnsafe(0)
+    expect(e)->toEqual(Watch.Unlink)
+    expect(Watch.isStructuralSource(e, p))->toEqual(true)
+  })
+
+  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])
+  })
+})

package/tests/WatchDebounceTest.res.mjs

@@ -0,0 +1,97 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Watch$ReventlessGwt from "../src/Watch.res.mjs";
+
+function delay(ms) {
+  return new Promise((resolve, _reject) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+globalThis.describe("Watch.isStructuralSource", () => {
+  globalThis.test("an unlink of a .res source is structural", async () => {
+    globalThis.expect(Watch$ReventlessGwt.isStructuralSource("Unlink", "/p/src/Foo/Bar.res")).toEqual(true);
+  });
+  globalThis.test("a generated .res.mjs unlink is NOT structural (ends in .mjs)", async () => {
+    globalThis.expect(Watch$ReventlessGwt.isStructuralSource("Unlink", "/p/src/Foo/Bar.res.mjs")).toEqual(false);
+  });
+  globalThis.test("an add of a .res source is not structural (incremental handles it)", async () => {
+    globalThis.expect(Watch$ReventlessGwt.isStructuralSource("Add", "/p/src/Foo/Bar.res")).toEqual(false);
+  });
+  globalThis.test("a change of a .res source is not structural", async () => {
+    globalThis.expect(Watch$ReventlessGwt.isStructuralSource("Change", "/p/src/Foo/Bar.res")).toEqual(false);
+  });
+});
+
+globalThis.describe("Watch.debounce coalescing", () => {
+  globalThis.test("a burst collapses to one call carrying the strongest event", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, p) => {
+      calls.contents = calls.contents.concat([[
+          e,
+          p
+        ]]);
+    });
+    fire("Change", "/p/src/A.res");
+    fire("Add", "/p/src/new/A.res");
+    fire("Unlink", "/p/src/old/A.res");
+    await delay(120);
+    globalThis.expect(calls.contents.length).toEqual(1);
+    let match = calls.contents[0];
+    globalThis.expect(match[0]).toEqual("Unlink");
+    globalThis.expect(match[1]).toEqual("/p/src/old/A.res");
+  });
+  globalThis.test("a later weaker event does not mask an earlier unlink", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, _p) => {
+      calls.contents = calls.contents.concat([e]);
+    });
+    fire("Unlink", "/p/src/old/A.res");
+    fire("Change", "/p/src/A.res");
+    await delay(120);
+    globalThis.expect(calls.contents).toEqual(["Unlink"]);
+  });
+  globalThis.test("interleaved .res.mjs unlinks don't steal the representative path", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, p) => {
+      calls.contents = calls.contents.concat([[
+          e,
+          p
+        ]]);
+    });
+    fire("Unlink", "/p/src/old/A.res");
+    fire("Unlink", "/p/src/old/A.res.mjs");
+    fire("Unlink", "/p/src/old/A_Behavior.res");
+    fire("Unlink", "/p/src/old/A_Behavior.res.mjs");
+    fire("Add", "/p/src/new/A.res");
+    fire("Add", "/p/src/new/A.res.mjs");
+    await delay(120);
+    globalThis.expect(calls.contents.length).toEqual(1);
+    let match = calls.contents[0];
+    let e = match[0];
+    globalThis.expect(e).toEqual("Unlink");
+    globalThis.expect(Watch$ReventlessGwt.isStructuralSource(e, match[1])).toEqual(true);
+  });
+  globalThis.test("a lone change stays a change (incremental re-run)", async () => {
+    let calls = {
+      contents: []
+    };
+    let fire = Watch$ReventlessGwt.debounce(40, (e, _p) => {
+      calls.contents = calls.contents.concat([e]);
+    });
+    fire("Change", "/p/src/A.res");
+    await delay(120);
+    globalThis.expect(calls.contents).toEqual(["Change"]);
+  });
+});
+
+export {
+  delay,
+}
+/*  Not a pure module */