@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/MultiSourceProjection_GWT.res.mjs

@@ -0,0 +1,354 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+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 Stream from "effect/Stream";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.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";
+import * as Projection$ReventlessCore from "@reventlessdev/reventless-core/src/Projection.res.mjs";
+import * as TestFixtures$ReventlessGwt from "./TestFixtures.res.mjs";
+
+function Make(Projection) {
+  S.enableJson();
+  let testId = {
+    contents: TestFixtures$ReventlessGwt.id
+  };
+  let meta = {
+    contents: TestFixtures$ReventlessGwt.meta
+  };
+  let describeWithId = (description, id, fn) => {
+    testId.contents = id;
+    JestBind$ReventlessGwt.describe(description, fn);
+  };
+  let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(Projection.sourceName, name, timeout, body);
+  let getSubId = state => Stdlib_Option.map(Projection.subIdConfig, param => param.getSubId(state));
+  let hasSubId = (state, subId) => Stdlib_Option.getOrThrow(getSubId(state), undefined) === subId;
+  let states = (store, id) => Stdlib_Option.getOr(store[id], []);
+  let setStates = (store, id, states) => {
+    store[id] = states;
+  };
+  let updateState = (store, id, subId, newState) => states(store, id).map(state => {
+    if (hasSubId(state, subId)) {
+      return newState;
+    } else {
+      return state;
+    }
+  });
+  let deleteStates = (store, id) => {
+    store[id] = [];
+  };
+  let deleteSubState = (store, id, subId, getSubId) => {
+    store[id] = Stdlib_Option.getOr(Stdlib_Option.map(store[id], states => states.filter(state => Primitive_object.notequal(getSubId(state), subId))), []);
+  };
+  let update = async (store, events$p) => {
+    let actions = events$p.map(event$p => Projection.project(event$p));
+    await Projection$ReventlessCore.handleActions(actions, {
+      load: extra => Promise.resolve({
+        TAG: "Ok",
+        _0: states(store, extra)
+      }),
+      loadStream: id => Stream.fromIterable(states(store, id)),
+      save: (extra, extra$1, extra$2, extra$3) => {
+        let match = states(store, extra);
+        let exit = 0;
+        switch (extra$2) {
+          case "Init" :
+          case "Overwrite" :
+            exit = 2;
+            break;
+          case "Any" :
+            break;
+        }
+        if (exit === 2) {
+          let len = match.length;
+          if (len !== 1) {
+            if (len !== 0) {
+              return Promise.resolve({
+                TAG: "Error",
+                _0: "StaleState"
+              });
+            }
+            if (extra$2 !== "Init") {
+              return Promise.resolve({
+                TAG: "Error",
+                _0: "StaleState"
+              });
+            }
+          } else if (extra$2 === "Init") {
+            return Promise.resolve({
+              TAG: "Error",
+              _0: "StaleState"
+            });
+          }
+        }
+        setStates(store, extra, [extra$1]);
+        return Promise.resolve({
+          TAG: "Ok",
+          _0: undefined
+        });
+      },
+      saveBatch: extra => {
+        extra.forEach(param => {
+          let id = param[0];
+          let newState = param[1];
+          let subId = getSubId(newState);
+          let match = subId !== undefined ? (
+              states(store, id).some(state => hasSubId(state, subId)) ? [
+                  updateState(store, id, subId, newState),
+                  []
+                ] : [
+                  states(store, id),
+                  [newState]
+                ]
+            ) : [
+              states(store, id),
+              [newState]
+            ];
+          store[id] = match[0].concat(match[1]);
+        });
+        return Promise.resolve({
+          TAG: "Ok",
+          _0: undefined
+        });
+      },
+      count: async (param, param$1, param$2) => ({
+        TAG: "Ok",
+        _0: 0
+      }),
+      delete: (extra, extra$1) => {
+        let match = Projection.subIdConfig;
+        if (extra$1 !== undefined) {
+          if (match !== undefined) {
+            deleteSubState(store, extra, extra$1[1], match.getSubId);
+            return Promise.resolve({
+              TAG: "Ok",
+              _0: undefined
+            });
+          } else {
+            return Promise.resolve({
+              TAG: "Ok",
+              _0: undefined
+            });
+          }
+        } else {
+          deleteStates(store, extra);
+          return Promise.resolve({
+            TAG: "Ok",
+            _0: undefined
+          });
+        }
+      },
+      deleteBatch: extra => {
+        extra.forEach(param => {
+          let subId = param[1];
+          let id = param[0];
+          let match = Projection.subIdConfig;
+          if (subId !== undefined) {
+            if (match !== undefined) {
+              return deleteSubState(store, id, subId[1], match.getSubId);
+            } else {
+              return;
+            }
+          } else {
+            return deleteStates(store, id);
+          }
+        });
+        return Promise.resolve({
+          TAG: "Ok",
+          _0: undefined
+        });
+      }
+    }, Projection.subIdConfig);
+    if (Projection.subIdConfig !== undefined) {
+      return Stdlib_Dict.mapValues(store, states => states.toSorted((state1, state2) => Primitive_string.compare(getSubId(state1), getSubId(state2))));
+    } else {
+      return store;
+    }
+  };
+  let givenEvents = events => update({}, events.map(event => ({
+    id: testId.contents,
+    meta: meta.contents,
+    event: event
+  })));
+  let givenEventsWithTime = events => update({}, events.map(param => {
+    let newrecord = {...meta.contents};
+    return {
+      id: testId.contents,
+      meta: (newrecord.time = param[0], newrecord),
+      event: param[1]
+    };
+  }));
+  let whenEvent = (store, event) => (() => (async () => await update(await store, [{
+      id: testId.contents,
+      meta: meta.contents,
+      event: event
+    }]))());
+  let whenEvents = (store, events) => (() => (async () => await update(await store, events.map(event => ({
+    id: testId.contents,
+    meta: meta.contents,
+    event: event
+  }))))());
+  let whenEventWithTime = (store, time, event) => (() => (async () => {
+    let newrecord = {...meta.contents};
+    return await update(await store, [{
+        id: testId.contents,
+        meta: (newrecord.time = time, newrecord),
+        event: event
+      }]);
+  })());
+  let whenEventsWithTime = (store, events) => (() => (async () => await update(await store, events.map(param => {
+    let newrecord = {...meta.contents};
+    return {
+      id: testId.contents,
+      meta: (newrecord.time = param[0], newrecord),
+      event: param[1]
+    };
+  })))());
+  let encState = s => Message$ReventlessCore.encode(s, Projection.targetStateSchema);
+  let statesEq = (a, b) => {
+    if (a.length === b.length) {
+      return Stdlib_Array.zip(a, b).every(param => {
+        let a = param[0];
+        let b = param[1];
+        return JSON.stringify(Message$ReventlessCore.encode(a, Projection.targetStateSchema)) === JSON.stringify(Message$ReventlessCore.encode(b, Projection.targetStateSchema));
+      });
+    } else {
+      return false;
+    }
+  };
+  let storeEq = (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(key => statesEq(Stdlib_Option.getOr(a[key], []), Stdlib_Option.getOr(b[key], [])));
+    } else {
+      return false;
+    }
+  };
+  let encStore = s => {
+    let obj = {};
+    Object.entries(s).forEach(param => {
+      obj[param[0]] = param[1].map(encState);
+    });
+    return obj;
+  };
+  let thenStates = async (thunk, expectedStates) => {
+    let store = await thunk();
+    let keys = Object.keys(store);
+    let actualId = keys[0];
+    let actualStates = Stdlib_Option.getOr(Object.values(store)[0], []);
+    if (keys.length === 1 && Primitive_object.equal(actualId, testId.contents) && statesEq(actualStates, expectedStates)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: testId.contents,
+        expected: expectedStates.map(encState),
+        actual: encStore(store)
+      });
+    }
+  };
+  let thenStatesWithId = async (thunk, id, expectedStates) => {
+    let store = await thunk();
+    let keys = Object.keys(store);
+    let actualId = keys[0];
+    let actualStates = Stdlib_Option.getOr(Object.values(store)[0], []);
+    if (keys.length === 1 && Primitive_object.equal(actualId, id) && statesEq(actualStates, expectedStates)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: id,
+        expected: expectedStates.map(encState),
+        actual: encStore(store)
+      });
+    }
+  };
+  let thenAllStates = async (thunk, expectedStore) => {
+    let store = await thunk();
+    if (storeEq(store, expectedStore)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: "<all>",
+        expected: encStore(expectedStore),
+        actual: encStore(store)
+      });
+    }
+  };
+  let thenState = (thunk, expectedState) => thenStates(thunk, [expectedState]);
+  let thenStateWithId = (thunk, id, expectedState) => thenStatesWithId(thunk, id, [expectedState]);
+  let thenNoState = async thunk => {
+    let store = await thunk();
+    let total = Stdlib_Array.reduce(Object.values(store), 0, (acc, states) => acc + states.length | 0);
+    if (total === 0) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: "<any>",
+        expected: undefined,
+        actual: encStore(store)
+      });
+    }
+  };
+  let thenThrow = async thunk => {
+    let val;
+    try {
+      val = await thunk();
+    } catch (exn) {
+      return Outcome$ReventlessGwt.pass;
+    }
+    return Outcome$ReventlessGwt.fail({
+      TAG: "Throw",
+      error: "Expected thunk to throw but it returned normally",
+      stack: ""
+    });
+  };
+  let thenFail = async thunk => {
+    let val;
+    try {
+      val = await thunk();
+    } catch (exn) {
+      return Outcome$ReventlessGwt.pass;
+    }
+    return Outcome$ReventlessGwt.fail({
+      TAG: "Throw",
+      error: "Expected failure but thunk returned normally",
+      stack: ""
+    });
+  };
+  return {
+    describe: JestBind$ReventlessGwt.describe,
+    describeWithId: describeWithId,
+    test: test,
+    givenEvents: givenEvents,
+    givenEventsWithTime: givenEventsWithTime,
+    whenEvent: whenEvent,
+    whenEvents: whenEvents,
+    whenEventWithTime: whenEventWithTime,
+    whenEventsWithTime: whenEventsWithTime,
+    thenStates: thenStates,
+    thenStatesWithId: thenStatesWithId,
+    thenAllStates: thenAllStates,
+    thenState: thenState,
+    thenStateWithId: thenStateWithId,
+    thenNoState: thenNoState,
+    thenThrow: thenThrow,
+    thenFail: thenFail
+  };
+}
+
+let handleActions = Projection$ReventlessCore.handleActions;
+
+export {
+  handleActions,
+  Make,
+}
+/* S Not a pure module */

package/src/OutboundTranslation_GWT.res

@@ -0,0 +1,238 @@
+open ReventlessCore
+
+// Minimal inline spec for OutboundTranslationSlice. `translate` is async and
+// supplied at test-time via `whenTranslateMocked` so the external service is
+// never hit. The spec's own `translate` is not part of the GWT — it's
+// exercised only through the runtime tests.
+module type SliceSpec = {
+  let name: string
+
+  @schema
+  type consumedEvent
+
+  @schema
+  type outboundItem
+
+  @schema
+  type inboundCommand
+
+  let collect: consumedEvent => array<(string, outboundItem)>
+}
+
+// Status enum reflecting how the slice's runtime labels a TODO after a
+// translate call. A successful translate (Ok) marks the item #Completed;
+// a failure (Error) leaves it #Pending for retry up to `maxRetries`.
+type todoStatus = [#Completed | #Pending]
+
+module type T = {
+  module Spec: SliceSpec
+
+  let describe: (string, unit => unit) => unit
+  let test: (string, ~timeout: int=?, unit => promise<Outcome.outcome>) => unit
+  // Sync companion for the `collect` leg, whose combinators return
+  // `Outcome.outcome` directly (no Promise). The async `test` works for
+  // collect bodies too, but only after a manual `Promise.resolve` wrapper.
+  let testSync: (string, unit => Outcome.outcome) => unit
+
+  type translateResult =
+    result<option<(string, Spec.inboundCommand)>, string>
+
+  // The state the pipeline carries after a translate attempt. `retries` counts
+  // the number of failed re-attempts (0 for a single `whenTranslateMocked`).
+  type attempt = {
+    id: string,
+    item: Spec.outboundItem,
+    result: translateResult,
+    retries: int,
+  }
+
+  // Unit — collect
+  let givenEvent: Spec.consumedEvent => Spec.consumedEvent
+  let whenCollect: Spec.consumedEvent => array<(string, Spec.outboundItem)>
+  let thenTodos: (
+    array<(string, Spec.outboundItem)>,
+    array<(string, Spec.outboundItem)>,
+  ) => Outcome.outcome
+
+  // Unit — translate
+  let givenTodo: (string, Spec.outboundItem) => (string, Spec.outboundItem)
+  let whenTranslateMocked: (
+    (string, Spec.outboundItem),
+    (string, Spec.outboundItem) => promise<translateResult>,
+  ) => promise<attempt>
+  // Re-invokes the mock on each `Error` up to `maxRetries` times (or until it
+  // returns `Ok`), tracking how many retries were spent — the real counter
+  // `thenRetryRecorded` asserts against.
+  let whenTranslateRetrying: (
+    (string, Spec.outboundItem),
+    ~maxRetries: int,
+    (string, Spec.outboundItem) => promise<translateResult>,
+  ) => promise<attempt>
+  let thenCommand: (
+    promise<attempt>,
+    string,
+    Spec.inboundCommand,
+  ) => promise<Outcome.outcome>
+  let thenNoCommand: promise<attempt> => promise<Outcome.outcome>
+  let thenRetryRecorded: (promise<attempt>, int) => promise<Outcome.outcome>
+  let thenTodoStatus: (promise<attempt>, string, todoStatus) => promise<Outcome.outcome>
+}
+
+module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
+  module Spec = Spec
+
+  S.enableJson()
+
+  let describe = JestBind.describe
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=Spec.name, name, ~timeout?, body)
+  let testSync = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+
+  type translateResult =
+    result<option<(string, Spec.inboundCommand)>, string>
+
+  type attempt = {
+    id: string,
+    item: Spec.outboundItem,
+    result: translateResult,
+    retries: int,
+  }
+
+  let encItem = (i: Spec.outboundItem) => i->Message.encode(Spec.outboundItemSchema)
+  let encItems = (arr: array<(string, Spec.outboundItem)>) =>
+    arr->Array.map(((id, i)) => (id, encItem(i)))
+  let encInbound = (c: Spec.inboundCommand) =>
+    c->Message.encode(Spec.inboundCommandSchema)
+
+  // Unit: collect
+  let givenEvent = e => e
+  let whenCollect = e => e->Spec.collect
+  let thenTodos = (actual, expected) =>
+    if actual == expected {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        TodoMismatch({
+          expected: encItems(expected),
+          actual: encItems(actual),
+        }),
+      )
+    }
+
+  // Unit: translate
+  let givenTodo = (id, item) => (id, item)
+  let whenTranslateMocked = async ((id, item), mock) => {
+    let result = await mock(id, item)
+    {id, item, result, retries: 0}
+  }
+
+  let whenTranslateRetrying = async ((id, item), ~maxRetries, mock) => {
+    let result = ref(await mock(id, item))
+    let retries = ref(0)
+    let failed = () =>
+      switch result.contents {
+      | Error(_) => true
+      | Ok(_) => false
+      }
+    while failed() && retries.contents < maxRetries {
+      retries := retries.contents + 1
+      result := await mock(id, item)
+    }
+    {id, item, result: result.contents, retries: retries.contents}
+  }
+
+  let commandPairJson = (id, cmd) => {
+    let d = Dict.make()
+    d->Dict.set("id", JSON.Encode.string(id))
+    d->Dict.set("command", encInbound(cmd))
+    JSON.Encode.object(d)
+  }
+
+  let thenCommand = async (pending, expectedId, expectedCmd) => {
+    let {result, _} = await pending
+    switch result {
+    | Ok(Some((id, cmd))) if id == expectedId && cmd == expectedCmd => Outcome.pass
+    | Ok(Some((id, cmd))) =>
+      Outcome.fail(
+        EventsMismatch({
+          expected: [commandPairJson(expectedId, expectedCmd)],
+          actual: [commandPairJson(id, cmd)],
+        }),
+      )
+    | Ok(None) =>
+      Outcome.fail(
+        EventsMismatch({
+          expected: [commandPairJson(expectedId, expectedCmd)],
+          actual: [],
+        }),
+      )
+    | Error(msg) =>
+      Outcome.fail(
+        TranslateError({expected: "(command)", actual: Some(msg)}),
+      )
+    }
+  }
+
+  let thenNoCommand = async pending => {
+    let {result, _} = await pending
+    switch result {
+    | Ok(None) => Outcome.pass
+    | Ok(Some((id, cmd))) =>
+      Outcome.fail(NoEventExpected({actual: [commandPairJson(id, cmd)]}))
+    | Error(msg) =>
+      Outcome.fail(
+        TranslateError({expected: "(no command)", actual: Some(msg)}),
+      )
+    }
+  }
+
+  // `thenRetryRecorded(n)` — asserts the harness spent exactly `n` retries.
+  // Pair with `whenTranslateRetrying(~maxRetries)`, which re-invokes the mock on
+  // each failure and tracks the count; a single `whenTranslateMocked` records 0.
+  let thenRetryRecorded = async (pending, expectedRetries) => {
+    let {retries, _} = await pending
+    if retries == expectedRetries {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: "retries",
+          expected: Some(JSON.Encode.int(expectedRetries)),
+          actual: Some(JSON.Encode.int(retries)),
+        }),
+      )
+    }
+  }
+
+  let statusToString = (s: todoStatus) =>
+    switch s {
+    | #Completed => "#Completed"
+    | #Pending => "#Pending"
+    }
+
+  let thenTodoStatus = async (pending, expectedId, expectedStatus) => {
+    let {id, result, _} = await pending
+    let actualStatus: todoStatus =
+      switch result {
+      | Ok(_) => #Completed
+      | Error(_) => #Pending
+      }
+    if id == expectedId && actualStatus == expectedStatus {
+      Outcome.pass
+    } else {
+      let encOne = (rid, rstatus) => {
+        let d = Dict.make()
+        d->Dict.set("id", JSON.Encode.string(rid))
+        d->Dict.set("status", JSON.Encode.string(statusToString(rstatus)))
+        JSON.Encode.object(d)
+      }
+      Outcome.fail(
+        StateMismatch({
+          key: id,
+          expected: Some(encOne(expectedId, expectedStatus)),
+          actual: Some(encOne(id, actualStatus)),
+        }),
+      )
+    }
+  }
+}