envio 3.1.2 → 3.2.0

package/src/Hasura.res.mjs

@@ -6,7 +6,6 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Schema from "./db/Schema.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -46,6 +45,21 @@ function clearMetadataRoute() {
   };
 }
 
+function reloadMetadataRoute() {
+  return {
+    method: "POST",
+    path: "",
+    input: s => {
+      s.field("type", S$RescriptSchema.literal("reload_metadata"));
+      return {
+        args: s.field("args", S$RescriptSchema.json(false)),
+        auth: auth(s)
+      };
+    },
+    responses: responses
+  };
+}
+
 function trackTablesRoute() {
   return {
     method: "POST",
@@ -112,6 +126,48 @@ async function clearHasuraMetadata(endpoint, auth) {
   }
 }
 
+async function reloadHasuraMetadata(endpoint, auth) {
+  try {
+    let result = await Rest.fetch(reloadMetadataRoute, {
+      auth: auth,
+      args: {
+        reload_sources: ["default"]
+      }
+    }, Rest.client(endpoint, undefined));
+    let tmp;
+    tmp = result === "QuerySucceeded" ? "Hasura metadata reloaded" : "Hasura metadata reload acknowledged";
+    return Logging.trace(tmp);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Logging.error({
+      msg: `There was an issue reloading hasura metadata - table tracking may race with schema creation.`,
+      err: Utils.prettifyExn(exn)
+    });
+  }
+}
+
+function makeColumnConfigs(table) {
+  let columnConfigs = {};
+  table.fields.forEach(fieldOrDerived => {
+    if (fieldOrDerived.TAG !== "Field") {
+      return;
+    }
+    let field = fieldOrDerived._0;
+    let apiFieldName = Table.getApiFieldName(field);
+    let dbFieldName = Table.getPgDbFieldName(field);
+    let customName = apiFieldName === dbFieldName ? undefined : apiFieldName;
+    let match = field.description;
+    if (customName === undefined && match === undefined) {
+      return;
+    }
+    columnConfigs[dbFieldName] = {
+      customName: customName,
+      comment: match
+    };
+  });
+  return columnConfigs;
+}
+
 async function trackTables(endpoint, auth, pgSchema, tableConfigs) {
   try {
     let result = await Rest.fetch(trackTablesRoute, {
@@ -127,15 +183,23 @@ async function trackTables(endpoint, auth, pgSchema, tableConfigs) {
           if (description !== undefined) {
             configuration["comment"] = description;
           }
-          let columnConfigEntries = Object.entries(param.columnDescriptions);
+          let columnConfigEntries = Object.entries(param.columnConfigs);
           if (columnConfigEntries.length !== 0) {
-            let columnConfig = {};
+            let columnConfigJson = {};
             columnConfigEntries.forEach(param => {
-              columnConfig[param[0]] = {
-                comment: param[1]
-              };
+              let config = param[1];
+              let entry = {};
+              let customName = config.customName;
+              if (customName !== undefined) {
+                entry["custom_name"] = customName;
+              }
+              let comment = config.comment;
+              if (comment !== undefined) {
+                entry["comment"] = comment;
+              }
+              columnConfigJson[param[0]] = entry;
             });
-            configuration["column_config"] = columnConfig;
+            configuration["column_config"] = columnConfigJson;
           }
           return {
             table: {
@@ -184,7 +248,7 @@ async function createSelectPermission(endpoint, auth, tableName, pgSchema, respo
 }
 
 async function createEntityRelationship(endpoint, auth, pgSchema, tableName, relationshipType, relationalKey, objectName, mappedEntity, isDerivedFrom, comment) {
-  let derivedFromTo = isDerivedFrom ? `"id": "` + relationalKey + `"` : `"` + relationalKey + `_id" : "id"`;
+  let derivedFromTo = isDerivedFrom ? `"id": "` + relationalKey + `"` : `"` + relationalKey + `" : "id"`;
   let tableJson = {
     schema: pgSchema,
     name: tableName
@@ -218,45 +282,32 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
     {
       tableName: InternalTable.RawEvents.table.tableName,
       description: undefined,
-      columnDescriptions: {}
+      columnConfigs: {}
     },
     {
       tableName: InternalTable.Views.metaViewName,
       description: undefined,
-      columnDescriptions: {}
+      columnConfigs: {}
     },
     {
       tableName: InternalTable.Views.chainMetadataViewName,
       description: undefined,
-      columnDescriptions: {}
+      columnConfigs: {}
     }
   ];
-  let userTableConfigs = userEntities.map(entity => {
-    let columnDescriptions = {};
-    entity.table.fields.forEach(fieldOrDerived => {
-      if (fieldOrDerived.TAG !== "Field") {
-        return;
-      }
-      let field = fieldOrDerived._0;
-      let d = field.description;
-      if (d !== undefined) {
-        columnDescriptions[Table.getDbFieldName(field)] = d;
-        return;
-      }
-    });
-    return {
-      tableName: entity.table.tableName,
-      description: entity.table.description,
-      columnDescriptions: columnDescriptions
-    };
-  });
-  let tableConfigs = Belt_Array.concatMany([
+  let userTableConfigs = userEntities.map(entity => ({
+    tableName: entity.table.tableName,
+    description: entity.table.description,
+    columnConfigs: makeColumnConfigs(entity.table)
+  }));
+  let tableConfigs = [
     exposedInternalTableConfigs,
     userTableConfigs
-  ]);
+  ].flat();
   let tableNames = tableConfigs.map(c => c.tableName);
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
+  await reloadHasuraMetadata(endpoint, auth);
   await trackTables(endpoint, auth, pgSchema, tableConfigs);
   for (let i = 0, i_finish = tableNames.length; i < i_finish; ++i) {
     let tableName = tableNames[i];
@@ -269,14 +320,14 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
     let derivedFromFields = Table.getDerivedFromFields(entityConfig.table);
     for (let j = 0, j_finish = derivedFromFields.length; j < j_finish; ++j) {
       let derivedFromField = derivedFromFields[j];
-      let relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
+      let relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromPgFieldName(schema, derivedFromField));
       await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true, derivedFromField.description);
     }
     let linkedEntityFields = Table.getLinkedEntityFields(entityConfig.table);
     for (let j$1 = 0, j_finish$1 = linkedEntityFields.length; j$1 < j_finish$1; ++j$1) {
       let match$1 = linkedEntityFields[j$1];
       let field = match$1[0];
-      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "object", field.fieldName, field.fieldName, match$1[1], false, field.description);
+      await createEntityRelationship(endpoint, auth, pgSchema, tableName$1, "object", Table.getPgDbFieldName(field), field.fieldName, match$1[1], false, field.description);
     }
   }
   return Logging.info("Hasura configuration completed");
@@ -286,10 +337,13 @@ export {
   auth,
   responses,
   clearMetadataRoute,
+  reloadMetadataRoute,
   trackTablesRoute,
   rawBodyRoute,
   sendOperation,
   clearHasuraMetadata,
+  reloadHasuraMetadata,
+  makeColumnConfigs,
   trackTables,
   createSelectPermission,
   createEntityRelationship,

package/src/InMemoryStore.res

@@ -45,6 +45,10 @@ type t = {
   // Processed but unwritten. The cycle drains them, splitting each write at a
   // change in isInReorgThreshold so it never mixes history-saving modes.
   mutable processedBatches: array<Batch.t>,
+  // True while a batch is being processed; guards ProcessEventBatch re-entry.
+  mutable isProcessing: bool,
+  // Count of processed batches; version-independent progress counter.
+  mutable processedBatchesCount: int,
   // The single in-flight write loop, None when idle.
   mutable writeFiber: option<promise<unit>>,
   // Set once a write throws, to stop the loop. The error itself goes to onError.
@@ -91,6 +95,8 @@ let make = (
     committedCheckpointId,
     processedCheckpointId: committedCheckpointId,
     processedBatches: [],
+    isProcessing: false,
+    processedBatchesCount: 0,
     writeFiber: None,
     hasFailedWrite: false,
     onError,
@@ -542,7 +548,10 @@ let prepareRollbackDiff = async (
       )
     })
 
-    let restoredEntities = restoredEntitiesResult->S.parseOrThrow(entityConfig.rowsSchema)
+    let restoredEntities =
+      restoredEntitiesResult
+      ->S.parseOrThrow(entityConfig.table->Table.pgRowsSchema)
+      ->(Utils.magic: array<unknown> => array<Internal.entity>)
 
     restoredEntities->Array.forEach((entity: Internal.entity) => {
       setEntities->Utils.Dict.push(entityConfig.name, entity.id)

package/src/InMemoryStore.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Env from "./Env.res.mjs";
+import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
@@ -61,6 +62,8 @@ function make$1(entities, committedCheckpointIdOpt, persistence, config, onError
     committedCheckpointId: committedCheckpointId,
     processedCheckpointId: committedCheckpointId,
     processedBatches: [],
+    isProcessing: false,
+    processedBatchesCount: 0,
     writeFiber: undefined,
     hasFailedWrite: false,
     onError: onError,
@@ -436,7 +439,7 @@ async function prepareRollbackDiff(inMemoryStore, persistence, rollbackTargetChe
         checkpointId: rollbackDiffCheckpointId
       });
     });
-    let restoredEntities = S$RescriptSchema.parseOrThrow(match[1], entityConfig.rowsSchema);
+    let restoredEntities = S$RescriptSchema.parseOrThrow(match[1], Table.pgRowsSchema(entityConfig.table));
     restoredEntities.forEach(entity => {
       Utils.Dict.push(setEntities, entityConfig.name, entity.id);
       InMemoryTable.Entity.set(entityTable, inMemoryStore.committedCheckpointId, {

package/src/InMemoryTable.res

@@ -1,12 +1,10 @@
 module Entity = {
   type relatedEntityId = string
-  type indexWithRelatedIds = (TableIndices.Index.t, Utils.Set.t<relatedEntityId>)
-  // Keyed by TableIndices.Index.toString
-  type indicesSerializedToValue = dict<indexWithRelatedIds>
-  // Keyed by TableIndices.Index.getFieldName
-  type indexFieldNameToIndices = dict<indicesSerializedToValue>
+  type filterWithRelatedIds = (EntityFilter.t, Utils.Set.t<relatedEntityId>)
+  // Keyed by EntityFilter.toString
+  type filterIndices = dict<filterWithRelatedIds>
 
-  type entityIndices = Utils.Set.t<TableIndices.Index.t>
+  type entityFilters = Utils.Set.t<EntityFilter.t>
   type t = {
     latestEntityChangeById: dict<Change.t<Internal.entity>>,
     // Recorded changes (new latest ids + prevEntityChanges pushes), tracked
@@ -15,8 +13,8 @@ module Entity = {
     // Swapped out when a write starts so processing keeps appending while the
     // previous changes persist in the background.
     mutable prevEntityChanges: array<Change.t<Internal.entity>>,
-    mutable indicesByEntityId: dict<entityIndices>,
-    mutable fieldNameIndices: indexFieldNameToIndices,
+    mutable filtersByEntityId: dict<entityFilters>,
+    mutable filterIndices: filterIndices,
   }
 
   // Helper to extract entity ID from any entity
@@ -30,30 +28,21 @@ module Entity = {
       )
     }
 
-  let getOrCreateEntityIndices = (self: t, ~entityId) =>
-    switch self.indicesByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
+  let getOrCreateEntityFilters = (self: t, ~entityId) =>
+    switch self.filtersByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
     | Some(s) => s
     | None =>
       let s = Utils.Set.make()
-      self.indicesByEntityId->Dict.set(entityId, s)
+      self.filtersByEntityId->Dict.set(entityId, s)
       s
     }
 
-  let makeIndicesSerializedToValue = (
-    ~index,
-    ~relatedEntityIds=Utils.Set.make(),
-  ): indicesSerializedToValue => {
-    let empty = Dict.make()
-    empty->Dict.set(index->TableIndices.Index.toString, (index, relatedEntityIds))
-    empty
-  }
-
   let make = (): t => {
     latestEntityChangeById: Dict.make(),
     changesCount: 0.,
     prevEntityChanges: [],
-    indicesByEntityId: Dict.make(),
-    fieldNameIndices: Dict.make(),
+    filtersByEntityId: Dict.make(),
+    filterIndices: Dict.make(),
   }
 
   // Changes to persist for checkpoints in (committedCheckpointId, upToCheckpointId].
@@ -64,15 +53,22 @@ module Entity = {
   > => {
     let changes = []
     let keptPrev = []
-    self.prevEntityChanges->Array.forEach(change =>
-      if change->Change.getCheckpointId > upToCheckpointId {
+    self.prevEntityChanges->Array.forEach(change => {
+      let checkpointId = change->Change.getCheckpointId
+      if checkpointId > upToCheckpointId {
         keptPrev->Array.push(change)
-      } else {
+      } else if checkpointId > committedCheckpointId {
         changes->Array.push(change)
       }
-    )
+      // Drop changes at or below committedCheckpointId: they were already
+      // snapshotted by the write that committed them. They land here when an
+      // entity is overwritten while that write is still in flight — set's
+      // guard compares against the not-yet-advanced committed checkpoint —
+      // and re-emitting them would write duplicate history rows.
+    })
+    let removedCount = self.prevEntityChanges->Array.length - keptPrev->Array.length
     self.prevEntityChanges = keptPrev
-    self.changesCount = self.changesCount -. changes->Array.length->Int.toFloat
+    self.changesCount = self.changesCount -. removedCount->Int.toFloat
     self.latestEntityChangeById->Utils.Dict.forEach(change => {
       let checkpointId = change->Change.getCheckpointId
       if checkpointId > committedCheckpointId && !(checkpointId > upToCheckpointId) {
@@ -99,63 +95,49 @@ module Entity = {
     })
     keysToDelete->Array.forEach(key => self.latestEntityChangeById->Utils.Dict.deleteInPlace(key))
     self.changesCount = self.changesCount -. keysToDelete->Array.length->Int.toFloat
-    self.indicesByEntityId = Dict.make()
-    self.fieldNameIndices = Dict.make()
+    self.filtersByEntityId = Dict.make()
+    self.filterIndices = Dict.make()
   }
 
   let updateIndices = (self: t, ~entity: Internal.entity) => {
     let entityId = entity->getEntityIdUnsafe
-    //Remove any invalid indices on entity
-    switch self.indicesByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
+    let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
+
+    //Remove any invalid filters on entity
+    switch self.filtersByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
     | None => ()
-    | Some(entityIndices) =>
-      entityIndices->Utils.Set.forEach(index => {
-        let fieldName = index->TableIndices.Index.getFieldName
-        let fieldValue =
-          entity
-          ->(Utils.magic: Internal.entity => dict<TableIndices.FieldValue.t>)
-          ->Dict.getUnsafe(fieldName)
-        if !(index->TableIndices.Index.evaluate(~fieldName, ~fieldValue)) {
-          entityIndices->Utils.Set.delete(index)->ignore
+    | Some(entityFilters) =>
+      entityFilters->Utils.Set.forEach(filter => {
+        if !(filter->EntityFilter.matches(~entity=entityAsDict)) {
+          entityFilters->Utils.Set.delete(filter)->ignore
         }
       })
     }
 
-    self.fieldNameIndices->Utils.Dict.forEachWithKey((indices, fieldName) => {
-      // A missing key reads as `undefined`, which matches the `None` arm of
-      // `FieldValue.t` (`option<...>`). Mirror `addEmptyIndex` so nullable
-      // FK columns that were omitted on the set entity don't crash.
-      let fieldValue =
-        entity
-        ->(Utils.magic: Internal.entity => dict<TableIndices.FieldValue.t>)
-        ->Dict.getUnsafe(fieldName)
-      indices->Utils.Dict.forEach(((index, relatedEntityIds)) => {
-        if index->TableIndices.Index.evaluate(~fieldName, ~fieldValue) {
-          //Add entity id to indices and add index to entity indicies
-          relatedEntityIds->Utils.Set.add(entityId)->ignore
-          self->getOrCreateEntityIndices(~entityId)->Utils.Set.add(index)->ignore
-        } else {
-          relatedEntityIds->Utils.Set.delete(entityId)->ignore
-        }
-      })
+    self.filterIndices->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
+        self->getOrCreateEntityFilters(~entityId)->Utils.Set.add(filter)->ignore
+      } else {
+        relatedEntityIds->Utils.Set.delete(entityId)->ignore
+      }
     })
   }
 
   let deleteEntityFromIndices = (self: t, ~entityId: string) =>
-    switch self.indicesByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
+    switch self.filtersByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
     | None => ()
-    | Some(entityIndices) =>
-      entityIndices->Utils.Set.forEach(index => {
-        switch self.fieldNameIndices
-        ->Utils.Dict.dangerouslyGetNonOption(index->TableIndices.Index.getFieldName)
-        ->Option.flatMap(indices =>
-          indices->Utils.Dict.dangerouslyGetNonOption(index->TableIndices.Index.toString)
+    | Some(entityFilters) =>
+      entityFilters->Utils.Set.forEach(filter => {
+        switch self.filterIndices->Utils.Dict.dangerouslyGetNonOption(
+          filter->EntityFilter.toString,
         ) {
-        | Some((_index, relatedEntityIds)) =>
+        | Some((_filter, relatedEntityIds)) =>
           let _wasRemoved = relatedEntityIds->Utils.Set.delete(entityId)
-        | None => () //Unexpected index should exist if it is entityIndices
+        | None => () //Unexpected filter index should exist if it is in entityFilters
         }
-        let _wasRemoved = entityIndices->Utils.Set.delete(index)
+        let _wasRemoved = entityFilters->Utils.Set.delete(filter)
       })
     }
 
@@ -214,84 +196,49 @@ module Entity = {
       ->Dict.getUnsafe(key)
       ->mapChangeToEntity
 
-  let hasIndex = (inMemTable: t, ~fieldName, ~operator: TableIndices.Operator.t) =>
-    fieldValueHash => {
-      switch inMemTable.fieldNameIndices->Utils.Dict.dangerouslyGetNonOption(fieldName) {
-      | None => false
-      | Some(indicesSerializedToValue) => {
-          let key = TableIndices.Index.toStringByParts(~fieldName, ~operator, ~fieldValueHash)
-          indicesSerializedToValue->Utils.Dict.dangerouslyGetNonOption(key) !== None
-        }
-      }
-    }
+  let hasIndex = (inMemTable: t) =>
+    (filterKey: string) =>
+      inMemTable.filterIndices->Utils.Dict.dangerouslyGetNonOption(filterKey) !== None
 
-  let getUnsafeOnIndex = (inMemTable: t, ~fieldName, ~operator: TableIndices.Operator.t) => {
+  let getUnsafeOnIndex = (inMemTable: t) => {
     let getEntity = inMemTable->getUnsafe
-    fieldValueHash => {
-      switch inMemTable.fieldNameIndices->Utils.Dict.dangerouslyGetNonOption(fieldName) {
+    (filterKey: string) => {
+      switch inMemTable.filterIndices->Utils.Dict.dangerouslyGetNonOption(filterKey) {
       | None =>
-        JsError.throwWithMessage(`Unexpected error. Must have an index on field ${fieldName}`)
-      | Some(indicesSerializedToValue) => {
-          let key = TableIndices.Index.toStringByParts(~fieldName, ~operator, ~fieldValueHash)
-          switch indicesSerializedToValue->Utils.Dict.dangerouslyGetNonOption(key) {
-          | None =>
-            JsError.throwWithMessage(
-              `Unexpected error. Must have an index for the value ${fieldValueHash} on field ${fieldName}`,
-            )
-          | Some((_index, relatedEntityIds)) => {
-              let res =
-                relatedEntityIds
-                ->Utils.Set.toArray
-                ->Array.filterMap(entityId => {
-                  switch inMemTable.latestEntityChangeById->Dict.has(entityId) {
-                  | true => getEntity(entityId)
-                  | false => None
-                  }
-                })
-              res
-            }
+        JsError.throwWithMessage(`Unexpected error. Must have an index for the filter ${filterKey}`)
+      | Some((_filter, relatedEntityIds)) =>
+        relatedEntityIds
+        ->Utils.Set.toArray
+        ->Array.filterMap(entityId => {
+          switch inMemTable.latestEntityChangeById->Dict.has(entityId) {
+          | true => getEntity(entityId)
+          | false => None
           }
-        }
+        })
       }
     }
   }
 
-  let addEmptyIndex = (inMemTable: t, ~index) => {
-    let fieldName = index->TableIndices.Index.getFieldName
-    let relatedEntityIds = Utils.Set.make()
-
-    inMemTable.latestEntityChangeById->Utils.Dict.forEach(change => {
-      switch change->mapChangeToEntity {
-      | Some(entity) =>
-        let fieldValue =
-          entity
-          ->(Utils.magic: Internal.entity => dict<TableIndices.FieldValue.t>)
-          ->Dict.getUnsafe(fieldName)
-        if index->TableIndices.Index.evaluate(~fieldName, ~fieldValue) {
-          let entityId = entity->getEntityIdUnsafe
-          let _ = inMemTable->getOrCreateEntityIndices(~entityId)->Utils.Set.add(index)
-          let _ = relatedEntityIds->Utils.Set.add(entityId)
-        }
-      | None => ()
-      }
-    })
-    switch inMemTable.fieldNameIndices->Utils.Dict.dangerouslyGetNonOption(fieldName) {
+  let addEmptyIndex = (inMemTable: t, ~filter: EntityFilter.t) => {
+    let filterKey = filter->EntityFilter.toString
+    switch inMemTable.filterIndices->Utils.Dict.dangerouslyGetNonOption(filterKey) {
+    | Some(_) => () //Should not happen, this means the index already exists
     | None =>
-      inMemTable.fieldNameIndices->Dict.set(
-        fieldName,
-        makeIndicesSerializedToValue(~index, ~relatedEntityIds),
-      )
-    | Some(indicesSerializedToValue) =>
-      switch indicesSerializedToValue->Utils.Dict.dangerouslyGetNonOption(
-        index->TableIndices.Index.toString,
-      ) {
-      | None =>
-        indicesSerializedToValue->Dict.set(
-          index->TableIndices.Index.toString,
-          (index, relatedEntityIds),
-        )
-      | Some(_) => () //Should not happen, this means the index already exists
-      }
+      let relatedEntityIds = Utils.Set.make()
+      inMemTable.latestEntityChangeById->Utils.Dict.forEach(change => {
+        switch change->mapChangeToEntity {
+        | Some(entity) =>
+          let entityAsDict =
+            entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
+          if filter->EntityFilter.matches(~entity=entityAsDict) {
+            let entityId = entity->getEntityIdUnsafe
+            let _ = inMemTable->getOrCreateEntityFilters(~entityId)->Utils.Set.add(filter)
+            let _ = relatedEntityIds->Utils.Set.add(entityId)
+          }
+        | None => ()
+        }
+      })
+      inMemTable.filterIndices->Dict.set(filterKey, (filter, relatedEntityIds))
     }
   }
 }