envio 2.32.3 → 3.0.0-alpha.0

package/src/{LoadManager.res.js → LoadManager.res.mjs}

@@ -1,9 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
 
-var Utils = require("./Utils.res.js");
-var Belt_Array = require("rescript/lib/js/belt_Array.js");
-var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+import * as Utils from "./Utils.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
 
 var Call = {};
 
@@ -123,10 +122,12 @@ function call(loadManager, input, key, load, hasher, shouldGroup, hasInMemory, g
   return promise;
 }
 
-exports.Call = Call;
-exports.Group = Group;
-exports.make = make;
-exports.schedule = schedule;
-exports.noopHasher = noopHasher;
-exports.call = call;
+export {
+  Call ,
+  Group ,
+  make ,
+  schedule ,
+  noopHasher ,
+  call ,
+}
 /* Utils Not a pure module */

package/src/{LogSelection.res.js → LogSelection.res.mjs}

@@ -1,12 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
 
-var Utils = require("./Utils.res.js");
-var Js_exn = require("rescript/lib/js/js_exn.js");
-var Belt_Array = require("rescript/lib/js/belt_Array.js");
-var Belt_Option = require("rescript/lib/js/belt_Option.js");
-var Caml_option = require("rescript/lib/js/caml_option.js");
-var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
 
 var MissingRequiredTopic0 = /* @__PURE__ */Caml_exceptions.create("LogSelection.MissingRequiredTopic0");
 
@@ -194,10 +193,12 @@ function parseEventFiltersOrThrow(eventFilters, sighash, params, topic1Opt, topi
         };
 }
 
-exports.MissingRequiredTopic0 = MissingRequiredTopic0;
-exports.makeTopicSelection = makeTopicSelection;
-exports.hasFilters = hasFilters;
-exports.compressTopicSelections = compressTopicSelections;
-exports.make = make;
-exports.parseEventFiltersOrThrow = parseEventFiltersOrThrow;
+export {
+  MissingRequiredTopic0 ,
+  makeTopicSelection ,
+  hasFilters ,
+  compressTopicSelections ,
+  make ,
+  parseEventFiltersOrThrow ,
+}
 /* Utils Not a pure module */

package/src/{Logging.res.js → Logging.res.mjs}

@@ -1,13 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
 
-var Pino = require("./bindings/Pino.res.js");
-var Pino$1 = require("pino");
-var Utils = require("./Utils.res.js");
-var Js_exn = require("rescript/lib/js/js_exn.js");
-var Js_dict = require("rescript/lib/js/js_dict.js");
-var Caml_obj = require("rescript/lib/js/caml_obj.js");
-var Caml_option = require("rescript/lib/js/caml_option.js");
+import * as Pino from "./bindings/Pino.res.mjs";
+import * as Pino$1 from "pino";
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
 
 var logLevels = Js_dict.fromArray([
       [
@@ -75,14 +74,14 @@ function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel)
   switch (logStrategy) {
     case "ecs-file" :
         var newrecord = Caml_obj.obj_dup(Pino.ECS.make());
-        return Pino$1((newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
+        return Pino$1.pino((newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
     case "ecs-console" :
         var newrecord$1 = Caml_obj.obj_dup(Pino.ECS.make());
-        return Pino$1((newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
+        return Pino$1.pino((newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
     case "ecs-console-multistream" :
         return makeMultiStreamLogger(undefined, Pino.ECS.make());
     case "file-only" :
-        return Pino$1({
+        return Pino$1.pino({
                     level: defaultFileLogLevel,
                     customLevels: logLevels
                   }, Pino$1.transport(pinoFile));
@@ -262,29 +261,31 @@ function getUserLogger(item) {
         };
 }
 
-exports.logLevels = logLevels;
-exports.makeLogger = makeLogger;
-exports.setLogger = setLogger;
-exports.getLogger = getLogger;
-exports.setLogLevel = setLogLevel;
-exports.trace = trace;
-exports.debug = debug;
-exports.info = info;
-exports.warn = warn;
-exports.error = error;
-exports.errorWithExn = errorWithExn;
-exports.fatal = fatal;
-exports.childTrace = childTrace;
-exports.childDebug = childDebug;
-exports.childInfo = childInfo;
-exports.childWarn = childWarn;
-exports.childError = childError;
-exports.childErrorWithExn = childErrorWithExn;
-exports.childFatal = childFatal;
-exports.createChild = createChild;
-exports.createChildFrom = createChildFrom;
-exports.getItemLogger = getItemLogger;
-exports.logForItem = logForItem;
-exports.noopLogger = noopLogger;
-exports.getUserLogger = getUserLogger;
+export {
+  logLevels ,
+  makeLogger ,
+  setLogger ,
+  getLogger ,
+  setLogLevel ,
+  trace ,
+  debug ,
+  info ,
+  warn ,
+  error ,
+  errorWithExn ,
+  fatal ,
+  childTrace ,
+  childDebug ,
+  childInfo ,
+  childWarn ,
+  childError ,
+  childErrorWithExn ,
+  childFatal ,
+  createChild ,
+  createChildFrom ,
+  getItemLogger ,
+  logForItem ,
+  noopLogger ,
+  getUserLogger ,
+}
 /* logLevels Not a pure module */

package/src/Persistence.res

@@ -29,13 +29,24 @@ type initialState = {
   cleanRun: bool,
   cache: dict<effectCacheRecord>,
   chains: array<initialChainState>,
-  checkpointId: int,
+  checkpointId: Internal.checkpointId,
   // Needed to keep reorg detection logic between restarts
   reorgCheckpoints: array<Internal.reorgCheckpoint>,
 }
 
 type operator = [#">" | #"=" | #"<"]
 
+type updatedEffectCache = {
+  effect: Internal.effect,
+  items: array<Internal.effectCacheItem>,
+  shouldInitialize: bool,
+}
+
+type updatedEntity = {
+  entityConfig: Internal.entityConfig,
+  updates: array<Internal.inMemoryStoreEntityUpdate<Internal.entity>>,
+}
+
 type storage = {
   // Should return true if we already have persisted data
   // and we can skip initialization
@@ -45,7 +56,7 @@ type storage = {
   initialize: (
     ~chainConfigs: array<Config.chain>=?,
     ~entities: array<Internal.entityConfig>=?,
-    ~enums: array<Internal.enumConfig<Internal.enum>>=?,
+    ~enums: array<Table.enumConfig<Table.enum>>=?,
   ) => promise<initialState>,
   resumeInitialState: unit => promise<initialState>,
   @raises("StorageError")
@@ -77,10 +88,53 @@ type storage = {
   ) => promise<unit>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
+  // Execute raw SQL query
+  executeUnsafe: string => promise<unknown>,
+  // Check if entity history has rows
+  hasEntityHistoryRows: unit => promise<bool>,
+  // Update chain metadata
+  setChainMeta: dict<InternalTable.Chains.metaFields> => promise<unknown>,
+  // Prune old checkpoints
+  pruneStaleCheckpoints: (~safeCheckpointId: Internal.checkpointId) => promise<unit>,
+  // Prune stale entity history
+  pruneStaleEntityHistory: (
+    ~entityName: string,
+    ~entityIndex: int,
+    ~safeCheckpointId: Internal.checkpointId,
+  ) => promise<unit>,
+  // Get rollback target checkpoint
+  getRollbackTargetCheckpoint: (
+    ~reorgChainId: int,
+    ~lastKnownValidBlockNumber: int,
+  ) => promise<array<{"id": Internal.checkpointId}>>,
+  // Get rollback progress diff
+  getRollbackProgressDiff: (
+    ~rollbackTargetCheckpointId: Internal.checkpointId,
+  ) => promise<
+    array<{
+      "chain_id": int,
+      "events_processed_diff": string,
+      "new_progress_block_number": int,
+    }>,
+  >,
+  // Get rollback data for entity
+  getRollbackData: (
+    ~entityConfig: Internal.entityConfig,
+    ~rollbackTargetCheckpointId: Internal.checkpointId,
+  ) => promise<(array<{"id": string}>, array<unknown>)>,
+  // Write batch to storage
+  writeBatch: (
+    ~batch: Batch.t,
+    ~rawEvents: array<InternalTable.RawEvents.t>,
+    ~rollbackTargetCheckpointId: option<Internal.checkpointId>,
+    ~isInReorgThreshold: bool,
+    ~config: Config.t,
+    ~allEntities: array<Internal.entityConfig>,
+    ~updatedEffectsCache: array<updatedEffectCache>,
+    ~updatedEntities: array<updatedEntity>,
+  ) => promise<unit>,
 }
 
-exception StorageError({message: string, reason: exn})
-
 type storageStatus =
   | Unknown
   | Initializing(promise<unit>)
@@ -89,38 +143,28 @@ type storageStatus =
 type t = {
   userEntities: array<Internal.entityConfig>,
   allEntities: array<Internal.entityConfig>,
-  allEnums: array<Internal.enumConfig<Internal.enum>>,
+  allEnums: array<Table.enumConfig<Table.enum>>,
   mutable storageStatus: storageStatus,
   mutable storage: storage,
-  // FIXME: This is temporary to move it library
-  // Should be a part of the storage interface and db agnostic
-  mutable sql: Postgres.sql,
 }
 
-let entityHistoryActionEnumConfig: Internal.enumConfig<EntityHistory.RowAction.t> = {
-  name: EntityHistory.RowAction.name,
-  variants: EntityHistory.RowAction.variants,
-  schema: EntityHistory.RowAction.schema,
-  default: SET,
-}
+exception StorageError({message: string, reason: exn})
 
 let make = (
   ~userEntities,
   // TODO: Should only pass userEnums and create internal config in runtime
   ~allEnums,
   ~storage,
-  ~sql,
 ) => {
   let allEntities = userEntities->Js.Array2.concat([InternalTable.DynamicContractRegistry.config])
   let allEnums =
-    allEnums->Js.Array2.concat([entityHistoryActionEnumConfig->Internal.fromGenericEnumConfig])
+    allEnums->Js.Array2.concat([EntityHistory.RowAction.config->Table.fromGenericEnumConfig])
   {
     userEntities,
     allEntities,
     allEnums,
     storageStatus: Unknown,
     storage,
-    sql,
   }
 }
 
@@ -197,32 +241,140 @@ let getInitializedState = persistence => {
   }
 }
 
-let setEffectCacheOrThrow = async (
+let writeBatch = (
   persistence,
-  ~effect: Internal.effect,
-  ~items,
-  ~invalidationsCount,
-) => {
+  ~batch,
+  ~config,
+  ~inMemoryStore: InMemoryStore.t,
+  ~isInReorgThreshold,
+) =>
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
     Js.Exn.raiseError(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
-  | Ready({cache}) => {
-      let storage = persistence.storage
-      let effectName = effect.name
-      let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(effectName) {
-      | Some(c) => c
-      | None => {
-          let c = {effectName, count: 0}
-          cache->Js.Dict.set(effectName, c)
-          c
-        }
+  | Ready({cache}) =>
+    let updatedEntities = persistence.allEntities->Belt.Array.keepMapU(entityConfig => {
+      let updates =
+        inMemoryStore
+        ->InMemoryStore.getInMemTable(~entityConfig)
+        ->InMemoryTable.Entity.updates
+      if updates->Utils.Array.isEmpty {
+        None
+      } else {
+        Some({entityConfig, updates})
       }
-      let initialize = effectCacheRecord.count === 0
-      await storage.setEffectCacheOrThrow(~effect, ~items, ~initialize)
-      effectCacheRecord.count =
-        effectCacheRecord.count + items->Js.Array2.length - invalidationsCount
-      Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
-    }
+    })
+    persistence.storage.writeBatch(
+      ~batch,
+      ~rawEvents=inMemoryStore.rawEvents->InMemoryTable.values,
+      ~rollbackTargetCheckpointId=inMemoryStore.rollbackTargetCheckpointId,
+      ~isInReorgThreshold,
+      ~config,
+      ~allEntities=persistence.allEntities,
+      ~updatedEntities,
+      ~updatedEffectsCache={
+        inMemoryStore.effects
+        ->Js.Dict.keys
+        ->Belt.Array.keepMapU(effectName => {
+          let inMemTable = inMemoryStore.effects->Js.Dict.unsafeGet(effectName)
+          let {idsToStore, dict, effect, invalidationsCount} = inMemTable
+          switch idsToStore {
+          | [] => None
+          | ids => {
+              let items = Belt.Array.makeUninitializedUnsafe(ids->Belt.Array.length)
+              ids->Belt.Array.forEachWithIndex((index, id) => {
+                items->Js.Array2.unsafe_set(
+                  index,
+                  (
+                    {
+                      id,
+                      output: dict->Js.Dict.unsafeGet(id),
+                    }: Internal.effectCacheItem
+                  ),
+                )
+              })
+              Some({
+                let effectName = effect.name
+                let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(
+                  effectName,
+                ) {
+                | Some(c) => c
+                | None => {
+                    let c = {effectName, count: 0}
+                    cache->Js.Dict.set(effectName, c)
+                    c
+                  }
+                }
+                let shouldInitialize = effectCacheRecord.count === 0
+                effectCacheRecord.count =
+                  effectCacheRecord.count + items->Js.Array2.length - invalidationsCount
+                Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
+                {effect, items, shouldInitialize}
+              })
+            }
+          }
+        })
+      },
+    )
+  }
+
+let prepareRollbackDiff = async (
+  persistence: t,
+  ~rollbackTargetCheckpointId,
+  ~rollbackDiffCheckpointId,
+) => {
+  let inMemStore = InMemoryStore.make(
+    ~entities=persistence.allEntities,
+    ~rollbackTargetCheckpointId,
+  )
+
+  let deletedEntities = Js.Dict.empty()
+  let setEntities = Js.Dict.empty()
+
+  let _ =
+    await persistence.allEntities
+    ->Belt.Array.map(async entityConfig => {
+      let entityTable = inMemStore->InMemoryStore.getInMemTable(~entityConfig)
+
+      let (removedIdsResult, restoredEntitiesResult) = await persistence.storage.getRollbackData(
+        ~entityConfig,
+        ~rollbackTargetCheckpointId,
+      )
+
+      // Process removed IDs
+      removedIdsResult->Js.Array2.forEach(data => {
+        deletedEntities->Utils.Dict.push(entityConfig.name, data["id"])
+        entityTable->InMemoryTable.Entity.set(
+          Delete({
+            entityId: data["id"],
+            checkpointId: rollbackDiffCheckpointId,
+          }),
+          ~shouldSaveHistory=false,
+          ~containsRollbackDiffChange=true,
+        )
+      })
+
+      let restoredEntities = restoredEntitiesResult->S.parseOrThrow(entityConfig.rowsSchema)
+
+      // Process restored entities
+      restoredEntities->Belt.Array.forEach((entity: Internal.entity) => {
+        setEntities->Utils.Dict.push(entityConfig.name, entity.id)
+        entityTable->InMemoryTable.Entity.set(
+          Set({
+            entityId: entity.id,
+            checkpointId: rollbackDiffCheckpointId,
+            entity,
+          }),
+          ~shouldSaveHistory=false,
+          ~containsRollbackDiffChange=true,
+        )
+      })
+    })
+    ->Promise.all
+
+  {
+    "inMemStore": inMemStore,
+    "deletedEntities": deletedEntities,
+    "setEntities": setEntities,
   }
 }

package/src/Persistence.res.mjs

@@ -0,0 +1,213 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Logging from "./Logging.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as EntityHistory from "./db/EntityHistory.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as InternalTable from "./db/InternalTable.res.mjs";
+import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+
+var StorageError = /* @__PURE__ */Caml_exceptions.create("Persistence.StorageError");
+
+function make(userEntities, allEnums, storage) {
+  var allEntities = userEntities.concat([InternalTable.DynamicContractRegistry.config]);
+  var allEnums$1 = allEnums.concat([EntityHistory.RowAction.config]);
+  return {
+          userEntities: userEntities,
+          allEntities: allEntities,
+          allEnums: allEnums$1,
+          storageStatus: "Unknown",
+          storage: storage
+        };
+}
+
+async function init(persistence, chainConfigs, resetOpt) {
+  var reset = resetOpt !== undefined ? resetOpt : false;
+  try {
+    var promise = persistence.storageStatus;
+    var shouldRun;
+    if (typeof promise !== "object") {
+      shouldRun = true;
+    } else if (promise.TAG === "Initializing") {
+      await promise._0;
+      shouldRun = reset;
+    } else {
+      shouldRun = reset;
+    }
+    if (!shouldRun) {
+      return ;
+    }
+    var resolveRef = {
+      contents: null
+    };
+    var promise$1 = new Promise((function (resolve, param) {
+            resolveRef.contents = resolve;
+          }));
+    persistence.storageStatus = {
+      TAG: "Initializing",
+      _0: promise$1
+    };
+    if (reset || !await persistence.storage.isInitialized()) {
+      Logging.info("Initializing the indexer storage...");
+      var initialState = await persistence.storage.initialize(chainConfigs, persistence.allEntities, persistence.allEnums);
+      Logging.info("The indexer storage is ready. Starting indexing!");
+      persistence.storageStatus = {
+        TAG: "Ready",
+        _0: initialState
+      };
+    } else {
+      var match = persistence.storageStatus;
+      var tmp;
+      tmp = typeof match !== "object" || match.TAG !== "Initializing" ? false : true;
+      if (tmp) {
+        Logging.info("Found existing indexer storage. Resuming indexing state...");
+        var initialState$1 = await persistence.storage.resumeInitialState();
+        persistence.storageStatus = {
+          TAG: "Ready",
+          _0: initialState$1
+        };
+        var progress = {};
+        initialState$1.chains.forEach(function (c) {
+              progress[c.id] = c.progressBlockNumber;
+            });
+        Logging.info({
+              msg: "Successfully resumed indexing state! Continuing from the last checkpoint.",
+              progress: progress
+            });
+      }
+      
+    }
+    return resolveRef.contents();
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return ErrorHandling.mkLogAndRaise(undefined, "EE800: Failed to initialize the indexer storage.", exn);
+  }
+}
+
+function getInitializedStorageOrThrow(persistence) {
+  var match = persistence.storageStatus;
+  if (typeof match !== "object" || match.TAG === "Initializing") {
+    return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
+  } else {
+    return persistence.storage;
+  }
+}
+
+function getInitializedState(persistence) {
+  var initialState = persistence.storageStatus;
+  if (typeof initialState !== "object" || initialState.TAG === "Initializing") {
+    return Js_exn.raiseError("Failed to access the initial state. The Persistence layer is not initialized.");
+  } else {
+    return initialState._0;
+  }
+}
+
+function writeBatch(persistence, batch, config, inMemoryStore, isInReorgThreshold) {
+  var match = persistence.storageStatus;
+  if (typeof match !== "object") {
+    return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
+  }
+  if (match.TAG === "Initializing") {
+    return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
+  }
+  var cache = match._0.cache;
+  var updatedEntities = Belt_Array.keepMapU(persistence.allEntities, (function (entityConfig) {
+          var updates = InMemoryTable.Entity.updates(InMemoryStore.getInMemTable(inMemoryStore, entityConfig));
+          if (Utils.$$Array.isEmpty(updates)) {
+            return ;
+          } else {
+            return {
+                    entityConfig: entityConfig,
+                    updates: updates
+                  };
+          }
+        }));
+  return persistence.storage.writeBatch(batch, InMemoryTable.values(inMemoryStore.rawEvents), inMemoryStore.rollbackTargetCheckpointId, isInReorgThreshold, config, persistence.allEntities, Belt_Array.keepMapU(Object.keys(inMemoryStore.effects), (function (effectName) {
+                    var inMemTable = inMemoryStore.effects[effectName];
+                    var idsToStore = inMemTable.idsToStore;
+                    var invalidationsCount = inMemTable.invalidationsCount;
+                    var effect = inMemTable.effect;
+                    var dict = inMemTable.dict;
+                    if (idsToStore.length === 0) {
+                      return ;
+                    }
+                    var items = new Array(idsToStore.length);
+                    Belt_Array.forEachWithIndex(idsToStore, (function (index, id) {
+                            items[index] = {
+                              id: id,
+                              output: dict[id]
+                            };
+                          }));
+                    var effectName$1 = effect.name;
+                    var c = cache[effectName$1];
+                    var effectCacheRecord;
+                    if (c !== undefined) {
+                      effectCacheRecord = c;
+                    } else {
+                      var c$1 = {
+                        effectName: effectName$1,
+                        count: 0
+                      };
+                      cache[effectName$1] = c$1;
+                      effectCacheRecord = c$1;
+                    }
+                    var shouldInitialize = effectCacheRecord.count === 0;
+                    return effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0, Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName$1), {
+                            effect: effect,
+                            items: items,
+                            shouldInitialize: shouldInitialize
+                          };
+                  })), updatedEntities);
+}
+
+async function prepareRollbackDiff(persistence, rollbackTargetCheckpointId, rollbackDiffCheckpointId) {
+  var inMemStore = InMemoryStore.make(persistence.allEntities, rollbackTargetCheckpointId);
+  var deletedEntities = {};
+  var setEntities = {};
+  await Promise.all(Belt_Array.map(persistence.allEntities, (async function (entityConfig) {
+              var entityTable = InMemoryStore.getInMemTable(inMemStore, entityConfig);
+              var match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
+              match[0].forEach(function (data) {
+                    Utils.Dict.push(deletedEntities, entityConfig.name, data.id);
+                    InMemoryTable.Entity.set(entityTable, {
+                          type: "DELETE",
+                          entityId: data.id,
+                          checkpointId: rollbackDiffCheckpointId
+                        }, false, true);
+                  });
+              var restoredEntities = S$RescriptSchema.parseOrThrow(match[1], entityConfig.rowsSchema);
+              return Belt_Array.forEach(restoredEntities, (function (entity) {
+                            Utils.Dict.push(setEntities, entityConfig.name, entity.id);
+                            InMemoryTable.Entity.set(entityTable, {
+                                  type: "SET",
+                                  entityId: entity.id,
+                                  entity: entity,
+                                  checkpointId: rollbackDiffCheckpointId
+                                }, false, true);
+                          }));
+            })));
+  return {
+          inMemStore: inMemStore,
+          deletedEntities: deletedEntities,
+          setEntities: setEntities
+        };
+}
+
+export {
+  StorageError ,
+  make ,
+  init ,
+  getInitializedStorageOrThrow ,
+  getInitializedState ,
+  writeBatch ,
+  prepareRollbackDiff ,
+}
+/* Utils Not a pure module */