envio 3.0.2 → 3.1.0-rc.1

package/src/InMemoryTable.res.mjs

@@ -1,8 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Lodash from "./bindings/Lodash.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Internal from "./Internal.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as TableIndices from "./TableIndices.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
@@ -11,44 +10,6 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function make(hash) {
-  return {
-    dict: {},
-    hash: hash
-  };
-}
-
-function set(self, key, value) {
-  self.dict[self.hash(key)] = value;
-}
-
-function setByHash(self, hash, value) {
-  self.dict[hash] = value;
-}
-
-function hasByHash(self, hash) {
-  return Utils.Dict.has(self.dict, hash);
-}
-
-function getUnsafeByHash(self, hash) {
-  return self.dict[hash];
-}
-
-function get(self, key) {
-  return self.dict[self.hash(key)];
-}
-
-function values(self) {
-  return Object.values(self.dict);
-}
-
-function clone(self) {
-  return {
-    dict: Lodash.cloneDeep(self.dict),
-    hash: self.hash
-  };
-}
-
 let UnexpectedIdNotDefinedOnEntity = /* @__PURE__ */Primitive_exceptions.create("InMemoryTable.Entity.UnexpectedIdNotDefinedOnEntity");
 
 function getEntityIdUnsafe(entity) {
@@ -62,171 +23,195 @@ function getEntityIdUnsafe(entity) {
   }
 }
 
+function getOrCreateEntityIndices(self, entityId) {
+  let s = self.indicesByEntityId[entityId];
+  if (s !== undefined) {
+    return Primitive_option.valFromOption(s);
+  }
+  let s$1 = new Set();
+  self.indicesByEntityId[entityId] = s$1;
+  return s$1;
+}
+
 function makeIndicesSerializedToValue(index, relatedEntityIdsOpt) {
   let relatedEntityIds = relatedEntityIdsOpt !== undefined ? Primitive_option.valFromOption(relatedEntityIdsOpt) : new Set();
-  let empty_dict = {};
-  let empty_hash = TableIndices.Index.toString;
-  let empty = {
-    dict: empty_dict,
-    hash: empty_hash
-  };
-  set(empty, index, [
+  let empty = {};
+  empty[TableIndices.Index.toString(index)] = [
     index,
     relatedEntityIds
-  ]);
+  ];
   return empty;
 }
 
-function make$1() {
+function make() {
   return {
-    table: {
-      dict: {},
-      hash: str => str
-    },
-    fieldNameIndices: {
-      dict: {},
-      hash: TableIndices.Index.getFieldName
-    }
+    latestEntityChangeById: {},
+    changesCount: 0,
+    prevEntityChanges: [],
+    indicesByEntityId: {},
+    fieldNameIndices: {}
   };
 }
 
-function updateIndices(self, entity, entityIndices) {
-  entityIndices.forEach(index => {
-    let fieldName = TableIndices.Index.getFieldName(index);
-    let fieldValue = entity[fieldName];
-    if (!TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
-      entityIndices.delete(index);
+function resetButKeepLatestChanges(self) {
+  let init = {
+    latestEntityChangeById: {},
+    changesCount: 0,
+    prevEntityChanges: [],
+    indicesByEntityId: {},
+    fieldNameIndices: {}
+  };
+  return {
+    latestEntityChangeById: self.latestEntityChangeById,
+    changesCount: self.changesCount,
+    prevEntityChanges: init.prevEntityChanges,
+    indicesByEntityId: init.indicesByEntityId,
+    fieldNameIndices: init.fieldNameIndices
+  };
+}
+
+function resetButKeepLoadedFromDbChanges(self) {
+  let latestEntityChangeById = {};
+  let keptCount = {
+    contents: 0
+  };
+  Utils.Dict.forEachWithKey(self.latestEntityChangeById, (change, key) => {
+    if (change.checkpointId === Internal.loadedFromDbCheckpointId) {
+      latestEntityChangeById[key] = change;
+      keptCount.contents = keptCount.contents + 1;
       return;
     }
   });
-  Object.keys(self.fieldNameIndices.dict).forEach(fieldName => {
-    let indices = self.fieldNameIndices.dict[fieldName];
+  let init = {
+    latestEntityChangeById: {},
+    changesCount: 0,
+    prevEntityChanges: [],
+    indicesByEntityId: {},
+    fieldNameIndices: {}
+  };
+  return {
+    latestEntityChangeById: latestEntityChangeById,
+    changesCount: keptCount.contents,
+    prevEntityChanges: init.prevEntityChanges,
+    indicesByEntityId: init.indicesByEntityId,
+    fieldNameIndices: init.fieldNameIndices
+  };
+}
+
+function updateIndices(self, entity) {
+  let entityId = getEntityIdUnsafe(entity);
+  let entityIndices = self.indicesByEntityId[entityId];
+  if (entityIndices !== undefined) {
+    let entityIndices$1 = Primitive_option.valFromOption(entityIndices);
+    entityIndices$1.forEach(index => {
+      let fieldName = TableIndices.Index.getFieldName(index);
+      let fieldValue = entity[fieldName];
+      if (!TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
+        entityIndices$1.delete(index);
+        return;
+      }
+    });
+  }
+  Utils.Dict.forEachWithKey(self.fieldNameIndices, (indices, fieldName) => {
     let fieldValue = entity[fieldName];
-    Object.values(indices.dict).forEach(param => {
+    Utils.Dict.forEach(indices, param => {
       let relatedEntityIds = param[1];
       let index = param[0];
       if (TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
-        relatedEntityIds.add(getEntityIdUnsafe(entity));
-        entityIndices.add(index);
+        relatedEntityIds.add(entityId);
+        getOrCreateEntityIndices(self, entityId).add(index);
       } else {
-        relatedEntityIds.delete(getEntityIdUnsafe(entity));
+        relatedEntityIds.delete(entityId);
       }
     });
   });
 }
 
-function deleteEntityFromIndices(self, entityId, entityIndices) {
-  entityIndices.forEach(index => {
-    let match = Stdlib_Option.flatMap(get(self.fieldNameIndices, index), __x => get(__x, index));
+function deleteEntityFromIndices(self, entityId) {
+  let entityIndices = self.indicesByEntityId[entityId];
+  if (entityIndices === undefined) {
+    return;
+  }
+  let entityIndices$1 = Primitive_option.valFromOption(entityIndices);
+  entityIndices$1.forEach(index => {
+    let match = Stdlib_Option.flatMap(self.fieldNameIndices[TableIndices.Index.getFieldName(index)], indices => indices[TableIndices.Index.toString(index)]);
     if (match !== undefined) {
       match[1].delete(entityId);
     }
-    entityIndices.delete(index);
+    entityIndices$1.delete(index);
   });
 }
 
-function initValue(inMemTable, key, entity, allowOverWriteEntityOpt) {
-  let allowOverWriteEntity = allowOverWriteEntityOpt !== undefined ? allowOverWriteEntityOpt : false;
-  let shouldWriteEntity = allowOverWriteEntity || Stdlib_Option.isNone(inMemTable.table.dict[inMemTable.table.hash(key)]);
-  if (!shouldWriteEntity) {
-    return;
-  }
-  let entityIndices = new Set();
-  if (entity !== undefined) {
-    updateIndices(inMemTable, Primitive_option.valFromOption(entity), entityIndices);
-  }
-  inMemTable.table.dict[inMemTable.table.hash(key)] = {
-    latest: entity,
-    status: "Loaded",
-    entityIndices: entityIndices
-  };
-}
-
-function set$1(inMemTable, change, shouldSaveHistory, containsRollbackDiffChangeOpt) {
-  let containsRollbackDiffChange = containsRollbackDiffChangeOpt !== undefined ? containsRollbackDiffChangeOpt : false;
-  let latest;
-  latest = change.type === "SET" ? Primitive_option.some(change.entity) : undefined;
-  let match = get(inMemTable.table, change.entityId);
-  let updatedEntityRecord;
-  if (match !== undefined) {
-    let previous_values = match.status;
-    if (previous_values === "Loaded") {
-      updatedEntityRecord = {
-        latest: latest,
-        status: {
-          latestChange: change,
-          history: shouldSaveHistory ? [change] : Utils.$$Array.immutableEmpty,
-          containsRollbackDiffChange: containsRollbackDiffChange
-        },
-        entityIndices: match.entityIndices
-      };
-    } else {
-      let newStatus = {
-        latestChange: change,
-        history: shouldSaveHistory ? (
-            previous_values.latestChange.checkpointId === change.checkpointId ? Utils.$$Array.setIndexImmutable(previous_values.history, previous_values.history.length - 1 | 0, change) : Belt_Array.concatMany([
-                previous_values.history,
-                [change]
-              ])
-          ) : previous_values.history,
-        containsRollbackDiffChange: previous_values.containsRollbackDiffChange
-      };
-      updatedEntityRecord = {
-        latest: latest,
-        status: newStatus,
-        entityIndices: match.entityIndices
-      };
+function set(inMemTable, committedCheckpointId, change) {
+  let entityId = change.entityId;
+  let prev = inMemTable.latestEntityChangeById[entityId];
+  if (prev !== undefined) {
+    let prevCheckpointId = prev.checkpointId;
+    if (prevCheckpointId > committedCheckpointId && prevCheckpointId < change.checkpointId) {
+      inMemTable.prevEntityChanges.push(prev);
+      inMemTable.changesCount = inMemTable.changesCount + 1;
     }
   } else {
-    updatedEntityRecord = {
-      latest: latest,
-      status: {
-        latestChange: change,
-        history: shouldSaveHistory ? [change] : Utils.$$Array.immutableEmpty,
-        containsRollbackDiffChange: containsRollbackDiffChange
-      },
-      entityIndices: new Set()
-    };
+    inMemTable.changesCount = inMemTable.changesCount + 1;
   }
   if (change.type === "SET") {
-    updateIndices(inMemTable, change.entity, updatedEntityRecord.entityIndices);
+    updateIndices(inMemTable, change.entity);
   } else {
-    deleteEntityFromIndices(inMemTable, change.entityId, updatedEntityRecord.entityIndices);
+    deleteEntityFromIndices(inMemTable, change.entityId);
   }
-  set(inMemTable.table, change.entityId, updatedEntityRecord);
+  inMemTable.latestEntityChangeById[entityId] = change;
 }
 
-function rowToEntity(row) {
-  return row.latest;
+function initValue(inMemTable, committedCheckpointId, key, entity) {
+  if (!Stdlib_Option.isNone(inMemTable.latestEntityChangeById[key])) {
+    return;
+  }
+  let change = entity !== undefined ? ({
+      type: "SET",
+      entityId: key,
+      entity: entity,
+      checkpointId: Internal.loadedFromDbCheckpointId
+    }) : ({
+      type: "DELETE",
+      entityId: key,
+      checkpointId: Internal.loadedFromDbCheckpointId
+    });
+  set(inMemTable, committedCheckpointId, change);
+}
+
+function mapChangeToEntity(change) {
+  if (change.type === "SET") {
+    return change.entity;
+  }
 }
 
 function getUnsafe(inMemTable) {
-  return key => inMemTable.table.dict[key].latest;
+  return key => mapChangeToEntity(inMemTable.latestEntityChangeById[key]);
 }
 
 function hasIndex(inMemTable, fieldName, operator) {
   return fieldValueHash => {
-    let indicesSerializedToValue = inMemTable.fieldNameIndices.dict[fieldName];
+    let indicesSerializedToValue = inMemTable.fieldNameIndices[fieldName];
     if (indicesSerializedToValue === undefined) {
       return false;
     }
-    let key = fieldName + `:` + operator + `:` + fieldValueHash;
-    return indicesSerializedToValue.dict[key] !== undefined;
+    let key = TableIndices.Index.toStringByParts(fieldName, operator, fieldValueHash);
+    return indicesSerializedToValue[key] !== undefined;
   };
 }
 
 function getUnsafeOnIndex(inMemTable, fieldName, operator) {
   let getEntity = getUnsafe(inMemTable);
   return fieldValueHash => {
-    let indicesSerializedToValue = inMemTable.fieldNameIndices.dict[fieldName];
+    let indicesSerializedToValue = inMemTable.fieldNameIndices[fieldName];
     if (indicesSerializedToValue === undefined) {
       return Stdlib_JsError.throwWithMessage(`Unexpected error. Must have an index on field ` + fieldName);
     }
-    let key = fieldName + `:` + operator + `:` + fieldValueHash;
-    let match = indicesSerializedToValue.dict[key];
+    let key = TableIndices.Index.toStringByParts(fieldName, operator, fieldValueHash);
+    let match = indicesSerializedToValue[key];
     if (match !== undefined) {
       return Stdlib_Array.filterMap(Array.from(match[1]), entityId => {
-        if (hasByHash(inMemTable.table, entityId)) {
+        if (entityId in inMemTable.latestEntityChangeById) {
           return getEntity(entityId);
         }
       });
@@ -239,111 +224,55 @@ function getUnsafeOnIndex(inMemTable, fieldName, operator) {
 function addEmptyIndex(inMemTable, index) {
   let fieldName = TableIndices.Index.getFieldName(index);
   let relatedEntityIds = new Set();
-  Object.values(inMemTable.table.dict).forEach(row => {
-    let entity = row.latest;
+  Utils.Dict.forEach(inMemTable.latestEntityChangeById, change => {
+    let entity = mapChangeToEntity(change);
     if (entity === undefined) {
       return;
     }
-    let entity$1 = Primitive_option.valFromOption(entity);
-    let fieldValue = entity$1[fieldName];
-    if (TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
-      row.entityIndices.add(index);
-      relatedEntityIds.add(getEntityIdUnsafe(entity$1));
+    let fieldValue = entity[fieldName];
+    if (!TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
       return;
     }
+    let entityId = getEntityIdUnsafe(entity);
+    getOrCreateEntityIndices(inMemTable, entityId).add(index);
+    relatedEntityIds.add(entityId);
   });
-  let indicesSerializedToValue = get(inMemTable.fieldNameIndices, index);
-  if (indicesSerializedToValue === undefined) {
-    return set(inMemTable.fieldNameIndices, index, makeIndicesSerializedToValue(index, Primitive_option.some(relatedEntityIds)));
-  }
-  let match = get(indicesSerializedToValue, index);
-  if (match !== undefined) {
-    return;
-  } else {
-    return set(indicesSerializedToValue, index, [
-      index,
-      relatedEntityIds
-    ]);
-  }
-}
-
-function addIdToIndex(inMemTable, index, entityId) {
-  let indicesSerializedToValue = get(inMemTable.fieldNameIndices, index);
-  if (indicesSerializedToValue === undefined) {
-    return set(inMemTable.fieldNameIndices, index, makeIndicesSerializedToValue(index, Primitive_option.some(new Set().add(entityId))));
-  }
-  let match = get(indicesSerializedToValue, index);
-  if (match !== undefined) {
-    match[1].add(entityId);
-    return;
-  } else {
-    return set(indicesSerializedToValue, index, [
-      index,
-      new Set().add(entityId)
-    ]);
-  }
-}
-
-function updates(inMemTable) {
-  return Stdlib_Array.filterMap(Object.values(inMemTable.table.dict), v => {
-    let update = v.status;
-    if (update === "Loaded") {
+  let indicesSerializedToValue = inMemTable.fieldNameIndices[fieldName];
+  if (indicesSerializedToValue !== undefined) {
+    let match = indicesSerializedToValue[TableIndices.Index.toString(index)];
+    if (match !== undefined) {
       return;
     } else {
-      return update;
-    }
-  });
-}
-
-function values$1(inMemTable) {
-  return Stdlib_Array.filterMap(Object.values(inMemTable.table.dict), rowToEntity);
-}
-
-function clone$1(param) {
-  let fieldNameIndices = param.fieldNameIndices;
-  return {
-    table: clone(param.table),
-    fieldNameIndices: {
-      dict: Object.fromEntries(Object.entries(fieldNameIndices.dict).map(param => [
-        param[0],
-        clone(param[1])
-      ])),
-      hash: fieldNameIndices.hash
+      indicesSerializedToValue[TableIndices.Index.toString(index)] = [
+        index,
+        relatedEntityIds
+      ];
+      return;
     }
-  };
+  }
+  inMemTable.fieldNameIndices[fieldName] = makeIndicesSerializedToValue(index, Primitive_option.some(relatedEntityIds));
 }
 
 let Entity = {
   UnexpectedIdNotDefinedOnEntity: UnexpectedIdNotDefinedOnEntity,
   getEntityIdUnsafe: getEntityIdUnsafe,
+  getOrCreateEntityIndices: getOrCreateEntityIndices,
   makeIndicesSerializedToValue: makeIndicesSerializedToValue,
-  make: make$1,
+  make: make,
+  resetButKeepLatestChanges: resetButKeepLatestChanges,
+  resetButKeepLoadedFromDbChanges: resetButKeepLoadedFromDbChanges,
   updateIndices: updateIndices,
   deleteEntityFromIndices: deleteEntityFromIndices,
+  set: set,
   initValue: initValue,
-  setRow: set,
-  set: set$1,
-  rowToEntity: rowToEntity,
-  getRow: get,
+  mapChangeToEntity: mapChangeToEntity,
   getUnsafe: getUnsafe,
   hasIndex: hasIndex,
   getUnsafeOnIndex: getUnsafeOnIndex,
-  addEmptyIndex: addEmptyIndex,
-  addIdToIndex: addIdToIndex,
-  updates: updates,
-  values: values$1,
-  clone: clone$1
+  addEmptyIndex: addEmptyIndex
 };
 
 export {
-  make,
-  set,
-  setByHash,
-  hasByHash,
-  getUnsafeByHash,
-  get,
-  values,
-  clone,
   Entity,
 }
 /* Utils Not a pure module */

package/src/Internal.res

@@ -330,17 +330,11 @@ type genericHandlerWithLoader<'loader, 'handler, 'where> = {
 // param (or any nested field) is a Solidity struct. `name` is always non-empty —
 // the CLI fills in `"0"`, `"1"`, ... for anonymous components in mixed-name
 // tuples — so the runtime can always rebuild a keyed object.
-type rec eventParamComponent = {
-  name: string,
-  abiType: string,
-  components?: array<eventParamComponent>,
-}
-
-type eventParam = {
+type rec paramMeta = {
   name: string,
   abiType: string,
   indexed: bool,
-  components?: array<eventParamComponent>,
+  components?: array<paramMeta>,
 }
 
 // This is private so it's not manually constructed internally
@@ -398,15 +392,11 @@ type eventFilters =
 type evmEventConfig = {
   ...eventConfig,
   getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
-  convertHyperSyncEventArgs: HyperSyncClient.Decoder.decodedEvent => eventParams,
   selectedBlockFields: Utils.Set.t<evmBlockField>,
   selectedTransactionFields: Utils.Set.t<evmTransactionField>,
-  // Retained so `HandlerLoader.applyRegistrations` can re-run
-  // `LogSelection.parseEventFiltersOrThrow` after handler modules register
-  // with a `where:` filter. Only indexed params are kept — they're all the
-  // filter parser needs for topic-getter construction + key validation.
   sighash: string,
-  indexedParams: array<eventParam>,
+  topicCount: int,
+  paramsMetadata: array<paramMeta>,
 }
 
 // Shared formula for `eventConfig.dependsOnAddresses`. Kept here so
@@ -520,8 +510,6 @@ let fuelTransferParamsSchema = S.schema(s => {
   amount: s.matches(Utils.BigInt.schema),
 })
 
-type multichain = | @as("ordered") Ordered | @as("unordered") Unordered
-
 type entity = private {id: string}
 
 // Per-entity storage resolved at parse time against the global storage
@@ -595,6 +583,12 @@ type noOnEventWhere
 
 type checkpointId = bigint
 
+// Assigned to changes loaded from the db, which never become history.
+let loadedFromDbCheckpointId: checkpointId = 0n
+
+// Committed checkpoint before any batch is written.
+let initialCheckpointId: checkpointId = 0n
+
 type reorgCheckpoint = {
   @as("id")
   checkpointId: bigint,
@@ -605,21 +599,3 @@ type reorgCheckpoint = {
   @as("block_hash")
   blockHash: string,
 }
-
-type inMemoryStoreEntityUpdate<'entity> = {
-  latestChange: Change.t<'entity>,
-  history: array<Change.t<'entity>>,
-  // In the event of a rollback, some entity updates may have been
-  // been affected by a rollback diff. If there was no rollback diff
-  // this will always be false.
-  // If there was a rollback diff, this will be false in the case of a
-  // new entity update (where entity affected is not present in the diff) b
-  // but true if the update is related to an entity that is
-  // currently present in the diff
-  containsRollbackDiffChange: bool,
-}
-
-@unboxed
-type inMemoryStoreEntityStatus<'entity> =
-  | Updated(inMemoryStoreEntityUpdate<'entity>)
-  | Loaded // This means there is no change from the db.

package/src/Internal.res.mjs

@@ -151,11 +151,15 @@ let effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(s
 
 function makeCacheTable(effectName) {
   return Table.mkTable(cacheTablePrefix + effectName, undefined, [
-    Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-    Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
-  ]);
+    Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined),
+    Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined, undefined)
+  ], undefined);
 }
 
+let loadedFromDbCheckpointId = 0n;
+
+let initialCheckpointId = 0n;
+
 export {
   allEvmBlockFields,
   evmBlockFieldSchema,
@@ -171,5 +175,7 @@ export {
   cacheOutputSchema,
   effectCacheItemRowsSchema,
   makeCacheTable,
+  loadedFromDbCheckpointId,
+  initialCheckpointId,
 }
 /* evmBlockFieldSchema Not a pure module */

package/src/LoadLayer.res

@@ -36,7 +36,7 @@ let loadById = (
     }
     idsToLoad->Array.forEach(entityId => {
       inMemTable->InMemoryTable.Entity.initValue(
-        ~allowOverWriteEntity=false,
+        ~committedCheckpointId=inMemoryStore.committedCheckpointId,
         ~key=entityId,
         ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityId),
       )
@@ -56,7 +56,7 @@ let loadById = (
     ~shouldGroup,
     ~hasher=LoadManager.noopHasher,
     ~getUnsafeInMemory=inMemTable->InMemoryTable.Entity.getUnsafe,
-    ~hasInMemory=hash => inMemTable.table->InMemoryTable.hasByHash(hash),
+    ~hasInMemory=hash => inMemTable.latestEntityChangeById->Dict.has(hash),
     ~input=entityId,
   )
 }
@@ -253,7 +253,7 @@ let loadEffect = (
 
     if (
       switch persistence.storageStatus {
-      | Ready({cache}) => cache->Utils.Dict.has(effectName)
+      | Ready({cache}) => cache->Dict.has(effectName)
       | _ => false
       }
     ) {
@@ -335,7 +335,7 @@ let loadEffect = (
     ~shouldGroup,
     ~hasher=args => args.cacheKey,
     ~getUnsafeInMemory=hash => inMemTable.dict->Dict.getUnsafe(hash),
-    ~hasInMemory=hash => inMemTable.dict->Utils.Dict.has(hash),
+    ~hasInMemory=hash => inMemTable.dict->Dict.has(hash),
     ~input=effectArgs,
   )
 }
@@ -397,7 +397,7 @@ let loadByField = (
 
         entities->Array.forEach(entity => {
           inMemTable->InMemoryTable.Entity.initValue(
-            ~allowOverWriteEntity=false,
+            ~committedCheckpointId=inMemoryStore.committedCheckpointId,
             ~key=entity.id,
             ~entity=Some(entity),
           )

package/src/LoadLayer.res.mjs

@@ -37,10 +37,10 @@ function loadById(loadManager, persistence, entityConfig, inMemoryStore, shouldG
       let entity = dbEntities[idx];
       entitiesMap[entity.id] = entity;
     }
-    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, entityId, entitiesMap[entityId], false));
+    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, inMemoryStore.committedCheckpointId, entityId, entitiesMap[entityId]));
     return Prometheus.StorageLoad.endOperation(timerRef, storage.name, key, idsToLoad.length, dbEntities.length);
   };
-  return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, hash => InMemoryTable.hasByHash(inMemTable.table, hash), InMemoryTable.Entity.getUnsafe(inMemTable));
+  return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, hash => hash in inMemTable.latestEntityChangeById, InMemoryTable.Entity.getUnsafe(inMemTable));
 }
 
 function callEffect(effect, arg, inMemTable, timerRef, onError) {
@@ -137,7 +137,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore,
     let idsFromCache = new Set();
     let match = persistence.storageStatus;
     let tmp;
-    tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : Utils.Dict.has(match._0.cache, effectName);
+    tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : effectName in match._0.cache;
     if (tmp) {
       let storage = Persistence.getInitializedStorageOrThrow(persistence);
       let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
@@ -193,7 +193,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore,
       return await executeWithRateLimit(effect, argsToCall, inMemTable, onError, false);
     }
   };
-  return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => Utils.Dict.has(inMemTable.dict, hash), hash => inMemTable.dict[hash]);
+  return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => hash in inMemTable.dict, hash => inMemTable.dict[hash]);
 }
 
 function loadByField(loadManager, persistence, operator, entityConfig, inMemoryStore, fieldName, fieldValueSchema, shouldGroup, item, fieldValue) {
@@ -238,7 +238,7 @@ function loadByField(loadManager, persistence, operator, entityConfig, inMemoryS
             break;
         }
         let entities = await storage.loadByFieldOrThrow(TableIndices.Index.getFieldName(index), fieldValueSchema, index.fieldValue, tmp, entityConfig.table, entityConfig.rowsSchema);
-        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, entity.id, entity, false));
+        entities.forEach(entity => InMemoryTable.Entity.initValue(inMemTable, inMemoryStore.committedCheckpointId, entity.id, entity));
         size.contents = size.contents + entities.length | 0;
         return;
       } catch (raw_exn) {