envio 3.5.0-alpha.1 → 3.5.0-alpha.3

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/HandlerRegister.res

@@ -215,6 +215,25 @@ let mergeRegistrations = (resolved: array<Internal.onEventRegistration>, ~config
 let isDroppedByWhere = (~config: Config.t, reg: Internal.onEventRegistration) =>
   config.ecosystem.name === Evm && (reg->getResolvedWhere).topicSelections->Utils.Array.isEmpty
 
+// Names configured across every chain, used to explain a registration that
+// matched nothing. Only built on the failure path.
+let describeConfigured = (registration: activeRegistration, ~contractName) => {
+  let contractNames = Utils.Set.make()
+  let eventNames = Utils.Set.make()
+  registration.config.chainMap
+  ->ChainMap.values
+  ->Array.forEach(chainConfig =>
+    chainConfig.contracts->Array.forEach(contract => {
+      contractNames->Utils.Set.add(contract.name)->ignore
+      if contract.name === contractName {
+        contract.events->Array.forEach(e => eventNames->Utils.Set.add(e.name)->ignore)
+      }
+    })
+  )
+  let sorted = set => set->Utils.Set.toArray->Array.toSorted(String.compare)
+  (sorted(contractNames), sorted(eventNames))
+}
+
 // Resolve one `onEvent`/`contractRegister` call into a registration for every
 // chain in the config (the full chain set) and store it in registration order.
 // Building runs the user's `where` callback here — once per chain — so a broken
@@ -230,6 +249,7 @@ let addOnEventRegistration = (
 ) => {
   let isWildcard = eventOptions->Option.flatMap(v => v.wildcard)->Option.getOr(false)
   let where = eventOptions->Option.flatMap(v => v.where)
+  let matched = ref(false)
   registration.config.chainMap
   ->ChainMap.values
   ->Array.forEach(chainConfig =>
@@ -239,6 +259,7 @@ let addOnEventRegistration = (
       switch contract.events->Array.find(e => e.name === eventName) {
       | None => ()
       | Some(eventConfig) =>
+        matched := true
         let reg = buildOnEventRegistrationWith(
           ~config=registration.config,
           ~chainId=chainConfig.id,
@@ -255,6 +276,30 @@ let addOnEventRegistration = (
       }
     }
   )
+
+  // Nothing matched on any chain, so the callback could never be dispatched.
+  // Reported at the registration call site, where the stack still points at the
+  // offending `onEvent`/`contractRegister`.
+  if !matched.contents {
+    let (contractNames, eventNames) = registration->describeConfigured(~contractName)
+    let listOr = (names, empty) =>
+      names->Utils.Array.isEmpty ? empty : names->Array.joinUnsafe(", ")
+    if eventNames->Utils.Array.isEmpty {
+      JsError.throwWithMessage(
+        `Contract "${contractName}" is not configured on any chain, so its handler for "${eventName}" would never run. Add it to your config, or remove the registration. Configured contracts: ${listOr(
+            contractNames,
+            "none",
+          )}.`,
+      )
+    } else {
+      JsError.throwWithMessage(
+        `Event "${eventName}" is not configured on contract "${contractName}", so its handler would never run. Add it to your config, or remove the registration. Configured events on "${contractName}": ${listOr(
+            eventNames,
+            "none",
+          )}.`,
+      )
+    }
+  }
 }
 
 let setHandler = (~contractName, ~eventName, handler, ~eventOptions) => {

package/src/HandlerRegister.res.mjs

@@ -8,6 +8,7 @@ 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_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -145,9 +146,33 @@ function isDroppedByWhere(config, reg) {
   }
 }
 
+function describeConfigured(registration, contractName) {
+  let contractNames = new Set();
+  let eventNames = new Set();
+  ChainMap.values(registration.config.chainMap).forEach(chainConfig => {
+    chainConfig.contracts.forEach(contract => {
+      contractNames.add(contract.name);
+      if (contract.name === contractName) {
+        contract.events.forEach(e => {
+          eventNames.add(e.name);
+        });
+        return;
+      }
+    });
+  });
+  let sorted = set => Array.from(set).toSorted(Primitive_string.compare);
+  return [
+    sorted(contractNames),
+    sorted(eventNames)
+  ];
+}
+
 function addOnEventRegistration(registration, contractName, eventName, handler, contractRegister, eventOptions) {
   let isWildcard = Stdlib_Option.getOr(Stdlib_Option.flatMap(eventOptions, v => v.wildcard), false);
   let where = Stdlib_Option.flatMap(eventOptions, v => v.where);
+  let matched = {
+    contents: false
+  };
   ChainMap.values(registration.config.chainMap).forEach(chainConfig => {
     let contract = chainConfig.contracts.find(c => c.name === contractName);
     if (contract === undefined) {
@@ -157,9 +182,27 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
     if (eventConfig === undefined) {
       return;
     }
+    matched.contents = true;
     let reg = buildOnEventRegistrationWith(registration.config, chainConfig.id, eventConfig, isWildcard, handler, contractRegister, where, contract.startBlock);
     getChainRegistrations(registration, chainConfig.id).onEventRegistrations.push(reg);
   });
+  if (matched.contents) {
+    return;
+  }
+  let match = describeConfigured(registration, contractName);
+  let eventNames = match[1];
+  let listOr = (names, empty) => {
+    if (Utils.$$Array.isEmpty(names)) {
+      return empty;
+    } else {
+      return names.join(", ");
+    }
+  };
+  if (Utils.$$Array.isEmpty(eventNames)) {
+    return Stdlib_JsError.throwWithMessage(`Contract "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured contracts: ` + listOr(match[0], "none") + `.`);
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Event "` + eventName + `" is not configured on contract "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured events on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
+  }
 }
 
 function setHandler(contractName, eventName, handler, eventOptions) {

package/src/InMemoryStore.res

@@ -45,7 +45,10 @@ let setEffectOutput = (
   | Some(_) => ()
   | None => inMemTable.changesCount = inMemTable.changesCount +. 1.
   }
-  inMemTable.dict->Dict.set(cacheKey, Set({entityId: cacheKey, entity: output, checkpointId}))
+  inMemTable.dict->Dict.set(
+    cacheKey,
+    Set({entityId: cacheKey->EntityId.unsafeOfString, entity: output, checkpointId}),
+  )
   if shouldCache {
     inMemTable.idsToStore->Array.push(cacheKey)->ignore
   }
@@ -58,7 +61,11 @@ let initEffectOutputFromDb = (inMemTable: EffectState.effectCacheInMemTable, ~ca
     inMemTable.changesCount = inMemTable.changesCount +. 1.
     inMemTable.dict->Dict.set(
       cacheKey,
-      Set({entityId: cacheKey, entity: output, checkpointId: Internal.loadedFromDbCheckpointId}),
+      Set({
+        entityId: cacheKey->EntityId.unsafeOfString,
+        entity: output,
+        checkpointId: Internal.loadedFromDbCheckpointId,
+      }),
     )
   }
 
@@ -131,7 +138,7 @@ let prepareRollbackDiff = async (
       entityTable->InMemoryTable.Entity.set(
         ~committedCheckpointId,
         Set({
-          entityId: entity.id,
+          entityId: entity.id->EntityId.unsafeOfString,
           checkpointId: rollbackDiffCheckpointId,
           entity,
         }),
@@ -177,7 +184,7 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
           inMemTable->InMemoryTable.Entity.set(
             ~committedCheckpointId,
             Set({
-              entityId: entity.id,
+              entityId: entity.id->EntityId.unsafeOfString,
               checkpointId,
               entity: entity->InternalTable.EnvioAddresses.castToInternal,
             }),

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,14 +14,16 @@ 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 entity ID from any entity
+  // 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.
   exception UnexpectedIdNotDefinedOnEntity
   let getEntityIdUnsafe = (entity: Internal.entity): string =>
-    switch (entity->(Utils.magic: Internal.entity => {"id": option<string>}))["id"] {
-    | Some(id) => id
+    switch (entity->(Utils.magic: Internal.entity => {"id": option<EntityId.t>}))["id"] {
+    | Some(id) => id->EntityId.toKey
     | None =>
       UnexpectedIdNotDefinedOnEntity->ErrorHandling.mkLogAndRaise(
         ~msg="Property 'id' does not exist on expected entity object",
@@ -42,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].
@@ -79,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) => {
@@ -96,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>)
 
@@ -114,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
@@ -125,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)) =>
@@ -142,8 +144,8 @@ module Entity = {
     }
 
   let set = (inMemTable: t, ~committedCheckpointId, change: Change.t<Internal.entity>) => {
-    let entityId = change->Change.getEntityId
-    switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(entityId) {
+    let entityKey = change->Change.getEntityId->EntityId.toKey
+    switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(entityKey) {
     | Some(prev) =>
       let prevCheckpointId = prev->Change.getCheckpointId
       if (
@@ -157,10 +159,10 @@ module Entity = {
     }
 
     switch change {
-    | Set({entity}) => inMemTable->updateIndices(~entity)
-    | Delete({entityId}) => inMemTable->deleteEntityFromIndices(~entityId)
+    | Set({entity}) => inMemTable->updateIndexes(~entity)
+    | Delete({entityId}) => inMemTable->deleteEntityFromIndexes(~entityId=entityId->EntityId.toKey)
     }
-    inMemTable.latestEntityChangeById->Dict.set(entityId, change)
+    inMemTable.latestEntityChangeById->Dict.set(entityKey, change)
   }
 
   // Only writes when the id isn't already present, so set always takes its
@@ -172,10 +174,10 @@ module Entity = {
     ~entity: option<Internal.entity>,
   ) =>
     if inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(key)->Option.isNone {
+      let entityId = key->EntityId.unsafeOfString
       let change: Change.t<Internal.entity> = switch entity {
-      | Some(entity) =>
-        Set({entityId: key, entity, checkpointId: Internal.loadedFromDbCheckpointId})
-      | None => Delete({entityId: key, checkpointId: Internal.loadedFromDbCheckpointId})
+      | Some(entity) => Set({entityId, entity, checkpointId: Internal.loadedFromDbCheckpointId})
+      | None => Delete({entityId, checkpointId: Internal.loadedFromDbCheckpointId})
       }
       inMemTable->set(~committedCheckpointId, change)
     }
@@ -198,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)) =>
@@ -221,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()
@@ -238,7 +240,7 @@ module Entity = {
         | None => ()
         }
       })
-      inMemTable.filterIndices->Dict.set(filterKey, (filter, relatedEntityIds))
+      inMemTable.filterIndexes->Dict.set(filterKey, (filter, relatedEntityIds))
     }
   }
 }

package/src/InMemoryTable.res.mjs

@@ -1,6 +1,7 @@
 // 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";
@@ -15,7 +16,7 @@ let UnexpectedIdNotDefinedOnEntity = /* @__PURE__ */Primitive_exceptions.create(
 function getEntityIdUnsafe(entity) {
   let id = entity.id;
   if (id !== undefined) {
-    return id;
+    return EntityId.toKey(Primitive_option.valFromOption(id));
   } else {
     return ErrorHandling.mkLogAndRaise(undefined, "Property 'id' does not exist on expected entity object", {
       RE_EXN_ID: UnexpectedIdNotDefinedOnEntity
@@ -39,7 +40,7 @@ function make() {
     changesCount: 0,
     prevEntityChanges: [],
     filtersByEntityId: {},
-    filterIndices: {}
+    filterIndexes: {}
   };
 }
 
@@ -83,10 +84,10 @@ function dropCommittedChanges(self, committedCheckpointId, keepLoadedFromDb) {
   keysToDelete.forEach(key => Utils.Dict.deleteInPlace(self.latestEntityChangeById, key));
   self.changesCount = self.changesCount - keysToDelete.length;
   self.filtersByEntityId = {};
-  self.filterIndices = {};
+  self.filterIndexes = {};
 }
 
-function updateIndices(self, entity) {
+function updateIndexes(self, entity) {
   let entityId = getEntityIdUnsafe(entity);
   let entityFilters = self.filtersByEntityId[entityId];
   if (entityFilters !== undefined) {
@@ -98,7 +99,7 @@ function updateIndices(self, entity) {
       }
     });
   }
-  Utils.Dict.forEach(self.filterIndices, param => {
+  Utils.Dict.forEach(self.filterIndexes, param => {
     let relatedEntityIds = param[1];
     let filter = param[0];
     if (EntityFilter.matches(filter, entity)) {
@@ -110,14 +111,14 @@ function updateIndices(self, entity) {
   });
 }
 
-function deleteEntityFromIndices(self, entityId) {
+function deleteEntityFromIndexes(self, entityId) {
   let entityFilters = self.filtersByEntityId[entityId];
   if (entityFilters === undefined) {
     return;
   }
   let entityFilters$1 = Primitive_option.valFromOption(entityFilters);
   entityFilters$1.forEach(filter => {
-    let match = self.filterIndices[EntityFilter.toString(filter)];
+    let match = self.filterIndexes[EntityFilter.toString(filter)];
     if (match !== undefined) {
       match[1].delete(entityId);
     }
@@ -126,8 +127,8 @@ function deleteEntityFromIndices(self, entityId) {
 }
 
 function set(inMemTable, committedCheckpointId, change) {
-  let entityId = change.entityId;
-  let prev = inMemTable.latestEntityChangeById[entityId];
+  let entityKey = EntityId.toKey(change.entityId);
+  let prev = inMemTable.latestEntityChangeById[entityKey];
   if (prev !== undefined) {
     let prevCheckpointId = prev.checkpointId;
     if (prevCheckpointId > committedCheckpointId && prevCheckpointId < change.checkpointId) {
@@ -138,11 +139,11 @@ function set(inMemTable, committedCheckpointId, change) {
     inMemTable.changesCount = inMemTable.changesCount + 1;
   }
   if (change.type === "SET") {
-    updateIndices(inMemTable, change.entity);
+    updateIndexes(inMemTable, change.entity);
   } else {
-    deleteEntityFromIndices(inMemTable, change.entityId);
+    deleteEntityFromIndexes(inMemTable, EntityId.toKey(change.entityId));
   }
-  inMemTable.latestEntityChangeById[entityId] = change;
+  inMemTable.latestEntityChangeById[entityKey] = change;
 }
 
 function initValue(inMemTable, committedCheckpointId, key, entity) {
@@ -173,13 +174,13 @@ function getUnsafe(inMemTable) {
 }
 
 function hasIndex(inMemTable) {
-  return filterKey => inMemTable.filterIndices[filterKey] !== undefined;
+  return filterKey => inMemTable.filterIndexes[filterKey] !== undefined;
 }
 
 function getUnsafeOnIndex(inMemTable) {
   let getEntity = getUnsafe(inMemTable);
   return filterKey => {
-    let match = inMemTable.filterIndices[filterKey];
+    let match = inMemTable.filterIndexes[filterKey];
     if (match !== undefined) {
       return Stdlib_Array.filterMap(Array.from(match[1]), entityId => {
         if (entityId in inMemTable.latestEntityChangeById) {
@@ -194,7 +195,7 @@ function getUnsafeOnIndex(inMemTable) {
 
 function addEmptyIndex(inMemTable, filter) {
   let filterKey = EntityFilter.toString(filter);
-  let match = inMemTable.filterIndices[filterKey];
+  let match = inMemTable.filterIndexes[filterKey];
   if (match !== undefined) {
     return;
   }
@@ -211,7 +212,7 @@ function addEmptyIndex(inMemTable, filter) {
     getOrCreateEntityFilters(inMemTable, entityId).add(filter);
     relatedEntityIds.add(entityId);
   });
-  inMemTable.filterIndices[filterKey] = [
+  inMemTable.filterIndexes[filterKey] = [
     filter,
     relatedEntityIds
   ];
@@ -224,8 +225,8 @@ let Entity = {
   make: make,
   snapshotChanges: snapshotChanges,
   dropCommittedChanges: dropCommittedChanges,
-  updateIndices: updateIndices,
-  deleteEntityFromIndices: deleteEntityFromIndices,
+  updateIndexes: updateIndexes,
+  deleteEntityFromIndexes: deleteEntityFromIndexes,
   set: set,
   initValue: initValue,
   mapChangeToEntity: mapChangeToEntity,