@reventlessdev/reventless-gwt 1.0.0-alpha.74

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/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
+    }
+}