envio 3.5.1 → 3.6.0

package/src/TestIndexer.res

@@ -70,6 +70,19 @@ let getIndexingAddressesByChain = (state: testIndexerState): dict<
   byChain
 }
 
+// Rows of a per-chain entity are keyed per (chain, id): the same id exists
+// independently on every chain.
+let rowKey = (~scope: Internal.chainScope, ~entityId: EntityId.t) =>
+  switch scope {
+  | CrossChain => entityId->EntityId.toKey
+  | Chain(chainId) => `${chainId->ChainId.toString}|${entityId->EntityId.toKey}`
+  }
+
+let readChainId = (entity: Internal.entity, ~field: Table.field): option<ChainId.t> =>
+  entity
+  ->(Utils.magic: Internal.entity => dict<ChainId.t>)
+  ->Utils.Dict.dangerouslyGetNonOption(field.fieldName)
+
 let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): array<
   Internal.entity,
 > => {
@@ -79,16 +92,28 @@ let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFi
   // entityConfig.
   switch state.entityConfigs->Dict.get(tableName) {
   | None => []
-  | Some(_) =>
+  | Some(entityConfig) =>
     let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
-    entityDict
-    ->Dict.valuesToArray
-    ->Array.filter(entity => {
-      // The store holds decoded entities and the filter carries decoded values,
-      // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
-      let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-      filter->EntityFilter.matches(~entity=entityAsDict)
-    })
+    let matched =
+      entityDict
+      ->Dict.valuesToArray
+      ->Array.filter(entity => {
+        // The store holds decoded entities and the filter carries decoded values,
+        // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
+        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
+        filter->EntityFilter.matches(~entity=entityAsDict)
+      })
+    // The chain is already fixed by the scope the load ran for, so the loaded
+    // entity is handed back in the shape the handlers see.
+    switch entityConfig.table->Table.getChainIdField {
+    | None => matched
+    | Some(field) =>
+      matched->Array.map(entity => {
+        let copy = entity->(Utils.magic: Internal.entity => dict<unknown>)->Utils.Dict.shallowCopy
+        copy->Utils.Dict.deleteInPlace(field.fieldName)
+        copy->(Utils.magic: dict<unknown> => Internal.entity)
+      })
+    }
   }
 }
 
@@ -104,8 +129,11 @@ let handleWriteBatch = (
   // checkpointId -> entityName -> entityChange
   let changesByCheckpoint: dict<dict<entityChange>> = Dict.make()
 
-  updatedEntities->Array.forEach(({entityConfig, changes}: Persistence.updatedEntity) => {
+  updatedEntities->Array.forEach(({entityConfig, scope, changes}: Persistence.updatedEntity) => {
     let entityName = entityConfig.name
+    // The scope is what makes a per-chain row identifiable, so it's stamped
+    // onto the stored entity the same way the Postgres write path does.
+    let chainIdField = entityConfig.table->Table.getChainIdField
     let entityDict = switch state.entities->Dict.get(entityName) {
     | Some(dict) => dict
     | None =>
@@ -138,10 +166,17 @@ let handleWriteBatch = (
         // The store keeps decoded entities so load comparisons (bigint /
         // BigDecimal) work on real values. Ids are keyed by their string form
         // since they may be string/int/bigint.
-        entityDict->Dict.set(entityId->EntityId.toKey, entity)
+        let storedEntity = switch (chainIdField, scope->Internal.chainScopeChainId) {
+        | (Some(field), Some(chainId)) =>
+          entity->Internal.stampChainId(~fieldName=field.fieldName, ~chainId)
+        | _ => entity
+        }
+        entityDict->Dict.set(rowKey(~scope, ~entityId), storedEntity)
+        // The change already carries the checkpoint's chainId, so the entity
+        // inside it stays unstamped.
         entityChangeFor(checkpointId).sets->Array.push(entity->Utils.magic)->ignore
       | Delete({entityId, checkpointId}) =>
-        Dict.delete(entityDict->Obj.magic, entityId->EntityId.toKey)
+        Dict.delete(entityDict->Obj.magic, rowKey(~scope, ~entityId))
         entityChangeFor(checkpointId).deleted->Array.push(entityId)->ignore
       }
     }
@@ -379,7 +414,10 @@ let copyEntity = (entity: Internal.entity): Internal.entity =>
   ->Utils.Dict.shallowCopy
   ->(Utils.magic: dict<unknown> => Internal.entity)
 
-// Entity operations for direct manipulation outside of handlers
+// Entity operations for direct manipulation outside of handlers. Unlike a
+// handler, which always runs on a known chain, these are chain-agnostic — so a
+// per-chain entity is looked up across every chain and an id present on more
+// than one is an error rather than an arbitrary pick.
 let getEntityFromState = (
   ~state: testIndexerState,
   ~entityConfig: Internal.entityConfig,
@@ -392,7 +430,25 @@ let getEntityFromState = (
     )
   }
   let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
-  entityDict->Dict.get(entityId)->Option.map(copyEntity)
+  switch entityConfig.table->Table.getChainIdField {
+  | None => entityDict->Dict.get(entityId)->Option.map(copyEntity)
+  | Some(field) =>
+    let matches = entityDict->Dict.valuesToArray->Array.filter(entity => entity.id === entityId)
+    switch matches {
+    | [] => None
+    | [entity] => Some(copyEntity(entity))
+    | _ =>
+      let chains =
+        matches
+        ->Array.map(entity =>
+          entity->readChainId(~field)->Option.mapOr("unknown", ChainId.toString)
+        )
+        ->Array.join(", ")
+      JsError.throwWithMessage(
+        `Entity \`${entityConfig.name}\` with id \`${entityId}\` exists on multiple chains (${chains}) — use getWhere({${field.fieldName}: {_eq: ...}}) to pick one.`,
+      )
+    }
+  }
 }
 
 let makeEntityGet = (~state: testIndexerState, ~entityConfig: Internal.entityConfig): (
@@ -435,7 +491,23 @@ let makeEntitySet = (~state: testIndexerState, ~entityConfig: Internal.entityCon
       state.entities->Dict.set(entityConfig.name, dict)
       dict
     }
-    entityDict->Dict.set(entity.id, copyEntity(entity))
+    // Outside a handler there's no chain in context, so a per-chain entity has
+    // to say which chain the row belongs to.
+    let scope = switch entityConfig.table->Table.getChainIdField {
+    | None => Internal.CrossChain
+    | Some(field) =>
+      switch entity->readChainId(~field) {
+      | Some(chainId) => Internal.Chain(chainId)
+      | None =>
+        JsError.throwWithMessage(
+          `${entityConfig.name}.set() requires a \`${field.fieldName}\` because the entity is per-chain. Pass it alongside the entity fields.`,
+        )
+      }
+    }
+    entityDict->Dict.set(
+      rowKey(~scope, ~entityId=entity.id->EntityId.unsafeOfString),
+      copyEntity(entity),
+    )
   }
 }
 
@@ -453,9 +525,43 @@ let makeEntityGetAll = (~state: testIndexerState, ~entityConfig: Internal.entity
   }
 }
 
+// The same filter syntax as `context.X.getWhere` in a handler, matched against
+// the store instead of a database. A per-chain entity's rows carry their chain
+// id, so `{chainId: {_eq: 1}}` is what narrows an id that exists on several
+// chains.
+let makeEntityGetWhere = (~state: testIndexerState, ~entityConfig: Internal.entityConfig): (
+  dict<dict<unknown>> => promise<array<Internal.entity>>
+) => {
+  filter => {
+    if state.processInProgress {
+      JsError.throwWithMessage(
+        `Cannot call ${entityConfig.name}.getWhere() while indexer.process() is running. ` ++ "Wait for process() to complete before accessing entities directly.",
+      )
+    }
+    let filters =
+      filter->EntityFilter.parseGetWhereOrThrow(
+        ~entityName=entityConfig.name,
+        ~table=entityConfig.table,
+      )
+    let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
+    // parseGetWhereOrThrow expands an operator group into alternatives whose
+    // matches are disjoint, so the union needs no dedup.
+    Promise.resolve(
+      entityDict
+      ->Dict.valuesToArray
+      ->Array.filter(entity => {
+        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
+        filters->Array.some(filter => filter->EntityFilter.matches(~entity=entityAsDict))
+      })
+      ->Array.map(copyEntity),
+    )
+  }
+}
+
 type entityOperations = {
   get: string => promise<option<Internal.entity>>,
   getAll: unit => promise<array<Internal.entity>>,
+  getWhere: dict<dict<unknown>> => promise<array<Internal.entity>>,
   getOrThrow: (string, ~message: string=?) => promise<Internal.entity>,
   set: Internal.entity => unit,
 }
@@ -507,8 +613,12 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   reset: async () => (),
   setChainMeta: async _ => Obj.magic(),
   pruneStaleCheckpoints: async (~safeCheckpointId as _) => (),
-  pruneStaleEntityHistory: async (~entityName as _, ~entityIndex as _, ~safeCheckpointId as _) =>
-    (),
+  pruneStaleEntityHistory: async (
+    ~entityName as _,
+    ~entityIndex as _,
+    ~chainIdColumn as _,
+    ~safeCheckpointId as _,
+  ) => (),
   getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) =>
     JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable.",
@@ -625,6 +735,7 @@ let createTestIndexer = (): t<'processConfig> => {
         {
           get: makeEntityGet(~state, ~entityConfig),
           getAll: makeEntityGetAll(~state, ~entityConfig),
+          getWhere: makeEntityGetWhere(~state, ~entityConfig),
           getOrThrow: makeEntityGetOrThrow(~state, ~entityConfig),
           set: makeEntitySet(~state, ~entityConfig),
         },

package/src/TestIndexer.res.mjs

@@ -1,12 +1,14 @@
 // 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 ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as EntityId from "./EntityId.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
@@ -55,19 +57,44 @@ function getIndexingAddressesByChain(state) {
   return byChain;
 }
 
+function rowKey(scope, entityId) {
+  if (scope === "crossChain") {
+    return EntityId.toKey(entityId);
+  } else {
+    return ChainId.toString(scope) + `|` + EntityId.toKey(entityId);
+  }
+}
+
+function readChainId(entity, field) {
+  return entity[field.fieldName];
+}
+
 function handleLoad(state, tableName, filter) {
-  let match = state.entityConfigs[tableName];
-  if (match === undefined) {
+  let entityConfig = state.entityConfigs[tableName];
+  if (entityConfig === undefined) {
     return [];
   }
   let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
-  return Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+  let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+  let field = Table.getChainIdField(entityConfig.table);
+  if (field !== undefined) {
+    return matched.map(entity => {
+      let copy = Utils.Dict.shallowCopy(entity);
+      Utils.Dict.deleteInPlace(copy, field.fieldName);
+      return copy;
+    });
+  } else {
+    return matched;
+  }
 }
 
 function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointEventsProcessed) {
   let changesByCheckpoint = {};
   updatedEntities.forEach(param => {
-    let entityName = param.entityConfig.name;
+    let scope = param.scope;
+    let entityConfig = param.entityConfig;
+    let entityName = entityConfig.name;
+    let chainIdField = Table.getChainIdField(entityConfig.table);
     let dict = state.entities[entityName];
     let entityDict;
     if (dict !== undefined) {
@@ -104,12 +131,14 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
     let processChange = change => {
       if (change.type === "SET") {
         let entity = change.entity;
-        entityDict[EntityId.toKey(change.entityId)] = entity;
+        let match = Internal.chainScopeChainId(scope);
+        let storedEntity = chainIdField !== undefined && match !== undefined ? Internal.stampChainId(entity, chainIdField.fieldName, Primitive_option.valFromOption(match)) : entity;
+        entityDict[rowKey(scope, change.entityId)] = storedEntity;
         entityChangeFor(change.checkpointId).sets.push(entity);
         return;
       }
       let entityId = change.entityId;
-      Stdlib_Dict.$$delete(entityDict, EntityId.toKey(entityId));
+      Stdlib_Dict.$$delete(entityDict, rowKey(scope, entityId));
       entityChangeFor(change.checkpointId).deleted.push(entityId);
     };
     param.changes.forEach(processChange);
@@ -265,7 +294,21 @@ function getEntityFromState(state, entityConfig, entityId, methodName) {
     Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.` + methodName + `() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
   }
   let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-  return Stdlib_Option.map(entityDict[entityId], copyEntity);
+  let field = Table.getChainIdField(entityConfig.table);
+  if (field === undefined) {
+    return Stdlib_Option.map(entityDict[entityId], copyEntity);
+  }
+  let matches = Object.values(entityDict).filter(entity => entity.id === entityId);
+  let len = matches.length;
+  if (len !== 1) {
+    if (len === 0) {
+      return;
+    }
+    let chains = matches.map(entity => Stdlib_Option.mapOr(entity[field.fieldName], "unknown", ChainId.toString)).join(", ");
+    return Stdlib_JsError.throwWithMessage(`Entity \`` + entityConfig.name + `\` with id \`` + entityId + `\` exists on multiple chains (` + chains + `) — use getWhere({` + field.fieldName + `: {_eq: ...}}) to pick one.`);
+  }
+  let entity = matches[0];
+  return Utils.Dict.shallowCopy(entity);
 }
 
 function makeEntityGet(state, entityConfig) {
@@ -297,7 +340,15 @@ function makeEntitySet(state, entityConfig) {
       state.entities[entityConfig.name] = dict$1;
       entityDict = dict$1;
     }
-    entityDict[entity.id] = Utils.Dict.shallowCopy(entity);
+    let field = Table.getChainIdField(entityConfig.table);
+    let scope;
+    if (field !== undefined) {
+      let chainId = entity[field.fieldName];
+      scope = chainId !== undefined ? Primitive_option.valFromOption(chainId) : Stdlib_JsError.throwWithMessage(entityConfig.name + `.set() requires a \`` + field.fieldName + `\` because the entity is per-chain. Pass it alongside the entity fields.`);
+    } else {
+      scope = "crossChain";
+    }
+    entityDict[rowKey(scope, entity.id)] = Utils.Dict.shallowCopy(entity);
   };
 }
 
@@ -311,6 +362,17 @@ function makeEntityGetAll(state, entityConfig) {
   };
 }
 
+function makeEntityGetWhere(state, entityConfig) {
+  return filter => {
+    if (state.processInProgress) {
+      Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.getWhere() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
+    }
+    let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
+    let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
+    return Promise.resolve(Object.values(entityDict).filter(entity => filters.some(filter => EntityFilter.matches(filter, entity))).map(copyEntity));
+  };
+}
+
 function makeInMemoryStorage(state) {
   return {
     name: "test-inmemory",
@@ -325,7 +387,7 @@ function makeInMemoryStorage(state) {
     reset: async () => {},
     setChainMeta: async param => {},
     pruneStaleCheckpoints: async param => {},
-    pruneStaleEntityHistory: async (param, param$1, param$2) => {},
+    pruneStaleEntityHistory: async (param, param$1, param$2, param$3) => {},
     getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
@@ -407,6 +469,7 @@ function createTestIndexer() {
       entityOpsDict[entityConfig.name] = {
         get: makeEntityGet(state, entityConfig),
         getAll: makeEntityGetAll(state, entityConfig),
+        getWhere: makeEntityGetWhere(state, entityConfig),
         getOrThrow: makeEntityGetOrThrow(state, entityConfig),
         set: makeEntitySet(state, entityConfig)
       };
@@ -613,6 +676,8 @@ function createTestIndexer() {
 export {
   toIndexingAddress,
   getIndexingAddressesByChain,
+  rowKey,
+  readChainId,
   handleLoad,
   handleWriteBatch,
   makeInitialState,
@@ -626,6 +691,7 @@ export {
   makeEntityGetOrThrow,
   makeEntitySet,
   makeEntityGetAll,
+  makeEntityGetWhere,
   makeInMemoryStorage,
   cloneRegistrations,
   registrationsRef,

package/src/UserContext.res

@@ -60,15 +60,19 @@ external makeEffectContext: (
 
 let initEffect = (params: contextParams) => {
   let handlerChainId = params.item->Internal.getItemChainId
+  // An effect that didn't state a scope follows the config: cross-chain by
+  // default, per-chain under `disable_default_cross_chain`.
+  let isCrossChain = (effect: Internal.effect) =>
+    effect.crossChain->Option.getOr(params.config.defaultCrossChain)
   // A chain-scoped effect always resolves against the chain of the handler that
   // triggered the call, even several effects deep, so the chain id is captured
   // once from the item and reused for the whole nested-call tree.
   let rec makeCaller = (~caller: option<Internal.effect>) => {
     (effect: Internal.effect, input: Internal.effectInput) => {
-      let scope = effect.crossChain ? Internal.CrossChain : Internal.Chain(handlerChainId)
+      let scope = effect->isCrossChain ? Internal.CrossChain : Internal.Chain(handlerChainId)
 
       switch caller {
-      | Some(callerEffect) if callerEffect.crossChain && !effect.crossChain =>
+      | Some(callerEffect) if callerEffect->isCrossChain && !(effect->isCrossChain) =>
         // A cross-chain effect isn't tied to a single chain, so it has no chain
         // to resolve a chain-scoped child against. Reject before any cache work.
         JsError.throwWithMessage(
@@ -114,6 +118,13 @@ type entityContextParams = {
   entityConfig: Internal.entityConfig,
 }
 
+// The handler context is always chain-scoped, so a per-chain entity resolves to
+// the chain the handler runs on and a cross-chain one to the shared partition.
+let entityScope = (params: entityContextParams) =>
+  params.entityConfig->InMemoryStore.entityScope(
+    ~chainId=params.item->Internal.getItemChainId,
+  )
+
 let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) => {
   let entityConfig = params.entityConfig
 
@@ -123,6 +134,7 @@ let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>)
       ~loadManager=params.loadManager,
       ~persistence=params.persistence,
       ~entityConfig,
+      ~scope=params->entityScope,
       ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
@@ -164,7 +176,7 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
       ? noopSet
       : (entity: Internal.entity) => {
           params.indexerState
-          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope=params->entityScope)
           ->InMemoryTable.Entity.set(
             ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Set({
@@ -188,6 +200,7 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
+              ~scope=params->entityScope,
               ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
@@ -220,6 +233,7 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
+              ~scope=params->entityScope,
               ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
@@ -250,6 +264,7 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
+              ~scope=params->entityScope,
               ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
@@ -273,7 +288,7 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
       } else {
         entityId => {
           params.indexerState
-          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope=params->entityScope)
           ->InMemoryTable.Entity.set(
             ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Delete({

package/src/UserContext.res.mjs

@@ -49,9 +49,10 @@ EffectContext.prototype = effectContextPrototype;
 
 function initEffect(params) {
   let handlerChainId = Internal.getItemChainId(params.item);
+  let isCrossChain = effect => Stdlib_Option.getOr(effect.crossChain, params.config.defaultCrossChain);
   let makeCaller = caller => ((effect, input) => {
-    let scope = effect.crossChain ? "crossChain" : handlerChainId;
-    if (caller !== undefined && caller.crossChain && !effect.crossChain) {
+    let scope = isCrossChain(effect) ? "crossChain" : handlerChainId;
+    if (caller !== undefined && isCrossChain(caller) && !isCrossChain(effect)) {
       Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
     }
     let tmp;
@@ -70,13 +71,17 @@ function initEffect(params) {
   return makeCaller(undefined);
 }
 
+function entityScope(params) {
+  return InMemoryStore.entityScope(params.entityConfig, Internal.getItemChainId(params.item));
+}
+
 function getWhereHandler(params, filter) {
   let entityConfig = params.entityConfig;
   let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
   if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
+    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
   } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
+    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
   }
 }
 
@@ -94,7 +99,7 @@ function throwClickHouseReadOnly(entityConfig, op) {
 
 let entityTraps_get = (params, prop) => {
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
       type: "SET",
       entityId: entity.id,
       entity: entity,
@@ -105,7 +110,7 @@ let entityTraps_get = (params, prop) => {
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig), IndexerState.committedCheckpointId(params.indexerState), {
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
           type: "DELETE",
           entityId: entityId,
           checkpointId: params.checkpointId
@@ -115,13 +120,13 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return _entityId => throwClickHouseReadOnly(params.entityConfig, "get");
       } else {
-        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
+        return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
       }
     case "getOrCreate" :
       if (isClickHouseOnly) {
         return _entity => throwClickHouseReadOnly(params.entityConfig, "getOrCreate");
       } else {
-        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entity.id).then(storageEntity => {
+        return entity => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entity.id).then(storageEntity => {
           if (storageEntity !== undefined) {
             return storageEntity;
           } else {
@@ -134,7 +139,7 @@ let entityTraps_get = (params, prop) => {
       if (isClickHouseOnly) {
         return (_entityId, param) => throwClickHouseReadOnly(params.entityConfig, "getOrThrow");
       } else {
-        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId).then(entity => {
+        return (entityId, message) => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId).then(entity => {
           if (entity !== undefined) {
             return entity;
           } else {
@@ -210,6 +215,7 @@ export {
   paramsByThis,
   effectContextPrototype,
   initEffect,
+  entityScope,
   getWhereHandler,
   noopSet,
   noopDeleteUnsafe,

package/src/Writing.res

@@ -10,10 +10,8 @@ let keepLatestChangesLimit = Env.inMemoryObjectsTarget
 
 let getChangesCount = (state: IndexerState.t) => {
   let total = ref(0.)
-  state
-  ->IndexerState.allEntities
-  ->Array.forEach(entityConfig => {
-    total := total.contents +. (state->InMemoryStore.getInMemTable(~entityConfig)).changesCount
+  state->IndexerState.eachEntityTable((~entityConfig as _, ~scope as _, ~table) => {
+    total := total.contents +. table.changesCount
   })
   state
   ->IndexerState.effectState
@@ -113,14 +111,12 @@ let runOneWrite = async (state: IndexerState.t) => {
 
     let rollback = state->IndexerState.takeRollback
 
-    let updatedEntities = persistence.allEntities->Array.filterMap(entityConfig => {
-      let table = state->InMemoryStore.getInMemTable(~entityConfig)
+    let updatedEntities = []
+    state->IndexerState.eachEntityTable((~entityConfig, ~scope, ~table) => {
       let changes =
         table->InMemoryTable.Entity.snapshotChanges(~committedCheckpointId, ~upToCheckpointId)
-      if changes->Utils.Array.isEmpty {
-        None
-      } else {
-        Some(({entityConfig, changes}: Persistence.updatedEntity))
+      if changes->Utils.Array.notEmpty {
+        updatedEntities->Array.push(({entityConfig, scope, changes}: Persistence.updatedEntity))
       }
     })
     let updatedEffectsCache = snapshotEffects(state, ~cache)
@@ -221,12 +217,8 @@ let commitBatch = (state: IndexerState.t, ~batch: Batch.t) => {
 // keepLoadedFromDb, entries seeded from a db read are spared.
 let dropCommitted = (state: IndexerState.t, ~keepLoadedFromDb) => {
   let committedCheckpointId = state->IndexerState.committedCheckpointId
-  state
-  ->IndexerState.allEntities
-  ->Array.forEach(entityConfig =>
-    state
-    ->InMemoryStore.getInMemTable(~entityConfig)
-    ->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
+  state->IndexerState.eachEntityTable((~entityConfig as _, ~scope as _, ~table) =>
+    table->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
   )
   state
   ->IndexerState.effectState

package/src/Writing.res.mjs

@@ -19,8 +19,8 @@ function getChangesCount(state) {
   let total = {
     contents: 0
   };
-  IndexerState.allEntities(state).forEach(entityConfig => {
-    total.contents = total.contents + InMemoryStore.getInMemTable(state, entityConfig).changesCount;
+  IndexerState.eachEntityTable(state, (param, param$1, table) => {
+    total.contents = total.contents + table.changesCount;
   });
   EffectState.forEach(IndexerState.effectState(state), inMemTable => {
     total.contents = total.contents + inMemTable.changesCount;
@@ -105,16 +105,16 @@ async function runOneWrite(state) {
   let checkpointId = Utils.$$Array.last(batch.checkpointIds);
   let upToCheckpointId = checkpointId !== undefined ? checkpointId : committedCheckpointId;
   let rollback = IndexerState.takeRollback(state);
-  let updatedEntities = Stdlib_Array.filterMap(persistence.allEntities, entityConfig => {
-    let table = InMemoryStore.getInMemTable(state, entityConfig);
+  let updatedEntities = [];
+  IndexerState.eachEntityTable(state, (entityConfig, scope, table) => {
     let changes = InMemoryTable.Entity.snapshotChanges(table, committedCheckpointId, upToCheckpointId);
-    if (Utils.$$Array.isEmpty(changes)) {
-      return;
-    } else {
-      return {
+    if (Utils.$$Array.notEmpty(changes)) {
+      updatedEntities.push({
         entityConfig: entityConfig,
+        scope: scope,
         changes: changes
-      };
+      });
+      return;
     }
   });
   let updatedEffectsCache = snapshotEffects(state, cache);
@@ -179,7 +179,7 @@ function commitBatch(state, batch) {
 
 function dropCommitted(state, keepLoadedFromDb) {
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
-  IndexerState.allEntities(state).forEach(entityConfig => InMemoryTable.Entity.dropCommittedChanges(InMemoryStore.getInMemTable(state, entityConfig), committedCheckpointId, keepLoadedFromDb));
+  IndexerState.eachEntityTable(state, (param, param$1, table) => InMemoryTable.Entity.dropCommittedChanges(table, committedCheckpointId, keepLoadedFromDb));
   EffectState.forEach(IndexerState.effectState(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
 }