envio 3.1.2 → 3.2.0

package/src/InMemoryTable.res.mjs

@@ -2,8 +2,8 @@
 
 import * as Utils from "./Utils.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";
-import * as TableIndices from "./TableIndices.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -23,33 +23,23 @@ function getEntityIdUnsafe(entity) {
   }
 }
 
-function getOrCreateEntityIndices(self, entityId) {
-  let s = self.indicesByEntityId[entityId];
+function getOrCreateEntityFilters(self, entityId) {
+  let s = self.filtersByEntityId[entityId];
   if (s !== undefined) {
     return Primitive_option.valFromOption(s);
   }
   let s$1 = new Set();
-  self.indicesByEntityId[entityId] = s$1;
+  self.filtersByEntityId[entityId] = s$1;
   return s$1;
 }
 
-function makeIndicesSerializedToValue(index, relatedEntityIdsOpt) {
-  let relatedEntityIds = relatedEntityIdsOpt !== undefined ? Primitive_option.valFromOption(relatedEntityIdsOpt) : new Set();
-  let empty = {};
-  empty[TableIndices.Index.toString(index)] = [
-    index,
-    relatedEntityIds
-  ];
-  return empty;
-}
-
 function make() {
   return {
     latestEntityChangeById: {},
     changesCount: 0,
     prevEntityChanges: [],
-    indicesByEntityId: {},
-    fieldNameIndices: {}
+    filtersByEntityId: {},
+    filterIndices: {}
   };
 }
 
@@ -57,14 +47,20 @@ function snapshotChanges(self, committedCheckpointId, upToCheckpointId) {
   let changes = [];
   let keptPrev = [];
   self.prevEntityChanges.forEach(change => {
-    if (change.checkpointId > upToCheckpointId) {
+    let checkpointId = change.checkpointId;
+    if (checkpointId > upToCheckpointId) {
       keptPrev.push(change);
-    } else {
+      return;
+    } else if (checkpointId > committedCheckpointId) {
       changes.push(change);
+      return;
+    } else {
+      return;
     }
   });
+  let removedCount = self.prevEntityChanges.length - keptPrev.length | 0;
   self.prevEntityChanges = keptPrev;
-  self.changesCount = self.changesCount - changes.length;
+  self.changesCount = self.changesCount - removedCount;
   Utils.Dict.forEach(self.latestEntityChangeById, change => {
     let checkpointId = change.checkpointId;
     if (checkpointId > committedCheckpointId && checkpointId <= upToCheckpointId) {
@@ -86,51 +82,46 @@ function dropCommittedChanges(self, committedCheckpointId, keepLoadedFromDb) {
   });
   keysToDelete.forEach(key => Utils.Dict.deleteInPlace(self.latestEntityChangeById, key));
   self.changesCount = self.changesCount - keysToDelete.length;
-  self.indicesByEntityId = {};
-  self.fieldNameIndices = {};
+  self.filtersByEntityId = {};
+  self.filterIndices = {};
 }
 
 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);
+  let entityFilters = self.filtersByEntityId[entityId];
+  if (entityFilters !== undefined) {
+    let entityFilters$1 = Primitive_option.valFromOption(entityFilters);
+    entityFilters$1.forEach(filter => {
+      if (!EntityFilter.matches(filter, entity)) {
+        entityFilters$1.delete(filter);
         return;
       }
     });
   }
-  Utils.Dict.forEachWithKey(self.fieldNameIndices, (indices, fieldName) => {
-    let fieldValue = entity[fieldName];
-    Utils.Dict.forEach(indices, param => {
-      let relatedEntityIds = param[1];
-      let index = param[0];
-      if (TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
-        relatedEntityIds.add(entityId);
-        getOrCreateEntityIndices(self, entityId).add(index);
-      } else {
-        relatedEntityIds.delete(entityId);
-      }
-    });
+  Utils.Dict.forEach(self.filterIndices, param => {
+    let relatedEntityIds = param[1];
+    let filter = param[0];
+    if (EntityFilter.matches(filter, entity)) {
+      relatedEntityIds.add(entityId);
+      getOrCreateEntityFilters(self, entityId).add(filter);
+    } else {
+      relatedEntityIds.delete(entityId);
+    }
   });
 }
 
 function deleteEntityFromIndices(self, entityId) {
-  let entityIndices = self.indicesByEntityId[entityId];
-  if (entityIndices === undefined) {
+  let entityFilters = self.filtersByEntityId[entityId];
+  if (entityFilters === 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)]);
+  let entityFilters$1 = Primitive_option.valFromOption(entityFilters);
+  entityFilters$1.forEach(filter => {
+    let match = self.filterIndices[EntityFilter.toString(filter)];
     if (match !== undefined) {
       match[1].delete(entityId);
     }
-    entityIndices$1.delete(index);
+    entityFilters$1.delete(filter);
   });
 }
 
@@ -181,26 +172,14 @@ function getUnsafe(inMemTable) {
   return key => mapChangeToEntity(inMemTable.latestEntityChangeById[key]);
 }
 
-function hasIndex(inMemTable, fieldName, operator) {
-  return fieldValueHash => {
-    let indicesSerializedToValue = inMemTable.fieldNameIndices[fieldName];
-    if (indicesSerializedToValue === undefined) {
-      return false;
-    }
-    let key = TableIndices.Index.toStringByParts(fieldName, operator, fieldValueHash);
-    return indicesSerializedToValue[key] !== undefined;
-  };
+function hasIndex(inMemTable) {
+  return filterKey => inMemTable.filterIndices[filterKey] !== undefined;
 }
 
-function getUnsafeOnIndex(inMemTable, fieldName, operator) {
+function getUnsafeOnIndex(inMemTable) {
   let getEntity = getUnsafe(inMemTable);
-  return fieldValueHash => {
-    let indicesSerializedToValue = inMemTable.fieldNameIndices[fieldName];
-    if (indicesSerializedToValue === undefined) {
-      return Stdlib_JsError.throwWithMessage(`Unexpected error. Must have an index on field ` + fieldName);
-    }
-    let key = TableIndices.Index.toStringByParts(fieldName, operator, fieldValueHash);
-    let match = indicesSerializedToValue[key];
+  return filterKey => {
+    let match = inMemTable.filterIndices[filterKey];
     if (match !== undefined) {
       return Stdlib_Array.filterMap(Array.from(match[1]), entityId => {
         if (entityId in inMemTable.latestEntityChangeById) {
@@ -208,48 +187,40 @@ function getUnsafeOnIndex(inMemTable, fieldName, operator) {
         }
       });
     } else {
-      return Stdlib_JsError.throwWithMessage(`Unexpected error. Must have an index for the value ` + fieldValueHash + ` on field ` + fieldName);
+      return Stdlib_JsError.throwWithMessage(`Unexpected error. Must have an index for the filter ` + filterKey);
     }
   };
 }
 
-function addEmptyIndex(inMemTable, index) {
-  let fieldName = TableIndices.Index.getFieldName(index);
+function addEmptyIndex(inMemTable, filter) {
+  let filterKey = EntityFilter.toString(filter);
+  let match = inMemTable.filterIndices[filterKey];
+  if (match !== undefined) {
+    return;
+  }
   let relatedEntityIds = new Set();
   Utils.Dict.forEach(inMemTable.latestEntityChangeById, change => {
     let entity = mapChangeToEntity(change);
     if (entity === undefined) {
       return;
     }
-    let fieldValue = entity[fieldName];
-    if (!TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
+    if (!EntityFilter.matches(filter, entity)) {
       return;
     }
     let entityId = getEntityIdUnsafe(entity);
-    getOrCreateEntityIndices(inMemTable, entityId).add(index);
+    getOrCreateEntityFilters(inMemTable, entityId).add(filter);
     relatedEntityIds.add(entityId);
   });
-  let indicesSerializedToValue = inMemTable.fieldNameIndices[fieldName];
-  if (indicesSerializedToValue !== undefined) {
-    let match = indicesSerializedToValue[TableIndices.Index.toString(index)];
-    if (match !== undefined) {
-      return;
-    } else {
-      indicesSerializedToValue[TableIndices.Index.toString(index)] = [
-        index,
-        relatedEntityIds
-      ];
-      return;
-    }
-  }
-  inMemTable.fieldNameIndices[fieldName] = makeIndicesSerializedToValue(index, Primitive_option.some(relatedEntityIds));
+  inMemTable.filterIndices[filterKey] = [
+    filter,
+    relatedEntityIds
+  ];
 }
 
 let Entity = {
   UnexpectedIdNotDefinedOnEntity: UnexpectedIdNotDefinedOnEntity,
   getEntityIdUnsafe: getEntityIdUnsafe,
-  getOrCreateEntityIndices: getOrCreateEntityIndices,
-  makeIndicesSerializedToValue: makeIndicesSerializedToValue,
+  getOrCreateEntityFilters: getOrCreateEntityFilters,
   make: make,
   snapshotChanges: snapshotChanges,
   dropCommittedChanges: dropCommittedChanges,

package/src/Internal.res

@@ -265,10 +265,17 @@ type genericEvent<'params, 'block, 'transaction> = {
   block: 'block,
 }
 
-type event = genericEvent<eventParams, eventBlock, eventTransaction>
+// Opaque internally — block-level values needed by the runtime
+// (blockNumber, timestamp, blockHash) live on the item instead.
+type event
 
 external fromGenericEvent: genericEvent<'a, 'b, 'c> => event = "%identity"
 
+// Escape hatch for serialization boundaries (raw events, logging)
+// which genuinely need the runtime shape.
+external toGenericEvent: event => genericEvent<eventParams, eventBlock, eventTransaction> =
+  "%identity"
+
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
@@ -412,6 +419,50 @@ type evmContractConfig = {
   events: array<evmEventConfig>,
 }
 
+type svmAccountFilter = {
+  position: int,
+  values: array<SvmTypes.Pubkey.t>,
+}
+
+/** AND-group: every entry must match the same instruction. */
+type svmAccountFilterGroup = array<svmAccountFilter>
+
+type svmInstructionEventConfig = {
+  ...eventConfig,
+  /** Base58 Solana program id this instruction belongs to. */
+  programId: SvmTypes.Pubkey.t,
+  /** Hex-encoded discriminator. `None` matches every instruction in the program. */
+  discriminator: option<string>,
+  /** Length of the discriminator in bytes (0 / 1 / 2 / 4 / 8). Drives the
+   `dN` selector at query time and the dispatch-key precomputation in the
+   router. */
+  discriminatorByteLen: int,
+  includeTransaction: bool,
+  includeLogs: bool,
+  includeTokenBalances: bool,
+  /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
+   AND across positions. Empty outer array means "no account filter". */
+  accountFilters: array<svmAccountFilterGroup>,
+  /** `None` matches both outer and inner (CPI-invoked) instructions. */
+  isInner: option<bool>,
+  /** Positional account names from the Borsh schema, in declared order.
+   `[]` means no schema is attached for this instruction. */
+  accounts: array<string>,
+  /** Borsh args layout as `Vec<ArgDef>` JSON (see `human_config::svm::ArgDef`
+   on the Rust side). `JSON.Null` means no schema is attached. */
+  args: JSON.t,
+  /** Program-level nominal-type registry (`BTreeMap<String, ArgType>` JSON).
+   Duplicated on every event of the same program — the runtime dedups by
+   `programId` when registering. `JSON.Null` when empty. */
+  definedTypes: JSON.t,
+}
+
+type svmProgramConfig = {
+  name: string,
+  programId: SvmTypes.Pubkey.t,
+  instructions: array<svmInstructionEventConfig>,
+}
+
 type indexingAddress = {
   address: Address.t,
   contractName: string,
@@ -430,6 +481,7 @@ type eventItem = private {
   timestamp: int,
   chain: ChainMap.Chain.t,
   blockNumber: int,
+  blockHash: string,
   logIndex: int,
   event: event,
 }
@@ -463,6 +515,7 @@ type item =
       timestamp: int,
       chain: ChainMap.Chain.t,
       blockNumber: int,
+      blockHash: string,
       logIndex: int,
       event: event,
     })
@@ -523,7 +576,6 @@ type genericEntityConfig<'entity> = {
   name: string,
   index: int,
   schema: S.t<'entity>,
-  rowsSchema: S.t<array<'entity>>,
   table: Table.table,
   storage: entityStorage,
 }
@@ -569,9 +621,6 @@ type effect = {
 }
 let cacheTablePrefix = "envio_effect_"
 let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<JSON.t> => S.t<effectOutput>)
-let effectCacheItemRowsSchema = S.array(
-  S.schema(s => {id: s.matches(S.string), output: s.matches(cacheOutputSchema)}),
-)
 let makeCacheTable = (~effectName) => {
   Table.mkTable(
     cacheTablePrefix ++ effectName,

package/src/Internal.res.mjs

@@ -144,15 +144,10 @@ let cacheTablePrefix = "envio_effect_";
 
 let cacheOutputSchema = S$RescriptSchema.json(false);
 
-let effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
-  id: s.m(S$RescriptSchema.string),
-  output: s.m(cacheOutputSchema)
-})));
-
 function makeCacheTable(effectName) {
   return Table.mkTable(cacheTablePrefix + effectName, 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)
+    Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined),
+    Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined)
   ], undefined);
 }
 
@@ -173,7 +168,6 @@ export {
   fuelTransferParamsSchema,
   cacheTablePrefix,
   cacheOutputSchema,
-  effectCacheItemRowsSchema,
   makeCacheTable,
   loadedFromDbCheckpointId,
   initialCheckpointId,

package/src/LazyLoader.res

@@ -54,7 +54,7 @@ let deleteKey: (dict<'value>, string) => unit = (_obj, _k) => %raw(`delete _obj[
 let timeoutAfter = timeoutMillis =>
   Utils.delay(timeoutMillis)->Promise.then(() =>
     Promise.reject(
-      LoaderTimeout(`Query took longer than ${Belt.Int.toString(timeoutMillis / 1000)} seconds`),
+      LoaderTimeout(`Query took longer than ${Int.toString(timeoutMillis / 1000)} seconds`),
     )
   )
 
@@ -67,7 +67,7 @@ let rec loadNext = async (am: asyncMap<'key, 'value>, k: 'key) => {
     // Resolve the external promise
     am.resolvers
     ->Utils.Map.get(k)
-    ->Belt.Option.forEach(r => {
+    ->Option.forEach(r => {
       let _ = am.resolvers->Utils.Map.delete(k)
       r(val)
     })

package/src/LazyLoader.res.mjs

@@ -2,7 +2,7 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as JsSdsl from "js-sdsl";
-import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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";
 
@@ -35,7 +35,7 @@ function deleteKey(_obj, _k) {
 function timeoutAfter(timeoutMillis) {
   return Utils.delay(timeoutMillis).then(() => Promise.reject({
     RE_EXN_ID: LoaderTimeout,
-    _1: `Query took longer than ` + String(timeoutMillis / 1000 | 0) + ` seconds`
+    _1: `Query took longer than ` + (timeoutMillis / 1000 | 0).toString() + ` seconds`
   }));
 }
 
@@ -46,7 +46,7 @@ async function loadNext(am, k) {
       am.loaderFn(k),
       timeoutAfter(am._timeoutMillis)
     ]);
-    Belt_Option.forEach(am.resolvers.get(k), r => {
+    Stdlib_Option.forEach(am.resolvers.get(k), r => {
       am.resolvers.delete(k);
       r(val);
     });

package/src/LoadLayer.res

@@ -17,11 +17,15 @@ let loadById = (
     // Since LoadManager.call prevents registerign entities already existing in the inMemoryStore,
     // we can be sure that we load only the new ones.
     let dbEntities = try {
-      await storage.loadByIdsOrThrow(
-        ~table=entityConfig.table,
-        ~rowsSchema=entityConfig.rowsSchema,
-        ~ids=idsToLoad,
-      )
+      (
+        await storage.loadOrThrow(
+          ~table=entityConfig.table,
+          ~filter=EntityFilter.In({
+            fieldName: Table.idFieldName,
+            fieldValue: idsToLoad->(Utils.magic: array<string> => array<unknown>),
+          }),
+        )
+      )->(Utils.magic: array<unknown> => array<Internal.entity>)
     } catch {
     | Persistence.StorageError({message, reason}) =>
       reason->ErrorHandling.mkLogAndRaise(~logger=item->Logging.getItemLogger, ~msg=message)
@@ -161,8 +165,8 @@ let rec executeWithRateLimit = (
 
     // Split into immediate and queued
     let immediateCount = Math.Int.min(state.availableCalls, effectArgs->Array.length)
-    let immediateArgs = effectArgs->Belt.Array.slice(~offset=0, ~len=immediateCount)
-    let queuedArgs = effectArgs->Belt.Array.sliceToEnd(immediateCount)
+    let immediateArgs = effectArgs->Array.slice(~start=0, ~end=immediateCount)
+    let queuedArgs = effectArgs->Array.slice(~start=immediateCount)
 
     // Update available calls
     state.availableCalls = state.availableCalls - immediateCount
@@ -264,11 +268,15 @@ let loadEffect = (
       let {table, outputSchema} = effect.storageMeta
 
       let dbEntities = try {
-        await storage.loadByIdsOrThrow(
-          ~table,
-          ~rowsSchema=Internal.effectCacheItemRowsSchema,
-          ~ids=idsToLoad,
-        )
+        (
+          await storage.loadOrThrow(
+            ~table,
+            ~filter=EntityFilter.In({
+              fieldName: Table.idFieldName,
+              fieldValue: idsToLoad->(Utils.magic: array<string> => array<unknown>),
+            }),
+          )
+        )->(Utils.magic: array<unknown> => array<Internal.effectCacheItem>)
       } catch {
       | exn =>
         item
@@ -342,60 +350,38 @@ let loadEffect = (
   )
 }
 
-let loadByField = (
+let loadByFilter = (
   ~loadManager,
   ~persistence: Persistence.t,
-  ~operator: TableIndices.Operator.t,
   ~entityConfig: Internal.entityConfig,
   ~inMemoryStore,
-  ~fieldName,
-  ~fieldValueSchema,
   ~shouldGroup,
   ~item,
-  ~fieldValue,
+  ~filter: EntityFilter.t,
 ) => {
-  let operatorCallName = switch operator {
-  | Eq => "eq"
-  | Gt => "gt"
-  | Lt => "lt"
-  }
-  let key = `${entityConfig.name}.getWhere.${fieldName}.${operatorCallName}`
+  let key = filter->EntityFilter.toOperationKey(~entityName=entityConfig.name)
   let inMemTable = inMemoryStore->InMemoryStore.getInMemTable(~entityConfig)
 
-  let load = async (fieldValues: array<'fieldValue>, ~onError as _) => {
+  let load = async (filters: array<EntityFilter.t>, ~onError as _) => {
     let storage = persistence->Persistence.getInitializedStorageOrThrow
     let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
 
     let size = ref(0)
 
-    let indiciesToLoad = fieldValues->Array.map((fieldValue): TableIndices.Index.t => {
-      Single({
-        fieldName,
-        fieldValue: TableIndices.FieldValue.castFrom(fieldValue),
-        operator,
-      })
-    })
+    filters->Array.forEach(filter => inMemTable->InMemoryTable.Entity.addEmptyIndex(~filter))
+
+    // Loading a superset of rows via a merged query is safe: every loaded
+    // entity is matched against all registered indices, not only the
+    // query's own filter.
+    let queries = filters->EntityFilter.merge
 
-    let _ = await indiciesToLoad
-    ->Array.map(async index => {
-      inMemTable->InMemoryTable.Entity.addEmptyIndex(~index)
+    let _ = await queries
+    ->Array.map(async filter => {
       try {
-        let entities = await storage.loadByFieldOrThrow(
-          ~operator=switch index {
-          | Single({operator: Gt}) => #">"
-          | Single({operator: Eq}) => #"="
-          | Single({operator: Lt}) => #"<"
-          },
-          ~table=entityConfig.table,
-          ~rowsSchema=entityConfig.rowsSchema,
-          ~fieldName=index->TableIndices.Index.getFieldName,
-          ~fieldValue=switch index {
-          | Single({fieldValue}) => fieldValue
-          },
-          ~fieldSchema=fieldValueSchema->(
-            Utils.magic: S.t<'fieldValue> => S.t<TableIndices.FieldValue.t>
-          ),
-        )
+        let entities =
+          (await storage.loadOrThrow(~table=entityConfig.table, ~filter))->(
+            Utils.magic: array<unknown> => array<Internal.entity>
+          )
 
         entities->Array.forEach(entity => {
           inMemTable->InMemoryTable.Entity.initValue(
@@ -411,11 +397,13 @@ let loadByField = (
         reason->ErrorHandling.mkLogAndRaise(
           ~logger=Logging.createChildFrom(
             ~logger=item->Logging.getItemLogger,
+            // The executed query might be merged from multiple getWhere
+            // calls, so report it as the operation users write with the
+            // values bound to its placeholders, instead of an internal
+            // filter representation they never constructed.
             ~params={
-              "operator": operatorCallName,
-              "tableName": entityConfig.table.tableName,
-              "fieldName": fieldName,
-              "fieldValue": fieldValue,
+              "operation": key,
+              "params": filter->EntityFilter.getParams,
             },
           ),
           ~msg=message,
@@ -427,7 +415,7 @@ let loadByField = (
     timerRef->Prometheus.StorageLoad.endOperation(
       ~storage=storage.name,
       ~operation=key,
-      ~whereSize=fieldValues->Array.length,
+      ~whereSize=queries->Array.reduce(0, (acc, query) => acc + query->EntityFilter.valuesCount),
       ~size=size.contents,
     )
   }
@@ -435,11 +423,10 @@ let loadByField = (
   loadManager->LoadManager.call(
     ~key,
     ~load,
-    ~input=fieldValue,
+    ~input=filter,
     ~shouldGroup,
-    ~hasher=fieldValue =>
-      fieldValue->TableIndices.FieldValue.castFrom->TableIndices.FieldValue.toString,
-    ~getUnsafeInMemory=inMemTable->InMemoryTable.Entity.getUnsafeOnIndex(~fieldName, ~operator),
-    ~hasInMemory=inMemTable->InMemoryTable.Entity.hasIndex(~fieldName, ~operator),
+    ~hasher=EntityFilter.toString,
+    ~getUnsafeInMemory=inMemTable->InMemoryTable.Entity.getUnsafeOnIndex,
+    ~hasInMemory=inMemTable->InMemoryTable.Entity.hasIndex,
   )
 }