@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Mapping_GWT.res.mjs

@@ -0,0 +1,322 @@
+// 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 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";
+
+function FromBehavior(Spec) {
+  return Behavior => ({
+    name: Spec.name,
+    Id: Spec.Id,
+    initialState: Behavior.initialState,
+    consumedEventSchema: Spec.eventSchema,
+    evolve: Behavior.evolve,
+    commandSchema: Spec.commandSchema,
+    eventSchema: Spec.eventSchema,
+    errorSchema: Spec.errorSchema,
+    decide: Behavior.decide
+  });
+}
+
+function FromStateChangeSlice(Spec) {
+  return {
+    name: Spec.name,
+    Id: undefined,
+    initialState: Spec.initialState,
+    consumedEventSchema: Spec.consumedEventSchema,
+    evolve: Spec.evolve,
+    commandSchema: Spec.commandSchema,
+    eventSchema: Spec.eventSchema,
+    errorSchema: Spec.errorSchema,
+    decide: Spec.decide
+  };
+}
+
+function Make(M) {
+  let Source = M.Source;
+  let Target = M.Target;
+  S.enableJson();
+  let sliceName = Source.name + `→` + Target.name;
+  let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(sliceName, name, timeout, body);
+  let queryEngine_scan = (param, param$1, param$2) => Promise.resolve([]);
+  let queryEngine_query = (param, param$1, param$2, param$3, param$4, param$5, param$6) => Promise.resolve([]);
+  let queryEngine = {
+    scan: queryEngine_scan,
+    query: queryEngine_query
+  };
+  let sourceErrors = {
+    contents: []
+  };
+  let targetErrors = {
+    contents: []
+  };
+  let execSource = (history, cmd) => {
+    sourceErrors.contents = [];
+    let state = Stdlib_Array.reduce(history, Source.initialState, Source.evolve);
+    let events = Source.decide(state, cmd);
+    if (events.TAG === "Ok") {
+      return events._0;
+    }
+    sourceErrors.contents = [events._0];
+    return [];
+  };
+  let execTarget = (history, cmd) => {
+    let state = Stdlib_Array.reduce(history, Target.initialState, Target.evolve);
+    let events = Target.decide(state, cmd);
+    if (events.TAG === "Ok") {
+      return events._0;
+    }
+    targetErrors.contents = [events._0];
+    return [];
+  };
+  let givenSourceEvents = sourceHistory => [
+    sourceHistory,
+    []
+  ];
+  let andTargetEvents = (param, targetHistory) => [
+    param[0],
+    targetHistory
+  ];
+  let whenSourceCmd = async (param, sourceId, cmd) => {
+    targetErrors.contents = [];
+    let sourceEvents = execSource(param[0], cmd);
+    let targetActions = sourceEvents.map(sourceEvent => M.map(Source.Id.makeFromString(sourceId), sourceEvent, queryEngine)).flat();
+    let targetHistories = Object.fromEntries(param[1]);
+    let commands = (await Promise.all(targetActions.map(async action => {
+      switch (action.TAG) {
+        case "Publish" :
+        case "PublishDelayed" :
+          return [[
+              action._0,
+              action._1
+            ]];
+        case "PublishAsync" :
+          return await action._0;
+        default:
+          return [];
+      }
+    }))).flat();
+    return Stdlib_Array.reduce(commands, {}, (targetEvents, param) => {
+      let idStr = Target.Id.toString(param[0]);
+      let hist = Stdlib_Option.getOr(targetHistories[idStr], []);
+      let newEvents = execTarget(hist, param[1]);
+      targetEvents[idStr] = Stdlib_Option.getOr(targetEvents[idStr], []).concat(newEvents);
+      return targetEvents;
+    });
+  };
+  let encTargetEvent = e => Message$ReventlessCore.encode(e, Target.eventSchema);
+  let encDict = d => Object.entries(d).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => {
+    let obj = {};
+    obj["id"] = param[0];
+    obj["events"] = param[1].map(encTargetEvent);
+    return obj;
+  });
+  let encExpected = pairs => pairs.toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => {
+    let obj = {};
+    obj["id"] = param[0];
+    obj["events"] = param[1].map(encTargetEvent);
+    return obj;
+  });
+  let unexpectedSideError = actualDict => {
+    let actualEvents = encDict(actualDict);
+    let srcErr = sourceErrors.contents[0];
+    if (srcErr !== undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: null,
+        actual: Message$ReventlessCore.encode(Primitive_option.valFromOption(srcErr), Source.errorSchema),
+        actualEvents: actualEvents
+      });
+    }
+    let tgtErr = targetErrors.contents[0];
+    if (tgtErr !== undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: null,
+        actual: Message$ReventlessCore.encode(Primitive_option.valFromOption(tgtErr), Target.errorSchema),
+        actualEvents: actualEvents
+      });
+    } else {
+      return Outcome$ReventlessGwt.pass;
+    }
+  };
+  let dictPairsEq = (a, b) => {
+    let ka = Object.keys(a).toSorted(Primitive_string.compare);
+    let kb = Object.keys(b).toSorted(Primitive_string.compare);
+    if (Primitive_object.equal(ka, kb)) {
+      return ka.every(k => {
+        let av = Stdlib_Option.getOr(a[k], []);
+        let bv = Stdlib_Option.getOr(b[k], []);
+        return Primitive_object.equal(av, bv);
+      });
+    } else {
+      return false;
+    }
+  };
+  let thenTargetEvents = async (targetEvents, expectedTargetEvents) => {
+    let actualDict = await targetEvents;
+    let out = unexpectedSideError(actualDict);
+    if (out.TAG !== "Ok") {
+      return out;
+    }
+    let expectedDict = Object.fromEntries(expectedTargetEvents);
+    if (dictPairsEq(actualDict, expectedDict)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: encExpected(expectedTargetEvents),
+        actual: encDict(actualDict)
+      });
+    }
+  };
+  let thenTargetEvent = async (targetEvents, id, expectedTargetEvent) => {
+    let actualDict = await targetEvents;
+    let out = unexpectedSideError(actualDict);
+    if (out.TAG !== "Ok") {
+      return out;
+    }
+    let pairs = Object.entries(actualDict);
+    let ok = false;
+    if (pairs.length === 1) {
+      let match = pairs[0];
+      let tmp;
+      if (match !== undefined) {
+        let match$1 = match[1];
+        if (match$1.length !== 1) {
+          tmp = false;
+        } else {
+          let actualEvent = match$1[0];
+          tmp = match[0] === id && Primitive_object.equal(actualEvent, expectedTargetEvent);
+        }
+      } else {
+        tmp = false;
+      }
+      ok = tmp;
+    }
+    if (ok) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: encExpected([[
+            id,
+            [expectedTargetEvent]
+          ]]),
+        actual: encDict(actualDict)
+      });
+    }
+  };
+  let thenNoTargetEvent = targetEvents => thenTargetEvents(targetEvents, []);
+  let thenSourceError = async (targetEvents, expectedError) => {
+    let actualDict = await targetEvents;
+    let actualEvents = encDict(actualDict);
+    let expectedJson = Message$ReventlessCore.encode(expectedError, Source.errorSchema);
+    let actual = sourceErrors.contents[0];
+    if (actual === undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedJson,
+        actual: undefined,
+        actualEvents: actualEvents
+      });
+    }
+    let actual$1 = Primitive_option.valFromOption(actual);
+    if (Primitive_object.notequal(actual$1, expectedError)) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedJson,
+        actual: Message$ReventlessCore.encode(actual$1, Source.errorSchema),
+        actualEvents: actualEvents
+      });
+    } else {
+      return Outcome$ReventlessGwt.pass;
+    }
+  };
+  let thenTargetError = async (targetEvents, expectedError) => {
+    let actualDict = await targetEvents;
+    let actualEvents = encDict(actualDict);
+    let expectedJson = Message$ReventlessCore.encode(expectedError, Target.errorSchema);
+    let actual = targetErrors.contents[0];
+    if (actual === undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedJson,
+        actual: undefined,
+        actualEvents: actualEvents
+      });
+    }
+    let actual$1 = Primitive_option.valFromOption(actual);
+    if (Primitive_object.notequal(actual$1, expectedError)) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedJson,
+        actual: Message$ReventlessCore.encode(actual$1, Target.errorSchema),
+        actualEvents: actualEvents
+      });
+    } else {
+      return Outcome$ReventlessGwt.pass;
+    }
+  };
+  let thenTargetEventsWithError = async (targetEvents, expectedTargetEvents, expectedError) => {
+    let actualDict = await targetEvents;
+    let actualEvents = encDict(actualDict);
+    let expectedErrorJson = Message$ReventlessCore.encode(expectedError, Target.errorSchema);
+    let actual = targetErrors.contents[0];
+    if (actual === undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedErrorJson,
+        actual: undefined,
+        actualEvents: actualEvents
+      });
+    }
+    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, Target.errorSchema),
+        actualEvents: actualEvents
+      });
+    }
+    let expectedDict = Object.fromEntries(expectedTargetEvents);
+    if (dictPairsEq(actualDict, expectedDict)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: encExpected(expectedTargetEvents),
+        actual: actualEvents
+      });
+    }
+  };
+  return {
+    Source: Source,
+    Target: Target,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    givenSourceEvents: givenSourceEvents,
+    andTargetEvents: andTargetEvents,
+    whenSourceCmd: whenSourceCmd,
+    thenTargetEvents: thenTargetEvents,
+    thenTargetEvent: thenTargetEvent,
+    thenNoTargetEvent: thenNoTargetEvent,
+    thenSourceError: thenSourceError,
+    thenTargetError: thenTargetError,
+    thenTargetEventsWithError: thenTargetEventsWithError
+  };
+}
+
+export {
+  FromBehavior,
+  FromStateChangeSlice,
+  Make,
+}
+/* S Not a pure module */

package/src/MismatchRender.res

@@ -0,0 +1,72 @@
+// Single source for rendering an `Outcome.mismatch`'s expected/actual/extras
+// into RenderRescript strings. The Human and TAP formatters previously each held
+// a full 10-arm switch over the mismatch that computed *identical* rendered
+// values (`RenderRescript.render*`, the `Error()`/`Ok()` wrapping, the Todo
+// `(id, value)` pairs) and differed only in framing — aligned `label: value`
+// lines vs YAML `key: "escaped"` lines. This normalizes the value-rendering once;
+// each formatter interprets the `field` list with its own framing.
+//
+// NOT used by JUnit (renders via the older JSON-based `Outcome.format`) nor
+// FormatterJson/VsCode (they consume the raw JSON values to build a structured
+// `{type, payload, rendered}` + `fieldDiff` payload).
+
+// One rendered piece of a mismatch. The constructor carries the *already
+// rendered* string (unescaped — Human uses it raw, TAP yaml-escapes it), except
+// the structural markers `ExpectedNoEvents` (Human prints a literal line; TAP
+// omits it) and `Stack` (Human appends it raw; TAP labels it as a yaml field).
+type field =
+  | Expected(string)
+  | Actual(string)
+  | Key(string)
+  | ExpectedNoEvents
+  | Error(string)
+  | Stack(string)
+
+type normalized = {
+  kind: string,
+  fields: array<field>,
+}
+
+let render = RenderRescript.render
+let renderMany = RenderRescript.renderMany
+let renderOption = RenderRescript.renderOption
+
+let normalize = (m: Outcome.mismatch): normalized => {
+  let fields = switch m {
+  | EventsMismatch({expected, actual}) => [Expected(renderMany(expected)), Actual(renderMany(actual))]
+  | ErrorMismatch({expected, actual, actualEvents}) => [
+      Expected(`Error(${render(expected)})`),
+      Actual(
+        switch actual {
+        | Some(v) => `Error(${render(v)})`
+        | None => `Ok(${renderMany(actualEvents)})`
+        },
+      ),
+    ]
+  | StateMismatch({key, expected, actual}) => [
+      Key(key),
+      Expected(renderOption(expected)),
+      Actual(renderOption(actual)),
+    ]
+  | NoEventExpected({actual}) => [ExpectedNoEvents, Actual(renderMany(actual))]
+  | TodoMismatch({expected, actual}) =>
+    let fmt = (arr: array<(string, JSON.t)>) =>
+      "[" ++ arr->Array.map(((id, v)) => `(${id}, ${render(v)})`)->Array.join(", ") ++ "]"
+    [Expected(fmt(expected)), Actual(fmt(actual))]
+  | AppendConditionMismatch({expected, actual}) => [
+      Expected(render(expected)),
+      Actual(render(actual)),
+    ]
+  | TranslateError({expected, actual}) => [
+      Expected(expected),
+      Actual(actual->Option.getOr("(none)")),
+    ]
+  | QueryRowsMismatch({expected, actual}) => [Expected(renderMany(expected)), Actual(renderMany(actual))]
+  | PublishedActionsMismatch({expected, actual}) => [
+      Expected(renderMany(expected)),
+      Actual(renderMany(actual)),
+    ]
+  | Throw({error, stack}) => [Error(error), Stack(stack)]
+  }
+  {kind: Outcome.kindName(m), fields}
+}

package/src/MismatchRender.res.mjs

@@ -0,0 +1,127 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+function normalize(m) {
+  let fields;
+  switch (m.TAG) {
+    case "ErrorMismatch" :
+      let actual = m.actual;
+      fields = [
+        {
+          TAG: "Expected",
+          _0: `Error(` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `)`
+        },
+        {
+          TAG: "Actual",
+          _0: actual !== undefined ? `Error(` + RenderRescript$ReventlessGwt.render(undefined, actual) + `)` : `Ok(` + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + `)`
+        }
+      ];
+      break;
+    case "StateMismatch" :
+      fields = [
+        {
+          TAG: "Key",
+          _0: m.key
+        },
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.renderOption(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderOption(m.actual)
+        }
+      ];
+      break;
+    case "NoEventExpected" :
+      fields = [
+        "ExpectedNoEvents",
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.actual)
+        }
+      ];
+      break;
+    case "TodoMismatch" :
+      let fmt = arr => "[" + arr.map(param => `(` + param[0] + `, ` + RenderRescript$ReventlessGwt.render(undefined, param[1]) + `)`).join(", ") + "]";
+      fields = [
+        {
+          TAG: "Expected",
+          _0: fmt(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: fmt(m.actual)
+        }
+      ];
+      break;
+    case "AppendConditionMismatch" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.render(undefined, m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.render(undefined, m.actual)
+        }
+      ];
+      break;
+    case "TranslateError" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: m.expected
+        },
+        {
+          TAG: "Actual",
+          _0: Stdlib_Option.getOr(m.actual, "(none)")
+        }
+      ];
+      break;
+    case "Throw" :
+      fields = [
+        {
+          TAG: "Error",
+          _0: m.error
+        },
+        {
+          TAG: "Stack",
+          _0: m.stack
+        }
+      ];
+      break;
+    default:
+      fields = [
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.actual)
+        }
+      ];
+  }
+  return {
+    kind: Outcome$ReventlessGwt.kindName(m),
+    fields: fields
+  };
+}
+
+let render = RenderRescript$ReventlessGwt.render;
+
+let renderMany = RenderRescript$ReventlessGwt.renderMany;
+
+let renderOption = RenderRescript$ReventlessGwt.renderOption;
+
+export {
+  render,
+  renderMany,
+  renderOption,
+  normalize,
+}
+/* No side effect */