@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/Projection.res.mjs

@@ -0,0 +1,712 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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 Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
+import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
+import * as Message$ReventlessCore from "./Message.res.mjs";
+import * as QueryDb$ReventlessCore from "./components/QueryDb/QueryDb.res.mjs";
+import * as QueryDb$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/QueryDb.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function MakeGenericSource(Mapping) {
+  let decode$p = json => Message$ReventlessCore.decodeEvent$p(json, S.string, Mapping.sourceEventSchema);
+  return {
+    name: Mapping.sourceName,
+    decode$p: decode$p
+  };
+}
+
+let Mapping = {
+  MakeGenericSource: MakeGenericSource
+};
+
+function logAction(str) {
+  log.debug("Projection", undefined, str);
+}
+
+function overlayDisplayName(state, stateSchema, spec) {
+  let json = S.reverseConvertToJsonOrThrow(state, stateSchema);
+  let stateDict = Stdlib_JSON.Decode.object(json);
+  if (stateDict === undefined) {
+    return state;
+  }
+  let label = DisplayName$Reventless.computeLabel(spec, stateDict);
+  stateDict["displayName"] = label;
+  return S.parseJsonOrThrow(stateDict, stateSchema);
+}
+
+function rewriteAction(action, stateSchema) {
+  let spec = DisplayName$Reventless.getSpec(stateSchema);
+  if (spec === undefined) {
+    return action;
+  }
+  let overlay = state => overlayDisplayName(state, stateSchema, spec);
+  if (typeof action !== "object") {
+    return action;
+  }
+  switch (action.TAG) {
+    case "Create" :
+      return {
+        TAG: "Create",
+        _0: action._0,
+        _1: overlayDisplayName(action._1, stateSchema, spec)
+      };
+    case "CreateMany" :
+      return {
+        TAG: "CreateMany",
+        _0: action._0.map(param => [
+          param[0],
+          overlayDisplayName(param[1], stateSchema, spec)
+        ])
+      };
+    case "Update" :
+      let fn = action._1;
+      return {
+        TAG: "Update",
+        _0: action._0,
+        _1: state => overlayDisplayName(fn(state), stateSchema, spec)
+      };
+    case "UpdateMany" :
+      let fn$1 = action._1;
+      return {
+        TAG: "UpdateMany",
+        _0: action._0,
+        _1: (id, s) => overlayDisplayName(fn$1(id, s), stateSchema, spec)
+      };
+    case "UpdateWithDefault" :
+      let fn$2 = action._2;
+      return {
+        TAG: "UpdateWithDefault",
+        _0: action._0,
+        _1: overlayDisplayName(action._1, stateSchema, spec),
+        _2: state => overlayDisplayName(fn$2(state), stateSchema, spec)
+      };
+    case "UpdateManyWithDefault" :
+      let fn$3 = action._2;
+      let defFn = action._1;
+      return {
+        TAG: "UpdateManyWithDefault",
+        _0: action._0,
+        _1: id => overlayDisplayName(defFn(id), stateSchema, spec),
+        _2: (id, s) => overlayDisplayName(fn$3(id, s), stateSchema, spec)
+      };
+    case "Set" :
+      return {
+        TAG: "Set",
+        _0: action._0,
+        _1: overlayDisplayName(action._1, stateSchema, spec)
+      };
+    case "SetMany" :
+      let fn$4 = action._1;
+      return {
+        TAG: "SetMany",
+        _0: action._0,
+        _1: id => overlayDisplayName(fn$4(id), stateSchema, spec)
+      };
+    case "CreateMultiState" :
+      return {
+        TAG: "CreateMultiState",
+        _0: action._0,
+        _1: action._1.map(overlay)
+      };
+    case "UpdateMultiState" :
+      let fn$5 = action._1;
+      return {
+        TAG: "UpdateMultiState",
+        _0: action._0,
+        _1: states => fn$5(states).map(overlay)
+      };
+    case "UpdateManyMultiStates" :
+      let fn$6 = action._1;
+      return {
+        TAG: "UpdateManyMultiStates",
+        _0: action._0,
+        _1: (id, states) => fn$6(id, states).map(overlay)
+      };
+    default:
+      return action;
+  }
+}
+
+async function applyChanges(action, id, beforeStates, afterStates, param, param$1) {
+  let getSubId = param$1.getSubId;
+  let subIdField = param$1.subIdField;
+  let beforeCount = beforeStates.length;
+  let beforeSubIds = Belt_SetString.fromArray(beforeStates.map(state => getSubId(state)));
+  let afterCount = afterStates.length;
+  let afterSubIds = Belt_SetString.fromArray(afterStates.map(state => getSubId(state)));
+  let addedSubIds = Belt_SetString.diff(afterSubIds, beforeSubIds);
+  let addedStates = afterStates.filter(state => Belt_SetString.has(addedSubIds, getSubId(state)));
+  let addedCount = addedStates.length;
+  let changedStates = Stdlib_Array.filterMap(beforeStates, before => {
+    let beforeSubId = getSubId(before);
+    return afterStates.find(after => {
+      if (getSubId(after) === beforeSubId) {
+        return Primitive_object.notequal(after, before);
+      } else {
+        return false;
+      }
+    });
+  });
+  let changedCount = changedStates.length;
+  let batchToSave = changedStates.concat(addedStates).map(state => [
+    id,
+    state,
+    undefined
+  ]);
+  let deletedSubIds = Belt_SetString.toArray(Belt_SetString.diff(beforeSubIds, afterSubIds));
+  let batchToDelete = deletedSubIds.map(subId => [
+    id,
+    [
+      subIdField,
+      subId
+    ]
+  ]);
+  let deletedCount = batchToDelete.length;
+  logAction(action + `(` + id + `): beforeStates:` + beforeCount.toString() + ` afterStates:` + afterCount.toString() + ` added:` + addedCount.toString() + ` changed:` + changedCount.toString() + ` deleted:` + deletedCount.toString());
+  await Promise.all([
+    param.deleteBatch(batchToDelete),
+    param.saveBatch(batchToSave)
+  ]);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+function stateToString(state) {
+  return Stdlib_Option.getOrThrow(JSON.stringify(state), undefined);
+}
+
+function statesToString(states) {
+  return states.map(stateToString).join(", ");
+}
+
+async function handleAction(action, operations, subIdConfig) {
+  let saveBatch = operations.saveBatch;
+  let save = operations.save;
+  let loadStream = operations.loadStream;
+  let loadAtMost = (n, id) => Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(Stream$1.take(loadStream(id), n)), states => ({
+    TAG: "Ok",
+    _0: states
+  })), e => Effect.succeed({
+    TAG: "Error",
+    _0: e
+  })));
+  let loadAll = id => Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(loadStream(id)), states => ({
+    TAG: "Ok",
+    _0: states
+  })), e => Effect.succeed({
+    TAG: "Error",
+    _0: e
+  })));
+  if (typeof action !== "object") {
+    logAction("Ignore");
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+  switch (action.TAG) {
+    case "Create" :
+      let state = action._1;
+      let id = action._0;
+      logAction(`Create(` + id + `, ` + stateToString(state) + `)`);
+      return await save(id, state, "Init", undefined);
+    case "CreateMany" :
+      let batch = action._0.map(param => [
+        param[0],
+        param[1],
+        undefined
+      ]);
+      let statesStr = batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ");
+      logAction(`CreateMany(` + statesStr + `)`);
+      return await saveBatch(batch);
+    case "Update" :
+      let id$1 = action._0;
+      let states = await loadAtMost(2, id$1);
+      if (states.TAG !== "Ok") {
+        return {
+          TAG: "Error",
+          _0: states._0
+        };
+      }
+      let states$1 = states._0;
+      let len = states$1.length;
+      if (len !== 1) {
+        if (len !== 0) {
+          logAction(`Update Error: Multiple oldStates for ` + id$1 + `)`);
+          return {
+            TAG: "Error",
+            _0: "StaleState"
+          };
+        } else {
+          logAction(`Update Error: No oldState for ` + id$1 + `)`);
+          return {
+            TAG: "Error",
+            _0: "StaleState"
+          };
+        }
+      }
+      let oldState = states$1[0];
+      let newState = action._1(oldState);
+      logAction(`Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
+      return await save(id$1, newState, "Overwrite", undefined);
+    case "UpdateWithDefault" :
+      let $$default = action._1;
+      let id$2 = action._0;
+      log.debug("Projection", undefined, `UpdateWithDefault(` + id$2 + `, loading ...`);
+      let states$2 = await loadAtMost(2, id$2);
+      if (states$2.TAG === "Ok") {
+        let states$3 = states$2._0;
+        let len$1 = states$3.length;
+        if (len$1 !== 1) {
+          if (len$1 !== 0) {
+            logAction(`UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
+            return {
+              TAG: "Error",
+              _0: "StaleState"
+            };
+          } else {
+            logAction(`UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
+            return await save(id$2, $$default, "Init", undefined);
+          }
+        }
+        let oldState$1 = states$3[0];
+        let newState$1 = action._2(oldState$1);
+        logAction(`UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
+        return await save(id$2, newState$1, "Overwrite", undefined);
+      }
+      let err = states$2._0;
+      logAction(`UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
+      return {
+        TAG: "Error",
+        _0: err
+      };
+    case "Set" :
+      let state$1 = action._1;
+      let id$3 = action._0;
+      logAction(`Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
+      return await save(id$3, state$1, "Any", undefined);
+    case "SetMany" :
+      let set = action._1;
+      let batch$1 = action._0.map(id => [
+        id,
+        set(id),
+        undefined
+      ]);
+      let statesStr$1 = batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ");
+      logAction(`SetMany(` + statesStr$1 + `)`);
+      return await saveBatch(batch$1);
+    case "Delete" :
+      let id$4 = action._0;
+      logAction(`Delete(` + id$4 + `)`);
+      return await operations.delete(id$4, undefined);
+    case "DeleteMany" :
+      let ids = action._0;
+      logAction(`DeleteMany(` + ids.join(", ") + `)`);
+      return await operations.deleteBatch(ids.map(id => [
+        id,
+        undefined
+      ]));
+    case "CreateMultiState" :
+      let states$4 = action._1;
+      let id$5 = action._0;
+      logAction(`CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
+      let len$2 = states$4.length;
+      if (len$2 !== 1) {
+        if (len$2 === 0) {
+          return {
+            TAG: "Ok",
+            _0: undefined
+          };
+        }
+        let batch$2 = states$4.map(state => [
+          id$5,
+          state,
+          undefined
+        ]);
+        return await saveBatch(batch$2);
+      }
+      let state$2 = states$4[0];
+      return await save(id$5, state$2, "Init", undefined);
+    case "UpdateMultiState" :
+      let id$6 = action._0;
+      let match = await loadAll(id$6);
+      if (match.TAG === "Ok") {
+        if (subIdConfig !== undefined) {
+          let states$5 = match._0;
+          let afterStates = action._1(states$5);
+          return await applyChanges("UpdateMultiState", id$6, states$5, afterStates, operations, subIdConfig);
+        }
+        logAction("UpdateMultiState Error: Missing SubIdConfig !");
+        return {
+          TAG: "Error",
+          _0: "MissingSubIdConfig"
+        };
+      }
+      if (subIdConfig !== undefined) {
+        let err$1 = match._0;
+        logAction(`UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
+        return {
+          TAG: "Error",
+          _0: err$1
+        };
+      }
+      logAction("UpdateMultiState Error: Missing SubIdConfig !");
+      return {
+        TAG: "Error",
+        _0: "MissingSubIdConfig"
+      };
+    default:
+      logAction("Error: Action not yet supported !");
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+  }
+}
+
+function actionsWithId(action) {
+  if (typeof action !== "object") {
+    return [];
+  }
+  switch (action.TAG) {
+    case "CreateMany" :
+      return action._0.map(param => {
+        let id = param[0];
+        return [
+          id,
+          {
+            TAG: "Create",
+            _0: id,
+            _1: param[1]
+          }
+        ];
+      });
+    case "SetMany" :
+      let set = action._1;
+      return action._0.map(id => [
+        id,
+        {
+          TAG: "Set",
+          _0: id,
+          _1: set(id)
+        }
+      ]);
+    case "DeleteMany" :
+      return action._0.map(id => [
+        id,
+        {
+          TAG: "Delete",
+          _0: id
+        }
+      ]);
+    case "UpdateMany" :
+    case "UpdateManyWithDefault" :
+    case "DeleteIf" :
+    case "DeleteManyIf" :
+      logAction("Error: Action not yet supported !");
+      return [];
+    case "UpdateManyMultiStates" :
+      let update = action._1;
+      return action._0.map(id => [
+        id,
+        {
+          TAG: "UpdateMultiState",
+          _0: id,
+          _1: states => update(id, states)
+        }
+      ]);
+    default:
+      return [[
+          action._0,
+          action
+        ]];
+  }
+}
+
+function groupActionsById(actions) {
+  let allActionsWithId = actions.map(actionsWithId).flat();
+  let ids = allActionsWithId.map(param => param[0]);
+  return Belt_SetString.toArray(Belt_SetString.fromArray(ids)).map(id => [
+    id,
+    Stdlib_Array.filterMap(allActionsWithId, param => {
+      if (param[0] === id) {
+        return param[1];
+      }
+    })
+  ]);
+}
+
+function optimizeActions(actions) {
+  return Stdlib_Array.reduce(actions, [], (optimizedActions, action) => {
+    let optimizedActionsCount = optimizedActions.length;
+    if (optimizedActionsCount === 0) {
+      return [action];
+    }
+    let lastAction = optimizedActions[optimizedActionsCount - 1 | 0];
+    let previousActions = optimizedActionsCount === 1 ? [] : optimizedActions.slice(0, optimizedActionsCount);
+    if (typeof lastAction === "object") {
+      switch (lastAction.TAG) {
+        case "Create" :
+          let state1 = lastAction._1;
+          let id1 = lastAction._0;
+          if (typeof action === "object") {
+            switch (action.TAG) {
+              case "Create" :
+                if (id1 === action._0) {
+                  log.warn("Projection", undefined, `optimizing 2 sequential Create for id=` + id1 + `, ignoring second: ` + Stdlib_Option.getOr(JSON.stringify(action._1), "?"));
+                  return previousActions.concat([{
+                      TAG: "Create",
+                      _0: id1,
+                      _1: state1
+                    }]);
+                }
+                break;
+              case "Update" :
+                if (id1 === action._0) {
+                  return previousActions.concat([{
+                      TAG: "Create",
+                      _0: id1,
+                      _1: action._1(state1)
+                    }]);
+                }
+                break;
+              case "UpdateWithDefault" :
+                if (id1 === action._0) {
+                  return previousActions.concat([{
+                      TAG: "Create",
+                      _0: id1,
+                      _1: action._2(state1)
+                    }]);
+                }
+                break;
+              case "Set" :
+                if (id1 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Set after Create for id=` + id1 + `, ignoring Create: ` + Stdlib_Option.getOr(JSON.stringify(state1), "?"));
+                  return previousActions.concat([{
+                      TAG: "Set",
+                      _0: id1,
+                      _1: action._1
+                    }]);
+                }
+                break;
+              case "Delete" :
+                if (id1 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Delete after Create for id=` + id1 + `, ignoring Create: ` + Stdlib_Option.getOr(JSON.stringify(state1), "?"));
+                  return previousActions.concat([{
+                      TAG: "Delete",
+                      _0: id1
+                    }]);
+                }
+                break;
+            }
+          }
+          break;
+        case "Update" :
+          let f = lastAction._1;
+          let id1$1 = lastAction._0;
+          if (typeof action === "object") {
+            switch (action.TAG) {
+              case "Update" :
+                if (id1$1 === action._0) {
+                  let g = action._1;
+                  return previousActions.concat([{
+                      TAG: "Update",
+                      _0: id1$1,
+                      _1: state => g(f(state))
+                    }]);
+                }
+                break;
+              case "UpdateWithDefault" :
+                if (id1$1 === action._0) {
+                  let g$1 = action._2;
+                  return previousActions.concat([{
+                      TAG: "UpdateWithDefault",
+                      _0: id1$1,
+                      _1: action._1,
+                      _2: state => g$1(f(state))
+                    }]);
+                }
+                break;
+              case "Set" :
+                if (id1$1 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Set after Update for id=` + id1$1 + `, ignoring the Update`);
+                  return previousActions.concat([{
+                      TAG: "Set",
+                      _0: id1$1,
+                      _1: action._1
+                    }]);
+                }
+                break;
+              case "Delete" :
+                if (id1$1 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Delete after Update for id=` + id1$1 + `, ignoring the Update`);
+                  return previousActions.concat([{
+                      TAG: "Delete",
+                      _0: id1$1
+                    }]);
+                }
+                break;
+            }
+          }
+          break;
+        case "UpdateWithDefault" :
+          let f$1 = lastAction._2;
+          let defaultState1 = lastAction._1;
+          let id1$2 = lastAction._0;
+          if (typeof action === "object") {
+            switch (action.TAG) {
+              case "Create" :
+                if (id1$2 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Create after UpdateWithDefault for id=` + id1$2 + `, ignoring the Create`);
+                  return previousActions.concat([{
+                      TAG: "UpdateWithDefault",
+                      _0: id1$2,
+                      _1: defaultState1,
+                      _2: f$1
+                    }]);
+                }
+                break;
+              case "Update" :
+                if (id1$2 === action._0) {
+                  let g$2 = action._1;
+                  return previousActions.concat([{
+                      TAG: "UpdateWithDefault",
+                      _0: id1$2,
+                      _1: g$2(defaultState1),
+                      _2: state => g$2(f$1(state))
+                    }]);
+                }
+                break;
+              case "UpdateWithDefault" :
+                if (id1$2 === action._0) {
+                  let g$3 = action._2;
+                  return previousActions.concat([{
+                      TAG: "UpdateWithDefault",
+                      _0: id1$2,
+                      _1: g$3(defaultState1),
+                      _2: state => g$3(f$1(state))
+                    }]);
+                }
+                break;
+              case "Set" :
+                if (id1$2 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Set after UpdateWithDefault for id=` + id1$2 + `, ignoring the UpdateWithDefault`);
+                  return previousActions.concat([{
+                      TAG: "Set",
+                      _0: id1$2,
+                      _1: action._1
+                    }]);
+                }
+                break;
+              case "Delete" :
+                if (id1$2 === action._0) {
+                  log.warn("Projection", undefined, `optimizing Delete after UpdateWithDefault for id=` + id1$2 + `, ignoring the UpdateWithDefault`);
+                  return previousActions.concat([{
+                      TAG: "Delete",
+                      _0: id1$2
+                    }]);
+                }
+                break;
+            }
+          }
+          break;
+        case "Delete" :
+          if (typeof action === "object" && action.TAG === "Create") {
+            let id1$3 = lastAction._0;
+            if (id1$3 === action._0) {
+              return previousActions.concat([{
+                  TAG: "Set",
+                  _0: id1$3,
+                  _1: action._1
+                }]);
+            }
+          }
+          break;
+        case "UpdateMultiState" :
+          if (typeof action === "object" && action.TAG === "UpdateMultiState") {
+            let id1$4 = lastAction._0;
+            if (id1$4 === action._0) {
+              let g$4 = action._1;
+              let f$2 = lastAction._1;
+              return previousActions.concat([{
+                  TAG: "UpdateMultiState",
+                  _0: id1$4,
+                  _1: state => g$4(f$2(state))
+                }]);
+            }
+          }
+          break;
+      }
+    }
+    log.warn("Projection", undefined, `actions not optimized: ` + Stdlib_Option.getOr(JSON.stringify(lastAction), "?") + ` + ` + Stdlib_Option.getOr(JSON.stringify(action), "?"));
+    return optimizedActions.concat([action]);
+  });
+}
+
+async function handleActions(actions, operations, subIdConfig) {
+  let handleActionsForId = async (actions, id) => {
+    let actionCount = actions.length;
+    if (actionCount > 1) {
+      log.debug("Projection", undefined, `handleActions: optimizing ` + actionCount.toString() + ` actions for id=` + id);
+    }
+    let optimizedActions = optimizeActions(actions);
+    let optimizedActionCount = optimizedActions.length;
+    log.info("Projection", undefined, `handleActions: id=` + id + ` actions=` + optimizedActionCount.toString());
+    return await Stdlib_Array.reduce(optimizedActions, Promise.resolve({
+      TAG: "Ok",
+      _0: undefined
+    }), async (p, action) => {
+      let err = await p;
+      if (err.TAG !== "Ok") {
+        log.error("Projection", undefined, `storage error: ` + JSON.stringify(Message$ReventlessCore.encode(err._0, QueryDb$ReventlessInfra.storageErrorSchema)));
+      }
+      return await handleAction(action, operations, subIdConfig);
+    });
+  };
+  let results = await Promise.all(groupActionsById(actions).map(param => handleActionsForId(param[1], param[0])));
+  let errors = Stdlib_Array.filterMap(results, x => {
+    if (x.TAG === "Ok") {
+      return;
+    } else {
+      return x._0;
+    }
+  });
+  if (errors.length === 0) {
+    return;
+  }
+  let count = errors.length;
+  return Stdlib_JsError.throwWithMessage(`Projection.handleActions failed with ` + count.toString() + ` errors: ` + errors.map(QueryDb$ReventlessCore.storageErrorToString).join(","));
+}
+
+let $$Set;
+
+export {
+  $$Set,
+  log,
+  Mapping,
+  logAction,
+  overlayDisplayName,
+  rewriteAction,
+  applyChanges,
+  stateToString,
+  statesToString,
+  handleAction,
+  actionsWithId,
+  groupActionsById,
+  optimizeActions,
+  handleActions,
+}
+/* log Not a pure module */