@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/MultiSourceProjection_GWT.res

@@ -0,0 +1,316 @@
+open ReventlessCore
+
+module type T = {
+  type sourceEvent
+  type targetState
+
+  let describe: (string, unit => unit) => unit
+  let describeWithId: (string, string, unit => unit) => unit
+  let test: (string, ~timeout: int=?, unit => promise<Outcome.outcome>) => unit
+
+  type store = dict<array<targetState>>
+  type storeThunk = unit => promise<store>
+
+  let givenEvents: array<sourceEvent> => promise<store>
+  let givenEventsWithTime: array<(string, sourceEvent)> => promise<store>
+  let whenEvent: (promise<store>, sourceEvent) => storeThunk
+  let whenEvents: (promise<store>, array<sourceEvent>) => storeThunk
+  let whenEventWithTime: (promise<store>, string, sourceEvent) => storeThunk
+  let whenEventsWithTime: (promise<store>, array<(string, sourceEvent)>) => storeThunk
+  let thenStates: (storeThunk, array<targetState>) => promise<Outcome.outcome>
+  let thenStatesWithId: (storeThunk, string, array<targetState>) => promise<Outcome.outcome>
+  let thenAllStates: (storeThunk, store) => promise<Outcome.outcome>
+  let thenState: (storeThunk, targetState) => promise<Outcome.outcome>
+  let thenStateWithId: (storeThunk, string, targetState) => promise<Outcome.outcome>
+  let thenNoState: storeThunk => promise<Outcome.outcome>
+  let thenThrow: storeThunk => promise<Outcome.outcome>
+  let thenFail: storeThunk => promise<Outcome.outcome>
+}
+
+let handleActions = Projection.handleActions // create alias to avoid shadowing of same named modules
+
+module Make = (Projection: Reventless.Projection.Mapping): (
+  T with type sourceEvent := Projection.sourceEvent and type targetState := Projection.targetState
+) => {
+  S.enableJson()
+
+  let testId = ref(TestFixtures.id)
+  let meta = ref(TestFixtures.meta)
+
+  let describe = JestBind.describe
+  let describeWithId = (description, id, fn) => {
+    testId := id
+    JestBind.describe(description, fn)
+  }
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=Projection.sourceName, name, ~timeout?, body)
+
+  type store = dict<array<Projection.targetState>>
+  type storeThunk = unit => promise<store>
+
+  let getSubId = state => Projection.subIdConfig->Option.map(({getSubId}) => state->getSubId)
+  let hasSubId = (state, subId) => state->getSubId->Option.getOrThrow == subId
+  let states = (store, id) => store->Dict.get(id)->Option.getOr([])
+  let setStates = (store, id, states) => store->Dict.set(id, states)
+  let updateState = (store, id, subId, newState) =>
+    store->states(id)->Array.map(state => state->hasSubId(subId) ? newState : state)
+  let addState = (store, id, newState) => {
+    let (updatedStates, newStates) = switch newState->getSubId {
+    | Some(subId) =>
+      store->states(id)->Array.some(state => state->hasSubId(subId))
+        ? (store->updateState(id, subId, newState), [])
+        : (store->states(id), [newState])
+    | None => (store->states(id), [newState])
+    }
+    store->Dict.set(id, Array.concat(updatedStates, newStates))
+  }
+  let deleteStates = (store, id) => store->Dict.set(id, [])
+  let deleteSubState = (store, id, subId, getSubId) =>
+    store->Dict.set(
+      id,
+      store
+      ->Dict.get(id)
+      ->Option.map(states => states->Array.filter(state => state->getSubId != subId))
+      ->Option.getOr([]),
+    )
+
+  let load = (store, id) => store->states(id)->Ok->Promise.resolve
+  let save = (store, id, state, saveMode: QueryDb.saveMode, _ttl) =>
+    switch (store->states(id), saveMode) {
+    | (_, Any)
+    | ([], Init)
+    | ([_], Overwrite) =>
+      store->setStates(id, [state])
+      Ok()->Promise.resolve
+    | _ => Error(ReventlessInfra.QueryDb.StaleState)->Promise.resolve
+    }
+  let saveBatch = (store, batch) => {
+    batch->Array.forEach(((id, state, _ttl)) => store->addState(id, state))
+    Ok()->Promise.resolve
+  }
+  let delete = (store, id, subId) =>
+    switch (subId, Projection.subIdConfig) {
+    | (None, _) =>
+      store->deleteStates(id)
+      Ok()->Promise.resolve
+    | (Some((_, subId)), Some({Reventless.ReadModel.getSubId: getSubId})) =>
+      store->deleteSubState(id, subId, getSubId)
+      Ok()->Promise.resolve
+    | _ => Ok()->Promise.resolve
+    }
+  let deleteBatch = (store, ids) => {
+    ids->Array.forEach(((id, subId)) =>
+      switch (subId, Projection.subIdConfig) {
+      | (None, _) => store->deleteStates(id)
+      | (Some((_, subId)), Some({Reventless.ReadModel.getSubId: getSubId})) =>
+        store->deleteSubState(id, subId, getSubId)
+      | _ => ()
+      }
+    )
+    Ok()->Promise.resolve
+  }
+
+  let handleActions = (actions, operations) =>
+    actions->handleActions(operations, Projection.subIdConfig)
+
+  let sortStore = store =>
+    switch Projection.subIdConfig {
+    | None => store
+    | Some(_) =>
+      Dict.mapValues(store, states =>
+        states->Array.toSorted((state1, state2) =>
+          String.compare(state1->getSubId->Option.getUnsafe, state2->getSubId->Option.getUnsafe)
+        )
+      )
+    }
+
+  let update = async (store, events') => {
+    await events'
+    ->Array.map(event' => event'->Projection.project)
+    ->handleActions({
+      load: load(store, ...),
+      loadStream: id => store->states(id)->Stream.fromIterable,
+      save: save(store, ...),
+      saveBatch: saveBatch(store, ...),
+      count: async (_, _, _) => Ok(0),
+      delete: delete(store, ...),
+      deleteBatch: deleteBatch(store, ...),
+    })
+
+    store->sortStore
+  }
+
+  let givenEvents = events =>
+    Dict.make()->update(
+      events->Array.map(event => {Message.id: testId.contents, meta: meta.contents, event}),
+    )
+
+  let givenEventsWithTime = events =>
+    Dict.make()->update(
+      events->Array.map(((time, event)) => {
+        Message.id: testId.contents,
+        meta: {...meta.contents, time},
+        event,
+      }),
+    )
+
+  let whenEvent = (store, event): storeThunk =>
+    () =>
+      (
+        async () =>
+          await (await store)->update([{Message.id: testId.contents, meta: meta.contents, event}])
+      )()
+  let whenEvents = (store, events): storeThunk =>
+    () =>
+      (
+        async () =>
+          await (await store)->update(
+            events->Array.map(event => {Message.id: testId.contents, meta: meta.contents, event}),
+          )
+      )()
+  let whenEventWithTime = (store, time, event): storeThunk =>
+    () =>
+      (
+        async () =>
+          await (await store)->update([
+            {Message.id: testId.contents, meta: {...meta.contents, time}, event},
+          ])
+      )()
+  let whenEventsWithTime = (store, events): storeThunk =>
+    () =>
+      (
+        async () =>
+          await (await store)->update(
+            events->Array.map(((time, event)) => {
+              Message.id: testId.contents,
+              meta: {...meta.contents, time},
+              event,
+            }),
+          )
+      )()
+
+  let encState = (s: Projection.targetState) => s->Message.encode(Projection.targetStateSchema)
+  let encStates = (arr: array<Projection.targetState>) => arr->Array.map(encState)
+
+  // State equality via encoded JSON — handles ReScript structural comparison
+  // nuances when states contain types whose `==` is not meaningful.
+  let stateEq = (a: Projection.targetState, b: Projection.targetState) =>
+    JSON.stringify(encState(a)) == JSON.stringify(encState(b))
+  let statesEq = (a, b) =>
+    Array.length(a) == Array.length(b) &&
+      Array.zip(a, b)->Array.every(((x, y)) => stateEq(x, y))
+  let storeEq = (a: store, b: store) => {
+    let ka = a->Dict.keysToArray->Array.toSorted(String.compare)
+    let kb = b->Dict.keysToArray->Array.toSorted(String.compare)
+    ka == kb &&
+      ka->Array.every(key =>
+        statesEq(a->Dict.get(key)->Option.getOr([]), b->Dict.get(key)->Option.getOr([]))
+      )
+  }
+
+  let encStore = (s: store) => {
+    let obj = Dict.make()
+    s
+    ->Dict.toArray
+    ->Array.forEach(((k, v)) => obj->Dict.set(k, JSON.Encode.array(v->encStates)))
+    JSON.Encode.object(obj)
+  }
+
+  let thenStates = async (thunk, expectedStates) => {
+    let store = await thunk()
+    let keys = store->Dict.keysToArray
+    let actualId = keys->Array.get(0)
+    let actualStates = store->Dict.valuesToArray->Array.get(0)->Option.getOr([])
+    if (
+      keys->Array.length == 1 &&
+        actualId == Some(testId.contents) &&
+        statesEq(actualStates, expectedStates)
+    ) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: testId.contents,
+          expected: Some(JSON.Encode.array(expectedStates->encStates)),
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenStatesWithId = async (thunk, id, expectedStates) => {
+    let store = await thunk()
+    let keys = store->Dict.keysToArray
+    let actualId = keys->Array.get(0)
+    let actualStates = store->Dict.valuesToArray->Array.get(0)->Option.getOr([])
+    if keys->Array.length == 1 && actualId == Some(id) && statesEq(actualStates, expectedStates) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: id,
+          expected: Some(JSON.Encode.array(expectedStates->encStates)),
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenAllStates = async (thunk, expectedStore: store) => {
+    let store = await thunk()
+    if storeEq(store, expectedStore) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: "<all>",
+          expected: Some(encStore(expectedStore)),
+          actual: Some(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 =
+      store->Dict.valuesToArray->Array.reduce(0, (acc, states) => acc + states->Array.length)
+    if total == 0 {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        StateMismatch({
+          key: "<any>",
+          expected: None,
+          actual: Some(encStore(store)),
+        }),
+      )
+    }
+  }
+
+  let thenThrow = async thunk =>
+    switch await thunk() {
+    | _ =>
+      Outcome.fail(
+        Throw({
+          error: "Expected thunk to throw but it returned normally",
+          stack: "",
+        }),
+      )
+    | exception _ => Outcome.pass
+    }
+
+  let thenFail = async thunk =>
+    switch await thunk() {
+    | _ =>
+      Outcome.fail(
+        Throw({error: "Expected failure but thunk returned normally", stack: ""}),
+      )
+    | exception _ => Outcome.pass
+    }
+}

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 */