envio 3.5.0-alpha.2 → 3.5.0-alpha.3

package/src/FetchState.res.mjs

@@ -200,16 +200,92 @@ function ascSortFn(a, b) {
   return Primitive_int.compare(a.latestFetchedBlock.blockNumber, b.latestFetchedBlock.blockNumber);
 }
 
+function anchoredContracts(partitions) {
+  let set = new Set();
+  partitions.forEach(p => {
+    let match = p.mergeBlock;
+    let match$1 = p.selection.clientFilteredContracts;
+    if (match !== undefined || match$1 === undefined) {
+      return;
+    } else {
+      match$1.forEach(name => {
+        set.add(name);
+      });
+      return;
+    }
+  });
+  return set;
+}
+
+function getAnchorSafeBlock(p) {
+  let safeRef = {
+    contents: p.latestFetchedBlock.blockNumber
+  };
+  p.mutPendingQueries.forEach(pq => {
+    let match = safeRef.contents;
+    if (match === undefined) {
+      return;
+    }
+    let toBlock = pq.toBlock;
+    let match$1 = pq.fetchedBlock;
+    if (match$1 === undefined) {
+      if (toBlock !== undefined) {
+        if (toBlock > match) {
+          safeRef.contents = toBlock;
+          return;
+        } else {
+          return;
+        }
+      } else {
+        safeRef.contents = undefined;
+        return;
+      }
+    }
+    let blockNumber = match$1.blockNumber;
+    if (blockNumber > match) {
+      safeRef.contents = blockNumber;
+      return;
+    }
+  });
+  return safeRef.contents;
+}
+
 function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts, clientFilteredContracts) {
   let newPartitions = [];
   let mergingPartitions = {};
   let nextPartitionIndexRef = {
     contents: nextPartitionIndex
   };
+  let anchorSafeBlocks = {};
+  let anchoredContractsSet = new Set();
+  if (clientFilteredContracts.size > 0) {
+    partitions.forEach(p => {
+      let match = p.mergeBlock;
+      let match$1 = p.selection.clientFilteredContracts;
+      if (match !== undefined) {
+        return;
+      }
+      if (match$1 === undefined) {
+        return;
+      }
+      let safeBlock = getAnchorSafeBlock(p);
+      match$1.forEach(name => {
+        anchoredContractsSet.add(name);
+        if (safeBlock !== undefined) {
+          anchorSafeBlocks[name] = safeBlock;
+          return;
+        }
+      });
+    });
+  }
   for (let idx = 0, idx_finish = partitions.length; idx < idx_finish; ++idx) {
     let p = partitions[idx];
-    let exit = 0;
-    if (p.dynamicContract !== undefined && p.mergeBlock === undefined && p.selection.dependsOnAddresses) {
+    let mergeBlock = p.mergeBlock;
+    if (mergeBlock !== undefined) {
+      if (p.latestFetchedBlock.blockNumber < mergeBlock) {
+        newPartitions.push(p);
+      }
+    } else if (p.dynamicContract !== undefined && p.selection.dependsOnAddresses) {
       let contractName = p.dynamicContract;
       let pAddressesCount = p.addresses.countFor(contractName);
       let match = Utils.$$Array.last(p.mutPendingQueries);
@@ -236,9 +312,6 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
         newPartitions.push(p);
       }
     } else {
-      exit = 1;
-    }
-    if (exit === 1) {
       newPartitions.push(p);
     }
   }
@@ -276,12 +349,57 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
     };
     newPartitions.push(currentPRef);
   }
-  newPartitions.sort(ascSortFn);
-  let partitionsCount = newPartitions.length;
+  let finalPartitions;
+  if (anchoredContractsSet.size === 0) {
+    finalPartitions = newPartitions;
+  } else {
+    let anchored = [];
+    newPartitions.forEach(p => {
+      if (p.mergeBlock !== undefined) {
+        anchored.push(p);
+        return;
+      }
+      let contractName = p.dynamicContract;
+      if (contractName !== undefined) {
+        if (anchoredContractsSet.has(contractName)) {
+          let anchorSafeBlock = anchorSafeBlocks[contractName];
+          if (anchorSafeBlock !== undefined) {
+            if (p.latestFetchedBlock.blockNumber < anchorSafeBlock) {
+              anchored.push({
+                id: p.id,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: p.selection,
+                addresses: p.addresses,
+                mergeBlock: anchorSafeBlock,
+                dynamicContract: p.dynamicContract,
+                mutPendingQueries: p.mutPendingQueries,
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+              });
+              return;
+            } else {
+              return;
+            }
+          } else {
+            anchored.push(p);
+            return;
+          }
+        }
+        anchored.push(p);
+        return;
+      }
+      anchored.push(p);
+    });
+    finalPartitions = anchored;
+  }
+  finalPartitions.sort(ascSortFn);
+  let partitionsCount = finalPartitions.length;
   let idsInAscOrder = Array(partitionsCount);
   let entities = {};
   for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
-    let p$1 = newPartitions[idx$2];
+    let p$1 = finalPartitions[idx$2];
     idsInAscOrder[idx$2] = p$1.id;
     entities[p$1.id] = p$1;
   }
@@ -475,6 +593,8 @@ let OptimizedPartitions = {
   mergePartitionsAtBlock: mergePartitionsAtBlock,
   tooFarBlockRange: 20000,
   ascSortFn: ascSortFn,
+  anchoredContracts: anchoredContracts,
+  getAnchorSafeBlock: getAnchorSafeBlock,
   make: make,
   consumeFetchedQueries: consumeFetchedQueries,
   getPendingQueryOrThrow: getPendingQueryOrThrow,
@@ -683,14 +803,17 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
   };
 }
 
-function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold) {
+function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold, shouldLogOpt) {
+  let shouldLog = shouldLogOpt !== undefined ? shouldLogOpt : true;
   clientFilteredContracts.add(contractName);
-  Logging.childTrace(Logging.createChild({
-    chainId: chainId,
-    contractName: contractName,
-    addressCount: addressCount,
-    threshold: threshold
-  }), "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.");
+  if (shouldLog) {
+    return Logging.childTrace(Logging.createChild({
+      chainId: chainId,
+      contractName: contractName,
+      addressCount: addressCount,
+      threshold: threshold
+    }), "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.");
+  }
 }
 
 function claimedFetchedBlock(p, knownHeight) {
@@ -700,7 +823,8 @@ function claimedFetchedBlock(p, knownHeight) {
   });
 }
 
-function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, knownHeight) {
+function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, clientFilteredFrontiersOpt, knownHeight) {
+  let clientFilteredFrontiers = clientFilteredFrontiersOpt !== undefined ? clientFilteredFrontiersOpt : [];
   if (clientFilteredContracts.size === 0) {
     return partitions;
   }
@@ -711,6 +835,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   let backfills = [];
   let absorbedPartitions = [];
   let strippedFrontiers = [];
+  let anchoredContracts$1 = anchoredContracts(partitions);
   partitions.forEach(p => {
     if (!p.selection.dependsOnAddresses) {
       if (p.mergeBlock !== undefined) {
@@ -726,6 +851,11 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
     let serverSideNames = contractNames.filter(c => !clientFilteredContracts.has(c));
     if (serverSideNames.length === contractNames.length) {
       kept.push(p);
+      return;
+    }
+    let contractName = p.dynamicContract;
+    if (contractName !== undefined ? anchoredContracts$1.has(contractName) : false) {
+      kept.push(p);
     } else if (Utils.$$Array.isEmpty(serverSideNames)) {
       absorbedPartitions.push(p);
     } else {
@@ -735,7 +865,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   });
   let standing = standingRef.contents;
   let selectionChanged = standing !== undefined ? Stdlib_Option.mapOr(standing.selection.clientFilteredContracts, 0, prim => prim.length) !== clientFilteredContracts.size : true;
-  if (Utils.$$Array.isEmpty(absorbedPartitions) && Utils.$$Array.isEmpty(strippedFrontiers) && !selectionChanged) {
+  if (Utils.$$Array.isEmpty(absorbedPartitions) && Utils.$$Array.isEmpty(strippedFrontiers) && Utils.$$Array.isEmpty(clientFilteredFrontiers) && !selectionChanged) {
     return partitions;
   }
   let minFrontierRef = {
@@ -753,6 +883,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   absorbedPartitions.forEach(p => considerFrontier(p.latestFetchedBlock));
   backfills.forEach(p => considerFrontier(p.latestFetchedBlock));
   strippedFrontiers.forEach(considerFrontier);
+  clientFilteredFrontiers.forEach(considerFrontier);
   let regByIndex = {};
   let addRegs = regs => {
     regs.forEach(reg => {
@@ -849,59 +980,72 @@ function createPartitions(registeringSetsByContract, addressStore, dynamicContra
   };
   let dynamicPartitions = [];
   let nonDynamicPartitions = [];
+  let clientFilteredFrontiers = [];
+  let anchoredContracts$1 = anchoredContracts(existingPartitions);
   let contractNames = Object.keys(registeringSetsByContract);
   for (let cIdx = 0, cIdx_finish = contractNames.length; cIdx < cIdx_finish; ++cIdx) {
     let contractName = contractNames[cIdx];
     let contractSet = registeringSetsByContract[contractName];
-    let isDynamic = dynamicContracts.has(contractName);
+    let isAnchored = anchoredContracts$1.has(contractName);
+    let isDynamic = dynamicContracts.has(contractName) || isAnchored;
     let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
     let groups = contractSet.startBlockGroups();
-    let offsetRef = 0;
-    let groupIdx = 0;
-    while (groupIdx < groups.length) {
-      let startBlock = groups[groupIdx].startBlock;
-      let countRef = 0;
-      let nextIdx = groupIdx;
-      let joining = true;
-      while (joining && nextIdx < groups.length) {
-        let group = groups[nextIdx];
-        if ((group.startBlock - startBlock | 0) < 20000) {
-          countRef = countRef + group.count | 0;
-          nextIdx = nextIdx + 1 | 0;
-        } else {
-          joining = false;
-        }
-      };
-      let latestFetchedBlock_blockNumber = Primitive_int.max(startBlock - 1 | 0, progressBlockNumber);
-      let latestFetchedBlock = {
-        blockNumber: latestFetchedBlock_blockNumber,
-        blockTimestamp: 0
-      };
-      let remainingRef = countRef;
-      let chunkOffsetRef = offsetRef;
-      while (remainingRef > 0) {
-        let take = Primitive_int.min(remainingRef, maxAddrInPartition);
-        let pAddresses = contractSet.slice(chunkOffsetRef, take);
-        partitions.push({
-          id: nextPartitionIndexRef.contents.toString(),
-          latestFetchedBlock: latestFetchedBlock,
-          selection: normalSelection,
-          addresses: pAddresses,
-          mergeBlock: undefined,
-          dynamicContract: isDynamic ? contractName : undefined,
-          mutPendingQueries: [],
-          sourceRangeCapacity: 0,
-          prevSourceRangeCapacity: 0,
-          eventDensity: undefined,
-          latestSourceRangeCapacityUpdateBlock: 0
+    if (clientFilteredContracts.has(contractName) && !isAnchored) {
+      let match = groups[0];
+      if (match !== undefined) {
+        clientFilteredFrontiers.push({
+          blockNumber: Primitive_int.max(match.startBlock - 1 | 0, progressBlockNumber),
+          blockTimestamp: 0
         });
-        nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
-        chunkOffsetRef = chunkOffsetRef + take | 0;
-        remainingRef = remainingRef - take | 0;
+      }
+    } else {
+      let offsetRef = 0;
+      let groupIdx = 0;
+      while (groupIdx < groups.length) {
+        let startBlock = groups[groupIdx].startBlock;
+        let countRef = 0;
+        let nextIdx = groupIdx;
+        let joining = true;
+        while (joining && nextIdx < groups.length) {
+          let group = groups[nextIdx];
+          if ((group.startBlock - startBlock | 0) < 20000) {
+            countRef = countRef + group.count | 0;
+            nextIdx = nextIdx + 1 | 0;
+          } else {
+            joining = false;
+          }
+        };
+        let latestFetchedBlock_blockNumber = Primitive_int.max(startBlock - 1 | 0, progressBlockNumber);
+        let latestFetchedBlock = {
+          blockNumber: latestFetchedBlock_blockNumber,
+          blockTimestamp: 0
+        };
+        let remainingRef = countRef;
+        let chunkOffsetRef = offsetRef;
+        while (remainingRef > 0) {
+          let take = Primitive_int.min(remainingRef, maxAddrInPartition);
+          let pAddresses = contractSet.slice(chunkOffsetRef, take);
+          partitions.push({
+            id: nextPartitionIndexRef.contents.toString(),
+            latestFetchedBlock: latestFetchedBlock,
+            selection: normalSelection,
+            addresses: pAddresses,
+            mergeBlock: undefined,
+            dynamicContract: isDynamic ? contractName : undefined,
+            mutPendingQueries: [],
+            sourceRangeCapacity: 0,
+            prevSourceRangeCapacity: 0,
+            eventDensity: undefined,
+            latestSourceRangeCapacityUpdateBlock: 0
+          });
+          nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+          chunkOffsetRef = chunkOffsetRef + take | 0;
+          remainingRef = remainingRef - take | 0;
+        };
+        offsetRef = offsetRef + countRef | 0;
+        groupIdx = nextIdx;
       };
-      offsetRef = offsetRef + countRef | 0;
-      groupIdx = nextIdx;
-    };
+    }
   }
   let mergedNonDynamic = [];
   if (nonDynamicPartitions.length !== 0) {
@@ -944,7 +1088,7 @@ function createPartitions(registeringSetsByContract, addressStore, dynamicContra
     mergedNonDynamic.push(currentPRef);
   }
   let mergedPartitions = mergedNonDynamic.concat(dynamicPartitions);
-  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, knownHeight);
+  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, clientFilteredFrontiers, knownHeight);
   return make(allPartitions, maxAddrInPartition, nextPartitionIndexRef.contents, dynamicContracts, clientFilteredContracts);
 }
 
@@ -1097,7 +1241,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
     Array.from(dynamicContractsRef).forEach(contractName => {
       let addressCount = addressStore.contractCount(contractName);
       if (!clientFilteredContracts$1.has(contractName) && addressCount > threshold) {
-        return addClientFilteredContract(clientFilteredContracts$1, contractName, fetchState.chainId, addressCount, threshold);
+        return addClientFilteredContract(clientFilteredContracts$1, contractName, fetchState.chainId, addressCount, threshold, undefined);
       }
     });
     clientFilteredContracts = clientFilteredContracts$1;
@@ -1482,12 +1626,13 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt) {
+function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt, isResumedOpt) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 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;
   let latestFetchedBlock = {
     blockNumber: progressBlockNumber,
     blockTimestamp: 0
@@ -1552,7 +1697,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     Utils.Dict.forEachWithKey(registeringSetsByContract, (set, contractName) => {
       let addressCount = set.size();
       if (addressCount > clientFilterAddressThreshold) {
-        return addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, clientFilterAddressThreshold);
+        return addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, clientFilterAddressThreshold, !isResumed);
       }
     });
   }
@@ -1669,6 +1814,7 @@ function rollback(fetchState, addressStore, targetBlockNumber) {
     } else {
       let id$1 = nextKeptIdRef.toString();
       nextKeptIdRef = nextKeptIdRef + 1 | 0;
+      let mergeBlock$2 = p.mergeBlock;
       keptPartitions.push({
         id: id$1,
         latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber ? ({
@@ -1677,7 +1823,7 @@ function rollback(fetchState, addressStore, targetBlockNumber) {
           }) : p.latestFetchedBlock,
         selection: p.selection,
         addresses: p.addresses,
-        mergeBlock: p.mergeBlock,
+        mergeBlock: mergeBlock$2 !== undefined && mergeBlock$2 > targetBlockNumber ? targetBlockNumber : mergeBlock$2,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
         sourceRangeCapacity: p.sourceRangeCapacity,

package/src/FinalizeBackfill.res

@@ -0,0 +1,34 @@
+// The FinalizingIndexes phase. Runs once, from the processing loop, when every
+// chain has caught up: processing is already paused (the loop awaits this),
+// pending writes are flushed, then storage creates every missing schema-defined
+// index and stamps `ready_at` in one transaction. A failure rolls back both, so
+// the next batch simply retries — the indexer never reports ready with an index
+// the schema promised still missing.
+
+let run = async (state: IndexerState.t) => {
+  Logging.info(
+    "All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.",
+  )
+
+  await Writing.flush(state)
+
+  // A failed write already surfaced through onError; committing ready_at on top
+  // of an incomplete write would claim progress that isn't durable.
+  if !(state->IndexerState.hasFailedWrite) {
+    let persistence = state->IndexerState.persistence
+    let storage = persistence->Persistence.getInitializedStorageOrThrow
+    let readyAt = Date.make()
+
+    await storage.finalizeBackfill(
+      ~entities=persistence.allEntities,
+      ~chainIds=state
+      ->IndexerState.chainStates
+      ->Dict.valuesToArray
+      ->Array.map(cs => (cs->ChainState.chainConfig).id),
+      ~readyAt,
+    )
+
+    state->IndexerState.markReady(~readyAt)
+    Logging.info("The indexer is ready. Switching to realtime indexing.")
+  }
+}

package/src/FinalizeBackfill.res.mjs

@@ -0,0 +1,26 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logging from "./Logging.res.mjs";
+import * as Writing from "./Writing.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as Persistence from "./Persistence.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
+
+async function run(state) {
+  Logging.info("All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.");
+  await Writing.flush(state);
+  if (IndexerState.hasFailedWrite(state)) {
+    return;
+  }
+  let persistence = IndexerState.persistence(state);
+  let storage = Persistence.getInitializedStorageOrThrow(persistence);
+  let readyAt = new Date();
+  await storage.finalizeBackfill(persistence.allEntities, Object.values(IndexerState.chainStates(state)).map(cs => ChainState.chainConfig(cs).id), readyAt);
+  IndexerState.markReady(state, readyAt);
+  return Logging.info("The indexer is ready. Switching to realtime indexing.");
+}
+
+export {
+  run,
+}
+/* Logging Not a pure module */

package/src/InMemoryTable.res

@@ -2,7 +2,7 @@ module Entity = {
   type relatedEntityId = string
   type filterWithRelatedIds = (EntityFilter.t, Utils.Set.t<relatedEntityId>)
   // Keyed by EntityFilter.toString
-  type filterIndices = dict<filterWithRelatedIds>
+  type filterIndexes = dict<filterWithRelatedIds>
 
   type entityFilters = Utils.Set.t<EntityFilter.t>
   type t = {
@@ -14,7 +14,7 @@ module Entity = {
     // previous changes persist in the background.
     mutable prevEntityChanges: array<Change.t<Internal.entity>>,
     mutable filtersByEntityId: dict<entityFilters>,
-    mutable filterIndices: filterIndices,
+    mutable filterIndexes: filterIndexes,
   }
 
   // Helper to extract an entity's id as a dict key. The raw id may be a
@@ -44,7 +44,7 @@ module Entity = {
     changesCount: 0.,
     prevEntityChanges: [],
     filtersByEntityId: Dict.make(),
-    filterIndices: Dict.make(),
+    filterIndexes: Dict.make(),
   }
 
   // Changes to persist for checkpoints in (committedCheckpointId, upToCheckpointId].
@@ -81,7 +81,7 @@ module Entity = {
   }
 
   // Frees committed changes: drops latest entries at or below committedCheckpointId
-  // (re-readable from the db) and clears the per-batch indices (rebuilt on the next
+  // (re-readable from the db) and clears the per-batch indexes (rebuilt on the next
   // getWhere). Uncommitted changes are kept. With keepLoadedFromDb, entries seeded
   // from a db read are spared so the cheaper-to-re-derive writes are dropped first.
   let dropCommittedChanges = (self: t, ~committedCheckpointId, ~keepLoadedFromDb) => {
@@ -98,10 +98,10 @@ module Entity = {
     keysToDelete->Array.forEach(key => self.latestEntityChangeById->Utils.Dict.deleteInPlace(key))
     self.changesCount = self.changesCount -. keysToDelete->Array.length->Int.toFloat
     self.filtersByEntityId = Dict.make()
-    self.filterIndices = Dict.make()
+    self.filterIndexes = Dict.make()
   }
 
-  let updateIndices = (self: t, ~entity: Internal.entity) => {
+  let updateIndexes = (self: t, ~entity: Internal.entity) => {
     let entityId = entity->getEntityIdUnsafe
     let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
 
@@ -116,7 +116,7 @@ module Entity = {
       })
     }
 
-    self.filterIndices->Utils.Dict.forEach(((filter, relatedEntityIds)) => {
+    self.filterIndexes->Utils.Dict.forEach(((filter, relatedEntityIds)) => {
       if filter->EntityFilter.matches(~entity=entityAsDict) {
         //Add entity id to the filter index and the filter to entity filters
         relatedEntityIds->Utils.Set.add(entityId)->ignore
@@ -127,12 +127,12 @@ module Entity = {
     })
   }
 
-  let deleteEntityFromIndices = (self: t, ~entityId: string) =>
+  let deleteEntityFromIndexes = (self: t, ~entityId: string) =>
     switch self.filtersByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
     | None => ()
     | Some(entityFilters) =>
       entityFilters->Utils.Set.forEach(filter => {
-        switch self.filterIndices->Utils.Dict.dangerouslyGetNonOption(
+        switch self.filterIndexes->Utils.Dict.dangerouslyGetNonOption(
           filter->EntityFilter.toString,
         ) {
         | Some((_filter, relatedEntityIds)) =>
@@ -159,8 +159,8 @@ module Entity = {
     }
 
     switch change {
-    | Set({entity}) => inMemTable->updateIndices(~entity)
-    | Delete({entityId}) => inMemTable->deleteEntityFromIndices(~entityId=entityId->EntityId.toKey)
+    | Set({entity}) => inMemTable->updateIndexes(~entity)
+    | Delete({entityId}) => inMemTable->deleteEntityFromIndexes(~entityId=entityId->EntityId.toKey)
     }
     inMemTable.latestEntityChangeById->Dict.set(entityKey, change)
   }
@@ -200,12 +200,12 @@ module Entity = {
 
   let hasIndex = (inMemTable: t) =>
     (filterKey: string) =>
-      inMemTable.filterIndices->Utils.Dict.dangerouslyGetNonOption(filterKey) !== None
+      inMemTable.filterIndexes->Utils.Dict.dangerouslyGetNonOption(filterKey) !== None
 
   let getUnsafeOnIndex = (inMemTable: t) => {
     let getEntity = inMemTable->getUnsafe
     (filterKey: string) => {
-      switch inMemTable.filterIndices->Utils.Dict.dangerouslyGetNonOption(filterKey) {
+      switch inMemTable.filterIndexes->Utils.Dict.dangerouslyGetNonOption(filterKey) {
       | None =>
         JsError.throwWithMessage(`Unexpected error. Must have an index for the filter ${filterKey}`)
       | Some((_filter, relatedEntityIds)) =>
@@ -223,7 +223,7 @@ module Entity = {
 
   let addEmptyIndex = (inMemTable: t, ~filter: EntityFilter.t) => {
     let filterKey = filter->EntityFilter.toString
-    switch inMemTable.filterIndices->Utils.Dict.dangerouslyGetNonOption(filterKey) {
+    switch inMemTable.filterIndexes->Utils.Dict.dangerouslyGetNonOption(filterKey) {
     | Some(_) => () //Should not happen, this means the index already exists
     | None =>
       let relatedEntityIds = Utils.Set.make()
@@ -240,7 +240,7 @@ module Entity = {
         | None => ()
         }
       })
-      inMemTable.filterIndices->Dict.set(filterKey, (filter, relatedEntityIds))
+      inMemTable.filterIndexes->Dict.set(filterKey, (filter, relatedEntityIds))
     }
   }
 }