@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/Behavior_GWT.res.mjs

@@ -0,0 +1,426 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
+
+function encodeTag(t) {
+  let d = {};
+  d["key"] = t.key;
+  d["value"] = t.value;
+  return d;
+}
+
+function encodeQueryItem(qi) {
+  let d = {};
+  let types = qi.eventTypes;
+  if (types !== undefined) {
+    d["eventTypes"] = types.map(prim => prim);
+  }
+  let tags = qi.tags;
+  if (tags !== undefined) {
+    d["tags"] = tags.map(encodeTag);
+  }
+  return d;
+}
+
+function encodeQuery(q) {
+  return q.map(encodeQueryItem);
+}
+
+function encodeAppendCondition(c) {
+  let d = {};
+  d["query"] = c.query.map(encodeQueryItem);
+  let pos = c.after;
+  if (pos !== undefined) {
+    d["after"] = pos;
+  }
+  return d;
+}
+
+function Make(Spec) {
+  return Behavior => {
+    S.enableJson();
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let errors = {
+      contents: []
+    };
+    let derivedCondition = {
+      contents: undefined
+    };
+    let appendConditionFailure = {
+      contents: undefined
+    };
+    let consumedEventTypes = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema).eventTypes;
+    let scopeShape = DcbTag$Reventless.sliceShapeFromSchemas("", Spec.commandSchema, Spec.consumedEventSchema, Spec.eventSchema);
+    let set = new Set();
+    DcbTag$Reventless.extractCrossPartitionTagKeys(Spec.eventSchema).forEach(k => {
+      set.add(k);
+    });
+    DcbScopeInference$Reventless.crossPartitionForSlice(scopeShape).forEach(k => {
+      set.add(k);
+    });
+    let crossPartitionTagKeys = Array.from(set.values()).toSorted(Primitive_string.compare);
+    let tagKeysByEventType = DcbScopeInference$Reventless.infer([scopeShape]).tagKeysByEventType;
+    let emittedEventTypes = DcbDecode$Reventless.makeDecoder(Spec.eventSchema).eventTypes;
+    let consumedTagKeysByType = DcbTag$Reventless.extractTagKeysByEventType(Spec.consumedEventSchema);
+    let queryTagKeys = query => query.flatMap(qi => Stdlib_Option.mapOr(qi.tags, [], tags => tags.map(t => t.key)));
+    let selectableBy = (query, declaredKeys) => {
+      if (query.length === 0) {
+        return true;
+      } else {
+        return query.some(qi => {
+          let tags = qi.tags;
+          if (tags !== undefined && tags.length !== 0) {
+            return tags.every(t => declaredKeys.includes(t.key));
+          } else {
+            return true;
+          }
+        });
+      }
+    };
+    let unreachableForeignReads = query => {
+      let qKeys = queryTagKeys(query);
+      return Stdlib_Array.filterMap(Object.entries(consumedTagKeysByType), param => {
+        let keys = param[1];
+        let evType = param[0];
+        let key = keys.find(k => qKeys.includes(k));
+        if (key !== undefined && !emittedEventTypes.includes(evType) && !selectableBy(query, keys)) {
+          return [
+            evType,
+            key
+          ];
+        }
+      });
+    };
+    let queryTagsTotal = q => Stdlib_Array.reduce(q, 0, (acc, qi) => acc + Stdlib_Option.mapOr(qi.tags, 0, t => t.length) | 0);
+    let givenEvents = consumed => consumed;
+    let whenCmd = (history, cmd) => {
+      errors.contents = [];
+      appendConditionFailure.contents = undefined;
+      let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, cmd, tagKeysByEventType, crossPartitionTagKeys);
+      let condition = {
+        query: query
+      };
+      derivedCondition.contents = condition;
+      if (consumedEventTypes.length !== 0 && queryTagsTotal(query) === 0) {
+        appendConditionFailure.contents = {
+          TAG: "AppendConditionMismatch",
+          expected: "a non-empty tag set derived from @s.matches(DcbTag.string) fields on the command",
+          actual: encodeAppendCondition(condition)
+        };
+      } else {
+        let match = unreachableForeignReads(query)[0];
+        if (match !== undefined) {
+          let key = match[1];
+          let evType = match[0];
+          appendConditionFailure.contents = {
+            TAG: "AppendConditionMismatch",
+            expected: `a decision-query clause that selects '` + evType + `' on tag '` + key + `' alone — this is a cross-entity read, so mark '` + key + `' @crossPartition (or model it as a tagged array) and it will fan into its own clause; otherwise the decision model can never see '` + evType + `'`,
+            actual: encodeAppendCondition(condition)
+          };
+        }
+      }
+      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
+      let events = Behavior.decide(state, cmd);
+      if (events.TAG === "Ok") {
+        return events._0;
+      }
+      errors.contents = [events._0];
+      return [];
+    };
+    let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
+    let encError = err => Message$ReventlessCore.encode(err, Spec.errorSchema);
+    let checkAppendCondition = () => Stdlib_Option.map(appendConditionFailure.contents, Outcome$ReventlessGwt.fail);
+    let unexpectedError = events => {
+      let actual = Stdlib_Option.map(errors.contents[0], encError);
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: null,
+        actual: actual,
+        actualEvents: events.map(encEvent)
+      });
+    };
+    let thenEvents = (events, expectedEvents) => {
+      let o = checkAppendCondition();
+      if (o !== undefined) {
+        return o;
+      } else if (errors.contents.length !== 0) {
+        return unexpectedError(events);
+      } else if (Primitive_object.equal(events, expectedEvents)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expectedEvents.map(encEvent),
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent]);
+    let thenNoEvent = events => {
+      let o = checkAppendCondition();
+      if (o !== undefined) {
+        return o;
+      } else if (errors.contents.length !== 0) {
+        return unexpectedError(events);
+      } else if (events.length === 0) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "NoEventExpected",
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let matchesError = (events, expectedEvents, expectedError) => {
+      let expectedErrorJson = Message$ReventlessCore.encode(expectedError, Spec.errorSchema);
+      let actual = errors.contents[0];
+      if (actual === undefined) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expectedErrorJson,
+          actual: undefined,
+          actualEvents: events.map(encEvent)
+        });
+      }
+      let actual$1 = Primitive_option.valFromOption(actual);
+      if (Primitive_object.notequal(actual$1, expectedError)) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expectedErrorJson,
+          actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
+          actualEvents: events.map(encEvent)
+        });
+      } else if (Primitive_object.equal(events, expectedEvents)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expectedEvents.map(encEvent),
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let thenError = (events, expectedError) => {
+      let o = checkAppendCondition();
+      if (o !== undefined) {
+        return o;
+      } else {
+        return matchesError(events, [], expectedError);
+      }
+    };
+    let thenEventWithError = (events, expectedEvent, expectedError) => {
+      let o = checkAppendCondition();
+      if (o !== undefined) {
+        return o;
+      } else {
+        return matchesError(events, [expectedEvent], expectedError);
+      }
+    };
+    let thenEventsWithError = (events, expectedEvents, expectedError) => {
+      let o = checkAppendCondition();
+      if (o !== undefined) {
+        return o;
+      } else {
+        return matchesError(events, expectedEvents, expectedError);
+      }
+    };
+    let thenAppendsConditionedOn = (_events, expectedQuery) => {
+      let cond = derivedCondition.contents;
+      if (cond !== undefined) {
+        if (Primitive_object.equal(cond.query, expectedQuery)) {
+          return Outcome$ReventlessGwt.pass;
+        } else {
+          return Outcome$ReventlessGwt.fail({
+            TAG: "AppendConditionMismatch",
+            expected: encodeAppendCondition({
+              query: expectedQuery
+            }),
+            actual: encodeAppendCondition(cond)
+          });
+        }
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "Throw",
+          error: "thenAppendsConditionedOn: whenCmd must be called before this assertion",
+          stack: ""
+        });
+      }
+    };
+    let thenAppendsConditionedOnExactly = (_events, expectedCondition) => {
+      let cond = derivedCondition.contents;
+      if (cond !== undefined) {
+        if (Primitive_object.equal(cond, expectedCondition)) {
+          return Outcome$ReventlessGwt.pass;
+        } else {
+          return Outcome$ReventlessGwt.fail({
+            TAG: "AppendConditionMismatch",
+            expected: encodeAppendCondition(expectedCondition),
+            actual: encodeAppendCondition(cond)
+          });
+        }
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "Throw",
+          error: "thenAppendsConditionedOnExactly: whenCmd must be called before this assertion",
+          stack: ""
+        });
+      }
+    };
+    return {
+      Spec: Spec,
+      describe: JestBind$ReventlessGwt.describe,
+      todo: JestBind$ReventlessGwt.todo,
+      test: test,
+      givenEvents: givenEvents,
+      whenCmd: whenCmd,
+      thenEvent: thenEvent,
+      thenEvents: thenEvents,
+      thenNoEvent: thenNoEvent,
+      thenEventWithError: thenEventWithError,
+      thenEventsWithError: thenEventsWithError,
+      thenError: thenError,
+      thenAppendsConditionedOn: thenAppendsConditionedOn,
+      thenAppendsConditionedOnExactly: thenAppendsConditionedOnExactly
+    };
+  };
+}
+
+function MakeFromAggregate(Spec) {
+  return Behavior => {
+    S.enableJson();
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let errors = {
+      contents: []
+    };
+    let givenEvents = events => events;
+    let whenCmd = (history, cmd) => {
+      errors.contents = [];
+      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
+      let events = Behavior.decide(state, cmd);
+      if (events.TAG === "Ok") {
+        return events._0;
+      }
+      errors.contents = [events._0];
+      return [];
+    };
+    let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
+    let encError = err => Message$ReventlessCore.encode(err, Spec.errorSchema);
+    let unexpectedError = events => {
+      let actual = Stdlib_Option.map(errors.contents[0], encError);
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: null,
+        actual: actual,
+        actualEvents: events.map(encEvent)
+      });
+    };
+    let thenEvents = (events, expectedEvents) => {
+      if (errors.contents.length !== 0) {
+        return unexpectedError(events);
+      } else if (Primitive_object.equal(events, expectedEvents)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expectedEvents.map(encEvent),
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let thenCompareEvents = (events, expectedEvents, cmp) => {
+      if (errors.contents.length !== 0) {
+        return unexpectedError(events);
+      } else if (events.length === expectedEvents.length && Stdlib_Array.zip(events, expectedEvents).every(param => cmp(param[0], param[1]))) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expectedEvents.map(encEvent),
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent]);
+    let thenCompareEvent = (events, expectedEvent, cmp) => thenCompareEvents(events, [expectedEvent], cmp);
+    let thenNoEvent = events => {
+      if (errors.contents.length !== 0) {
+        return unexpectedError(events);
+      } else if (events.length === 0) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "NoEventExpected",
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let matchesError = (events, expectedEvents, expectedError) => {
+      let expectedErrorJson = Message$ReventlessCore.encode(expectedError, Spec.errorSchema);
+      let actual = errors.contents[0];
+      if (actual === undefined) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expectedErrorJson,
+          actual: undefined,
+          actualEvents: events.map(encEvent)
+        });
+      }
+      let actual$1 = Primitive_option.valFromOption(actual);
+      if (Primitive_object.notequal(actual$1, expectedError)) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expectedErrorJson,
+          actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
+          actualEvents: events.map(encEvent)
+        });
+      } else if (Primitive_object.equal(events, expectedEvents)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expectedEvents.map(encEvent),
+          actual: events.map(encEvent)
+        });
+      }
+    };
+    let thenError = (events, expectedError) => matchesError(events, [], expectedError);
+    let thenEventWithError = (events, expectedEvent, expectedError) => matchesError(events, [expectedEvent], expectedError);
+    let thenEventsWithError = matchesError;
+    return {
+      Spec: Spec,
+      describe: JestBind$ReventlessGwt.describe,
+      test: test,
+      givenEvents: givenEvents,
+      whenCmd: whenCmd,
+      thenEvent: thenEvent,
+      thenCompareEvent: thenCompareEvent,
+      thenNoEvent: thenNoEvent,
+      thenEventWithError: thenEventWithError,
+      thenEvents: thenEvents,
+      thenCompareEvents: thenCompareEvents,
+      thenEventsWithError: thenEventsWithError,
+      thenError: thenError
+    };
+  };
+}
+
+export {
+  encodeTag,
+  encodeQueryItem,
+  encodeQuery,
+  encodeAppendCondition,
+  Make,
+  MakeFromAggregate,
+}
+/* S Not a pure module */

package/src/Bind.res

@@ -0,0 +1,29 @@
+// CLI-mode binding for test files.
+//
+// Mirrors the shape of `JestBind` (`describe`, `test`, `testPromise`) but
+// pushes directly into `Collector` instead of forwarding to Jest globals.
+// Test files can either:
+//
+//   1. Rely on the DSL default (every `*_GWT.res` module uses `JestBind`
+//      internally, which routes to `Collector` when the CLI has activated it),
+//      or
+//   2. Explicitly `open ReventlessGwt.Bind` to get these functions bound at
+//      compile time — useful for ad-hoc harnesses or tests that want to
+//      bypass the JestBind fallback entirely.
+//
+// Either way, the runtime contract is identical: each call pushes one entry
+// into `Collector.entries`. The CLI drains the list after dynamic-import
+// resolves.
+
+let describe = (label: string, body: unit => unit) =>
+  Collector.pushDescribe(label, body)
+
+let test = (~slice=?, name: string, body: unit => Outcome.outcome) => {
+  let location = Collector.captureLocation(1)
+  Collector.push(~slice?, ~location?, name, () => Promise.resolve(body()))
+}
+
+let testPromise = (~slice=?, name: string, body: unit => promise<Outcome.outcome>) => {
+  let location = Collector.captureLocation(1)
+  Collector.push(~slice?, ~location?, name, body)
+}

package/src/Bind.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Collector$ReventlessGwt from "./Collector.res.mjs";
+
+let describe = Collector$ReventlessGwt.pushDescribe;
+
+function test(slice, name, body) {
+  let location = Collector$ReventlessGwt.captureLocation(1);
+  Collector$ReventlessGwt.push(slice, location, name, () => Promise.resolve(body()));
+}
+
+function testPromise(slice, name, body) {
+  let location = Collector$ReventlessGwt.captureLocation(1);
+  Collector$ReventlessGwt.push(slice, location, name, body);
+}
+
+export {
+  describe,
+  test,
+  testPromise,
+}
+/* No side effect */

package/src/BuildClassifier.res

@@ -0,0 +1,137 @@
+// Turns a ReScript v12 `rescript build -w` stdout line-stream into build status
+// callbacks. One classifier per managed package.
+//
+// The watch output cycle is:
+//   Parsed N source files          ← a compile pass begins
+//   Compiled N modules
+//   Finished incremental compilation   ← success terminator
+// On a type/syntax error there is NO terminator — rescript prints a
+// "We've found a bug for you!" block and waits. So success is detected on the
+// "Finished … compilation" line; failure is detected by an error marker and
+// flushed after the output settles (debounced), since there is no end line.
+//
+// Backstop: a build that prints "Parsed …" but then emits neither a terminator
+// nor a recognised error marker — a crashed/hung watcher, or an error in a form
+// the markers miss — would otherwise pin the consumer (the VS Code status bar)
+// at "building" forever. A generous wall-clock watchdog fails such a build so
+// the UI recovers.
+
+@val external now: unit => float = "performance.now"
+@val external setTimeout: (unit => unit, int) => float = "setTimeout"
+@val external clearTimeout: float => unit = "clearTimeout"
+
+let stripAnsi: string => string = %raw(`s => s.replace(/\x1b\[[0-9;]*m/g, "")`)
+
+type callbacks = {
+  onStart: unit => unit,
+  onOk: float => unit,
+  onFail: string => unit,
+}
+
+let isStartLine = (l: string) =>
+  String.startsWith(l, "Parsed ") && String.endsWith(l, "source files")
+
+let isFinishLine = (l: string) =>
+  String.includes(l, "Finished") && String.includes(l, "compilation")
+
+let isErrorMarker = (l: string) =>
+  String.includes(l, "We've found a bug for you!") ||
+  String.includes(l, "Syntax error") ||
+  (String.startsWith(l, "Found ") && String.includes(l, "error"))
+
+// Returns a `feed` function: hand it each raw stdout line. `watchdogMs` bounds
+// how long a started-but-unterminated compile may stay "building" before it is
+// reported failed (see the backstop note above).
+let make = (~watchdogMs: int=120_000, cb: callbacks): (string => unit) => {
+  let compiling = ref(false)
+  let hasError = ref(false)
+  let startTime = ref(0.0)
+  let buffer = ref([])
+  let timer: ref<option<float>> = ref(None)
+  let watchdog: ref<option<float>> = ref(None)
+
+  let clearTimer = () =>
+    switch timer.contents {
+    | Some(t) => {
+        clearTimeout(t)
+        timer := None
+      }
+    | None => ()
+    }
+
+  let clearWatchdog = () =>
+    switch watchdog.contents {
+    | Some(t) => {
+        clearTimeout(t)
+        watchdog := None
+      }
+    | None => ()
+    }
+
+  let reset = () => {
+    compiling := false
+    hasError := false
+    buffer := []
+  }
+
+  // After output settles, a compile that saw an error (and thus no "Finished"
+  // terminator) is reported failed, capturing a concise message.
+  let settle = () =>
+    if compiling.contents && hasError.contents {
+      let msg = buffer.contents->Array.slice(~start=0, ~end=20)->Array.join("\n")
+      clearWatchdog()
+      cb.onFail(msg)
+      reset()
+    }
+
+  let arm = () => {
+    clearTimer()
+    timer := Some(setTimeout(settle, 400))
+  }
+
+  // Last-resort timer: fail a build still compiling after `watchdogMs` with no
+  // terminator and no recognised error, so the consumer never spins forever.
+  let armWatchdog = () => {
+    clearWatchdog()
+    watchdog :=
+      Some(
+        setTimeout(() =>
+          if compiling.contents {
+            clearTimer()
+            cb.onFail("build watchdog: no completion within " ++ Int.toString(watchdogMs / 1000) ++ "s")
+            reset()
+          }
+        , watchdogMs),
+      )
+  }
+
+  line => {
+    let l = stripAnsi(line)->String.trim
+    if isStartLine(l) {
+      if !compiling.contents {
+        cb.onStart()
+      }
+      compiling := true
+      hasError := false
+      buffer := []
+      startTime := now()
+      arm()
+      armWatchdog()
+    } else if isFinishLine(l) {
+      clearTimer()
+      clearWatchdog()
+      if compiling.contents {
+        cb.onOk(now() -. startTime.contents)
+        reset()
+      }
+    } else {
+      if String.length(l) > 0 {
+        buffer := Array.concat(buffer.contents, [l])
+      }
+      if isErrorMarker(l) {
+        hasError := true
+      }
+      arm()
+    }
+  }
+}