@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Behavior_GWT.res.mjs

@@ -0,0 +1,523 @@
+// 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 AssertionCore(Spec) {
+  let errors = {
+    contents: []
+  };
+  let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
+  let encEvents = evs => evs.map(encEvent);
+  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 compareEvents = (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 compareEventsWith = (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 compareNoEvent = 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)
+      });
+    }
+  };
+  return {
+    errors: errors,
+    encEvent: encEvent,
+    encEvents: encEvents,
+    encError: encError,
+    unexpectedError: unexpectedError,
+    compareEvents: compareEvents,
+    compareEventsWith: compareEventsWith,
+    compareNoEvent: compareNoEvent,
+    matchesError: matchesError
+  };
+}
+
+function Make(Spec) {
+  return Behavior => {
+    S.enableJson();
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let errors = {
+      contents: []
+    };
+    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 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 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 checkAppendCondition = () => Stdlib_Option.map(appendConditionFailure.contents, Outcome$ReventlessGwt.fail);
+    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 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 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 compareEvents = (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 compareEventsWith = (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 compareNoEvent = 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 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 thenEvent = (events, expectedEvent) => compareEvents(events, [expectedEvent]);
+    let thenCompareEvent = (events, expectedEvent, cmp) => compareEventsWith(events, [expectedEvent], cmp);
+    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: compareNoEvent,
+      thenEventWithError: thenEventWithError,
+      thenEvents: compareEvents,
+      thenCompareEvents: compareEventsWith,
+      thenEventsWithError: thenEventsWithError,
+      thenError: thenError
+    };
+  };
+}
+
+export {
+  encodeTag,
+  encodeQueryItem,
+  encodeQuery,
+  encodeAppendCondition,
+  AssertionCore,
+  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, undefined, name, () => Promise.resolve(body()));
+}
+
+function testPromise(slice, name, body) {
+  let location = Collector$ReventlessGwt.captureLocation(1);
+  Collector$ReventlessGwt.push(slice, location, undefined, name, body);
+}
+
+export {
+  describe,
+  test,
+  testPromise,
+}
+/* No side effect */