envio 3.15.0 → 3.16.0

package/src/FetchState.res.mjs

@@ -941,26 +941,47 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
+    blockThrottle: fetchState.blockThrottle,
     buffer: blockItems.length !== 0 ? mergeIntoBuffer(base, blockItems) : base,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
     onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: knownHeight,
     firstEventBlock: fetchState.firstEventBlock,
-    clientFilterAddressThreshold: fetchState.clientFilterAddressThreshold
+    clientFilterPolicy: fetchState.clientFilterPolicy
   };
 }
 
-function addClientFilteredContract(clientFilteredContracts, contractName, onNotice, addressCount, threshold, isAlreadyReportedOpt) {
+function switchToClientSideFiltering(clientFilteredContracts, contractNames, policy, dynamicContracts, addressStore, onNotice, isAlreadyReportedOpt) {
   let isAlreadyReported = isAlreadyReportedOpt !== undefined ? isAlreadyReportedOpt : false;
-  clientFilteredContracts.add(contractName);
-  if (!isAlreadyReported) {
-    return onNotice({
-      TAG: "SwitchedToClientSideFiltering",
-      contractName: contractName,
-      addressCount: addressCount,
-      threshold: threshold
-    });
-  }
+  let switched = new Set(Array.from(clientFilteredContracts));
+  contractNames.forEach(contractName => {
+    if (switched.has(contractName)) {
+      return;
+    }
+    if (policy.allDynamicContracts && dynamicContracts.has(contractName)) {
+      switched.add(contractName);
+      return;
+    }
+    let threshold = policy.addressThreshold;
+    if (threshold === undefined) {
+      return;
+    }
+    let addressCount = addressStore.contractCount(contractName);
+    if (addressCount > threshold) {
+      switched.add(contractName);
+      if (!isAlreadyReported) {
+        return onNotice({
+          TAG: "SwitchedToClientSideFiltering",
+          contractName: contractName,
+          addressCount: addressCount,
+          threshold: threshold
+        });
+      } else {
+        return;
+      }
+    }
+  });
+  return switched;
 }
 
 function claimedFetchedBlock(p, knownHeight) {
@@ -1362,20 +1383,7 @@ function registerDynamicContracts(fetchState, addressStore, onNotice, claimCeili
       }
     }
   }
-  let threshold = fetchState.clientFilterAddressThreshold;
-  let clientFilteredContracts;
-  if (threshold !== undefined) {
-    let clientFilteredContracts$1 = new Set(Array.from(fetchState.optimizedPartitions.clientFilteredContracts));
-    Array.from(dynamicContractsRef).forEach(contractName => {
-      let addressCount = addressStore.contractCount(contractName);
-      if (!clientFilteredContracts$1.has(contractName) && addressCount > threshold) {
-        return addClientFilteredContract(clientFilteredContracts$1, contractName, onNotice, addressCount, threshold, undefined);
-      }
-    });
-    clientFilteredContracts = clientFilteredContracts$1;
-  } else {
-    clientFilteredContracts = fetchState.optimizedPartitions.clientFilteredContracts;
-  }
+  let clientFilteredContracts = switchToClientSideFiltering(fetchState.optimizedPartitions.clientFilteredContracts, Array.from(dynamicContractsRef), fetchState.clientFilterPolicy, dynamicContractsRef, addressStore, onNotice, undefined);
   let registeringSetsByContract = {};
   registeringContractNames.forEach(contractName => {
     registeringSetsByContract[contractName] = AddressStore.makeSet(addressStore, contractName, {
@@ -1386,6 +1394,55 @@ function registerDynamicContracts(fetchState, addressStore, onNotice, claimCeili
   return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined, undefined);
 }
 
+function switchDynamicContractsToClientSideFiltering(fetchState, addressStore) {
+  if (fetchState.clientFilterPolicy.allDynamicContracts) {
+    return fetchState;
+  }
+  let init = fetchState.clientFilterPolicy;
+  let fetchState_optimizedPartitions = fetchState.optimizedPartitions;
+  let fetchState_startBlock = fetchState.startBlock;
+  let fetchState_endBlock = fetchState.endBlock;
+  let fetchState_normalSelection = fetchState.normalSelection;
+  let fetchState_chainId = fetchState.chainId;
+  let fetchState_latestOnBlockBlockNumber = fetchState.latestOnBlockBlockNumber;
+  let fetchState_blockLag = fetchState.blockLag;
+  let fetchState_blockThrottle = fetchState.blockThrottle;
+  let fetchState_buffer = fetchState.buffer;
+  let fetchState_maxOnBlockBufferSize = fetchState.maxOnBlockBufferSize;
+  let fetchState_onBlockRegistrations = fetchState.onBlockRegistrations;
+  let fetchState_knownHeight = fetchState.knownHeight;
+  let fetchState_firstEventBlock = fetchState.firstEventBlock;
+  let fetchState_clientFilterPolicy = {
+    addressThreshold: init.addressThreshold,
+    allDynamicContracts: true
+  };
+  let fetchState$1 = {
+    optimizedPartitions: fetchState_optimizedPartitions,
+    startBlock: fetchState_startBlock,
+    endBlock: fetchState_endBlock,
+    normalSelection: fetchState_normalSelection,
+    chainId: fetchState_chainId,
+    latestOnBlockBlockNumber: fetchState_latestOnBlockBlockNumber,
+    blockLag: fetchState_blockLag,
+    blockThrottle: fetchState_blockThrottle,
+    buffer: fetchState_buffer,
+    maxOnBlockBufferSize: fetchState_maxOnBlockBufferSize,
+    onBlockRegistrations: fetchState_onBlockRegistrations,
+    knownHeight: fetchState_knownHeight,
+    firstEventBlock: fetchState_firstEventBlock,
+    clientFilterPolicy: fetchState_clientFilterPolicy
+  };
+  let match = fetchState_optimizedPartitions;
+  let clientFilteredContracts = match.clientFilteredContracts;
+  let dynamicContracts = match.dynamicContracts;
+  let switched = new Set(Array.from(clientFilteredContracts).concat(Array.from(dynamicContracts)));
+  if (switched.size === clientFilteredContracts.size) {
+    return fetchState$1;
+  } else {
+    return updateInternal(fetchState$1, createPartitions({}, addressStore, dynamicContracts, switched, fetchState_normalSelection, match.maxAddrInPartition, match.nextPartitionIndex, Object.values(fetchState_optimizedPartitions.entities), 0, fetchState_knownHeight), undefined, undefined, undefined, undefined);
+  }
+}
+
 function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
   return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems.length, latestFetchedBlock), newItems.length !== 0 ? mergeIntoBuffer(fetchState.buffer, newItems) : undefined, true, undefined, undefined);
 }
@@ -1624,15 +1681,30 @@ function acceptCandidates(candidates, reservations, chainTargetItems, partitionI
   };
 }
 
-function getNextQuery(param, chainTargetBlock, chainTargetItems) {
-  let blockLag = param.blockLag;
+function blocksBehindHeadAllowedByThrottle(param) {
+  let blockThrottle = param.blockThrottle;
   let endBlock = param.endBlock;
-  let optimizedPartitions = param.optimizedPartitions;
-  let headBlockNumber = param.knownHeight - blockLag | 0;
+  if (endBlock !== undefined && (param.knownHeight - param.blockLag | 0) >= endBlock) {
+    return 0;
+  } else {
+    return Primitive_int.max(0, blockThrottle - 1 | 0);
+  }
+}
+
+function headFetchTarget(fetchState) {
+  return (fetchState.knownHeight - fetchState.blockLag | 0) - blocksBehindHeadAllowedByThrottle(fetchState) | 0;
+}
+
+function getNextQuery(fetchState, chainTargetBlock, chainTargetItems) {
+  let blockLag = fetchState.blockLag;
+  let endBlock = fetchState.endBlock;
+  let optimizedPartitions = fetchState.optimizedPartitions;
+  let headBlockNumber = fetchState.knownHeight - blockLag | 0;
   if (headBlockNumber <= 0) {
     return "WaitingForNewBlock";
   }
-  let isOnBlockBehindTheHead = param.latestOnBlockBlockNumber < headBlockNumber;
+  let caughtUpBlockNumber = headBlockNumber - blocksBehindHeadAllowedByThrottle(fetchState) | 0;
+  let isOnBlockBehindTheHead = fetchState.latestOnBlockBlockNumber < caughtUpBlockNumber;
   let shouldWaitForNewBlock = (
     endBlock !== undefined ? headBlockNumber < endBlock : true
   ) && !isOnBlockBehindTheHead;
@@ -1658,7 +1730,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems) {
       }
     }
     inFlightCounts[idx] = inFlightCount;
-    if (p.mutPendingQueries.length !== 0 || p.latestFetchedBlock < headBlockNumber) {
+    if (p.mutPendingQueries.length !== 0 || p.latestFetchedBlock < caughtUpBlockNumber) {
       shouldWaitForNewBlock = false;
     }
   }
@@ -1749,10 +1821,11 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addressRows, maxAddrInPartition, chainId, onNotice, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt, isResumedOpt) {
+function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addressRows, maxAddrInPartition, chainId, onNotice, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, blockThrottleOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt, isResumedOpt) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
+  let blockThrottle = blockThrottleOpt !== undefined ? blockThrottleOpt : 0;
   let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
   let clientFilterAddressThreshold = clientFilterAddressThresholdOpt !== undefined ? Primitive_option.valFromOption(clientFilterAddressThresholdOpt) : undefined;
   let isResumed = isResumedOpt !== undefined ? isResumedOpt : false;
@@ -1801,7 +1874,6 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     requestedFromBlock: rejected.effectiveStartBlock
   }));
   let dynamicContracts = new Set();
-  let clientFilteredContracts = new Set();
   let registeringSetsByContract = {};
   Array.from(contractNamesWithNormalEvents).forEach(contractName => {
     if (addressStore.contractCount(contractName) > 0) {
@@ -1815,14 +1887,11 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
       return;
     }
   });
-  if (clientFilterAddressThreshold !== undefined) {
-    Utils.Dict.forEachWithKey(registeringSetsByContract, (set, contractName) => {
-      let addressCount = set.size();
-      if (addressCount > clientFilterAddressThreshold) {
-        return addClientFilteredContract(clientFilteredContracts, contractName, onNotice, addressCount, clientFilterAddressThreshold, isResumed);
-      }
-    });
-  }
+  let clientFilterPolicy = {
+    addressThreshold: clientFilterAddressThreshold,
+    allDynamicContracts: false
+  };
+  let clientFilteredContracts = switchToClientSideFiltering(new Set(), Object.keys(registeringSetsByContract), clientFilterPolicy, dynamicContracts, addressStore, onNotice, isResumed);
   let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber, knownHeight);
   if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockRegistrations$1)) {
     Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + ChainId.toString(chainId) + `. ` + (`addresses=` + addressRows.addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
@@ -1853,12 +1922,13 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     chainId: chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
+    blockThrottle: blockThrottle,
     buffer: buffer,
     maxOnBlockBufferSize: maxOnBlockBufferSize,
     onBlockRegistrations: onBlockRegistrations$1,
     knownHeight: knownHeight,
     firstEventBlock: firstEventBlock,
-    clientFilterAddressThreshold: clientFilterAddressThreshold
+    clientFilterPolicy: clientFilterPolicy
   };
 }
 
@@ -1966,12 +2036,13 @@ function rollback(fetchState, rolledBackAddressStore, targetBlockNumber) {
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: Primitive_int.min(fetchState.latestOnBlockBlockNumber, targetBlockNumber),
     blockLag: fetchState.blockLag,
+    blockThrottle: fetchState.blockThrottle,
     buffer: fetchState.buffer,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
     onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock,
-    clientFilterAddressThreshold: fetchState.clientFilterAddressThreshold
+    clientFilterPolicy: fetchState.clientFilterPolicy
   }, optimizedPartitions, fetchState.buffer.filter(item => {
     let tmp;
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
@@ -2021,12 +2092,13 @@ function resetPendingQueries(fetchState) {
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
     blockLag: fetchState.blockLag,
+    blockThrottle: fetchState.blockThrottle,
     buffer: fetchState.buffer,
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
     onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock,
-    clientFilterAddressThreshold: fetchState.clientFilterAddressThreshold
+    clientFilterPolicy: fetchState.clientFilterPolicy
   };
 }
 
@@ -2044,21 +2116,37 @@ function isActivelyIndexing(fetchState) {
 }
 
 function isFetchingAtHead(fetchState) {
-  let knownHeight = fetchState.knownHeight;
-  let blockLag = fetchState.blockLag;
   let endBlock = fetchState.endBlock;
   let bufferBlockNumber$1 = bufferBlockNumber(fetchState);
-  if (knownHeight !== 0) {
+  if (fetchState.knownHeight !== 0) {
     if (endBlock !== undefined && bufferBlockNumber$1 >= endBlock) {
       return true;
     } else {
-      return bufferBlockNumber$1 >= (knownHeight - blockLag | 0);
+      return bufferBlockNumber$1 >= headFetchTarget(fetchState);
     }
   } else {
     return false;
   }
 }
 
+function isWithinHeadClientFilteringDistance(fetchState) {
+  let knownHeight = fetchState.knownHeight;
+  let endBlock = fetchState.endBlock;
+  let optimizedPartitions = fetchState.optimizedPartitions;
+  if (!(knownHeight !== 0 && (
+      endBlock !== undefined ? endBlock > (knownHeight - fetchState.blockLag | 0) : true
+    ))) {
+    return false;
+  }
+  let id = optimizedPartitions.idsInAscOrder[0];
+  let latestFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+  if (latestFetchedBlock !== undefined) {
+    return (headFetchTarget(fetchState) - latestFetchedBlock | 0) <= 200;
+  } else {
+    return true;
+  }
+}
+
 function isReadyToEnterReorgThreshold(tolerance, fetchState) {
   let knownHeight = fetchState.knownHeight;
   let endBlock = fetchState.endBlock;
@@ -2145,6 +2233,8 @@ let maxChainConcurrency = Env.maxChainConcurrency;
 
 let chunkRangeGrowthFactor = 1.8;
 
+let headClientFilteringDistance = 200;
+
 export {
   deriveSelectionStartBlock,
   makeSelection,
@@ -2168,12 +2258,13 @@ export {
   mergeIntoBuffer,
   appendOnBlockItems,
   updateInternal,
-  addClientFilteredContract,
+  switchToClientSideFiltering,
   claimedFetchedBlock,
   collapseClientFilteredContracts,
   reportRejectedRegistration,
   createPartitions,
   registerDynamicContracts,
+  switchDynamicContractsToClientSideFiltering,
   handleQueryResult,
   startFetchingQueries,
   maxInFlightChunksPerPartition,
@@ -2184,6 +2275,8 @@ export {
   walkPartitionPending,
   pushForwardCandidates,
   acceptCandidates,
+  blocksBehindHeadAllowedByThrottle,
+  headFetchTarget,
   getNextQuery,
   hasReadyItem,
   getReadyItemsCount,
@@ -2195,6 +2288,8 @@ export {
   resetPendingQueries,
   isActivelyIndexing,
   isFetchingAtHead,
+  headClientFilteringDistance,
+  isWithinHeadClientFilteringDistance,
   isReadyToEnterReorgThreshold,
   getProgressPercentage,
   sortForBatch,

package/src/FinalizeBackfill.res

@@ -40,7 +40,7 @@ let runOnce = async (state: IndexerState.t) => {
     let storage = persistence->Persistence.getInitializedStorageOrThrow
     let readyAt = Date.make()
 
-    await storage.finalizeBackfill(~entities=persistence.allEntities, ~chainIds, ~readyAt)
+    await storage.finalizeBackfill(~chainIds, ~readyAt)
 
     // Only after the commit: in-memory readiness must never run ahead of the
     // `ready_at` a restart would read back.
@@ -68,10 +68,8 @@ let run = (state: IndexerState.t) =>
 // Best-effort and not awaited by the loop: indexing is already live and correct
 // without the index, just slower.
 let repairSchemaIndexes = (state: IndexerState.t) => {
-  let persistence = state->IndexerState.persistence
-  let storage = persistence->Persistence.getInitializedStorageOrThrow
+  let storage = state->IndexerState.persistence->Persistence.getInitializedStorageOrThrow
   storage.ensureSchemaIndexes(
-    ~entities=persistence.allEntities,
     ~chainIds=state->IndexerState.crossChainState->CrossChainState.chainIds,
   )
 }

package/src/FinalizeBackfill.res.mjs

@@ -27,7 +27,7 @@ async function runOnce(state) {
   let persistence = IndexerState.persistence(state);
   let storage = Persistence.getInitializedStorageOrThrow(persistence);
   let readyAt = new Date();
-  await storage.finalizeBackfill(persistence.allEntities, chainIds, readyAt);
+  await storage.finalizeBackfill(chainIds, readyAt);
   return IndexerState.markReady(state, readyAt);
 }
 
@@ -42,9 +42,8 @@ function run(state) {
 }
 
 function repairSchemaIndexes(state) {
-  let persistence = IndexerState.persistence(state);
-  let storage = Persistence.getInitializedStorageOrThrow(persistence);
-  return storage.ensureSchemaIndexes(persistence.allEntities, CrossChainState.chainIds(IndexerState.crossChainState(state)));
+  let storage = Persistence.getInitializedStorageOrThrow(IndexerState.persistence(state));
+  return storage.ensureSchemaIndexes(CrossChainState.chainIds(IndexerState.crossChainState(state)));
 }
 
 export {

package/src/InMemoryTable.res

@@ -22,6 +22,8 @@ module Entity = {
   }
 
   type t = {
+    // Keys every id dict and Set below; see Table.table.
+    entityIdToKey: EntityId.t => string,
     latestEntityChangeById: dict<Change.t<Internal.entity>>,
     // Recorded changes (new latest ids + prevEntityChanges pushes), tracked
     // manually so InMemoryStore can gauge size without scanning every dict.
@@ -45,12 +47,9 @@ module Entity = {
     mutable hasIndexes: bool,
   }
 
-  // Helper to extract an entity's id as a dict key. The raw id may be a
-  // string/int/bigint, so it's stringified to a stable key for in-memory
-  // indexing.
-  let getEntityIdUnsafe = (entity: Internal.entity): string =>
+  let getEntityKeyUnsafe = (self: t, entity: Internal.entity): string =>
     switch (entity->(Utils.magic: Internal.entity => {"id": option<EntityId.t>}))["id"] {
-    | Some(id) => id->EntityId.toKey
+    | Some(id) => self.entityIdToKey(id)
     | None => JsError.throwWithMessage("Property 'id' does not exist on expected entity object")
     }
 
@@ -62,7 +61,8 @@ module Entity = {
     }
   }
 
-  let make = (): t => {
+  let make = (~entityIdToKey): t => {
+    entityIdToKey,
     latestEntityChangeById: Dict.make(),
     changesCount: 0.,
     dirtyIds: Utils.Set.make(),
@@ -141,10 +141,8 @@ module Entity = {
     self.hasIndexes = false
   }
 
-  let updateIndexes = (self: t, ~entity: Internal.entity) =>
+  let updateIndexes = (self: t, ~entityId: string, ~entity: Internal.entity) =>
     if self.hasIndexes {
-      let entityId = entity->getEntityIdUnsafe
-
       switch self.indexesByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
       | None => ()
       | Some(indexes) =>
@@ -185,7 +183,7 @@ module Entity = {
     }
 
   let set = (inMemTable: t, ~committedCheckpointId, change: Change.t<Internal.entity>) => {
-    let entityKey = change->Change.getEntityId->EntityId.toKey
+    let entityKey = inMemTable.entityIdToKey(change->Change.getEntityId)
     switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(entityKey) {
     | Some(prev) =>
       let prevCheckpointId = prev->Change.getCheckpointId
@@ -200,8 +198,8 @@ module Entity = {
     }
 
     switch change {
-    | Set({entity}) => inMemTable->updateIndexes(~entity)
-    | Delete({entityId}) => inMemTable->deleteEntityFromIndexes(~entityId=entityId->EntityId.toKey)
+    | Set({entity}) => inMemTable->updateIndexes(~entityId=entityKey, ~entity)
+    | Delete(_) => inMemTable->deleteEntityFromIndexes(~entityId=entityKey)
     }
     inMemTable.latestEntityChangeById->Dict.set(entityKey, change)
     if change->Change.getCheckpointId > committedCheckpointId {
@@ -214,11 +212,14 @@ module Entity = {
   let initValue = (
     inMemTable: t,
     ~committedCheckpointId,
-    ~key: string,
+    ~entityId: EntityId.t,
     ~entity: option<Internal.entity>,
   ) =>
-    if inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(key)->Option.isNone {
-      let entityId = key->EntityId.unsafeOfString
+    if (
+      inMemTable.latestEntityChangeById
+      ->Utils.Dict.dangerouslyGetNonOption(inMemTable.entityIdToKey(entityId))
+      ->Option.isNone
+    ) {
       let change: Change.t<Internal.entity> = switch entity {
       | Some(entity) => Set({entityId, entity, checkpointId: Internal.loadedFromDbCheckpointId})
       | None => Delete({entityId, checkpointId: Internal.loadedFromDbCheckpointId})
@@ -312,7 +313,7 @@ module Entity = {
         switch change->mapChangeToEntity {
         | Some(entity) =>
           if index.matcher(entity) {
-            inMemTable->addToIndex(~index, ~entityId=entity->getEntityIdUnsafe)
+            inMemTable->addToIndex(~index, ~entityId=inMemTable->getEntityKeyUnsafe(entity))
           }
         | None => ()
         }

package/src/InMemoryTable.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -9,10 +8,10 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
-function getEntityIdUnsafe(entity) {
+function getEntityKeyUnsafe(self, entity) {
   let id = entity.id;
   if (id !== undefined) {
-    return EntityId.toKey(Primitive_option.valFromOption(id));
+    return self.entityIdToKey(Primitive_option.valFromOption(id));
   } else {
     return Stdlib_JsError.throwWithMessage("Property 'id' does not exist on expected entity object");
   }
@@ -28,8 +27,9 @@ function addToIndex(self, index, entityId) {
   }
 }
 
-function make() {
+function make(entityIdToKey) {
   return {
+    entityIdToKey: entityIdToKey,
     latestEntityChangeById: {},
     changesCount: 0,
     dirtyIds: new Set(),
@@ -99,11 +99,10 @@ function dropCommittedChanges(self, committedCheckpointId, keepLoadedFromDb) {
   self.hasIndexes = false;
 }
 
-function updateIndexes(self, entity) {
+function updateIndexes(self, entityId, entity) {
   if (!self.hasIndexes) {
     return;
   }
-  let entityId = getEntityIdUnsafe(entity);
   let indexes = self.indexesByEntityId[entityId];
   if (indexes !== undefined) {
     let indexes$1 = Primitive_option.valFromOption(indexes);
@@ -144,7 +143,7 @@ function deleteEntityFromIndexes(self, entityId) {
 }
 
 function set(inMemTable, committedCheckpointId, change) {
-  let entityKey = EntityId.toKey(change.entityId);
+  let entityKey = inMemTable.entityIdToKey(change.entityId);
   let prev = inMemTable.latestEntityChangeById[entityKey];
   if (prev !== undefined) {
     let prevCheckpointId = prev.checkpointId;
@@ -156,9 +155,9 @@ function set(inMemTable, committedCheckpointId, change) {
     inMemTable.changesCount = inMemTable.changesCount + 1;
   }
   if (change.type === "SET") {
-    updateIndexes(inMemTable, change.entity);
+    updateIndexes(inMemTable, entityKey, change.entity);
   } else {
-    deleteEntityFromIndexes(inMemTable, EntityId.toKey(change.entityId));
+    deleteEntityFromIndexes(inMemTable, entityKey);
   }
   inMemTable.latestEntityChangeById[entityKey] = change;
   if (change.checkpointId > committedCheckpointId) {
@@ -167,18 +166,18 @@ function set(inMemTable, committedCheckpointId, change) {
   }
 }
 
-function initValue(inMemTable, committedCheckpointId, key, entity) {
-  if (!Stdlib_Option.isNone(inMemTable.latestEntityChangeById[key])) {
+function initValue(inMemTable, committedCheckpointId, entityId, entity) {
+  if (!Stdlib_Option.isNone(inMemTable.latestEntityChangeById[inMemTable.entityIdToKey(entityId)])) {
     return;
   }
   let change = entity !== undefined ? ({
       type: "SET",
-      entityId: key,
+      entityId: entityId,
       entity: entity,
       checkpointId: Internal.loadedFromDbCheckpointId
     }) : ({
       type: "DELETE",
-      entityId: key,
+      entityId: entityId,
       checkpointId: Internal.loadedFromDbCheckpointId
     });
   set(inMemTable, committedCheckpointId, change);
@@ -285,7 +284,7 @@ function addEmptyIndex(inMemTable, filter, table) {
   Utils.Dict.forEach(inMemTable.latestEntityChangeById, change => {
     let entity = mapChangeToEntity(change);
     if (entity !== undefined && index_matcher(entity)) {
-      return addToIndex(inMemTable, index, getEntityIdUnsafe(entity));
+      return addToIndex(inMemTable, index, getEntityKeyUnsafe(inMemTable, entity));
     }
   });
 }
@@ -321,7 +320,7 @@ function tryIndexFromLoadedValues(inMemTable, filter, table) {
 }
 
 let Entity = {
-  getEntityIdUnsafe: getEntityIdUnsafe,
+  getEntityKeyUnsafe: getEntityKeyUnsafe,
   addToIndex: addToIndex,
   make: make,
   snapshotChanges: snapshotChanges,