envio 3.15.0-subgraph → 3.16.0-subgraph

package/src/FinalizeBackfill.res.mjs

@@ -27,7 +27,7 @@ async function runOnce(state) {
   let persistence = IndexerState.persistence(state);
   let storage = Persistence.getInitializedStorageOrThrow(persistence);
   let readyAt = new Date();
-  await storage.finalizeBackfill(persistence.allEntities, chainIds, readyAt);
+  await storage.finalizeBackfill(chainIds, readyAt);
   return IndexerState.markReady(state, readyAt);
 }
 
@@ -42,9 +42,8 @@ function run(state) {
 }
 
 function repairSchemaIndexes(state) {
-  let persistence = IndexerState.persistence(state);
-  let storage = Persistence.getInitializedStorageOrThrow(persistence);
-  return storage.ensureSchemaIndexes(persistence.allEntities, CrossChainState.chainIds(IndexerState.crossChainState(state)));
+  let storage = Persistence.getInitializedStorageOrThrow(IndexerState.persistence(state));
+  return storage.ensureSchemaIndexes(CrossChainState.chainIds(IndexerState.crossChainState(state)));
 }
 
 export {

package/src/InMemoryTable.res

@@ -22,6 +22,8 @@ module Entity = {
   }
 
   type t = {
+    // Keys every id dict and Set below; see Table.table.
+    entityIdToKey: EntityId.t => string,
     latestEntityChangeById: dict<Change.t<Internal.entity>>,
     // Recorded changes (new latest ids + prevEntityChanges pushes), tracked
     // manually so InMemoryStore can gauge size without scanning every dict.
@@ -45,12 +47,9 @@ module Entity = {
     mutable hasIndexes: bool,
   }
 
-  // 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.
-  let getEntityIdUnsafe = (entity: Internal.entity): string =>
+  let getEntityKeyUnsafe = (self: t, entity: Internal.entity): string =>
     switch (entity->(Utils.magic: Internal.entity => {"id": option<EntityId.t>}))["id"] {
-    | Some(id) => id->EntityId.toKey
+    | Some(id) => self.entityIdToKey(id)
     | None => JsError.throwWithMessage("Property 'id' does not exist on expected entity object")
     }
 
@@ -62,7 +61,8 @@ module Entity = {
     }
   }
 
-  let make = (): t => {
+  let make = (~entityIdToKey): t => {
+    entityIdToKey,
     latestEntityChangeById: Dict.make(),
     changesCount: 0.,
     dirtyIds: Utils.Set.make(),
@@ -141,10 +141,8 @@ module Entity = {
     self.hasIndexes = false
   }
 
-  let updateIndexes = (self: t, ~entity: Internal.entity) =>
+  let updateIndexes = (self: t, ~entityId: string, ~entity: Internal.entity) =>
     if self.hasIndexes {
-      let entityId = entity->getEntityIdUnsafe
-
       switch self.indexesByEntityId->Utils.Dict.dangerouslyGetNonOption(entityId) {
       | None => ()
       | Some(indexes) =>
@@ -185,7 +183,7 @@ module Entity = {
     }
 
   let set = (inMemTable: t, ~committedCheckpointId, change: Change.t<Internal.entity>) => {
-    let entityKey = change->Change.getEntityId->EntityId.toKey
+    let entityKey = inMemTable.entityIdToKey(change->Change.getEntityId)
     switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(entityKey) {
     | Some(prev) =>
       let prevCheckpointId = prev->Change.getCheckpointId
@@ -200,8 +198,8 @@ module Entity = {
     }
 
     switch change {
-    | Set({entity}) => inMemTable->updateIndexes(~entity)
-    | Delete({entityId}) => inMemTable->deleteEntityFromIndexes(~entityId=entityId->EntityId.toKey)
+    | Set({entity}) => inMemTable->updateIndexes(~entityId=entityKey, ~entity)
+    | Delete(_) => inMemTable->deleteEntityFromIndexes(~entityId=entityKey)
     }
     inMemTable.latestEntityChangeById->Dict.set(entityKey, change)
     if change->Change.getCheckpointId > committedCheckpointId {
@@ -214,11 +212,14 @@ module Entity = {
   let initValue = (
     inMemTable: t,
     ~committedCheckpointId,
-    ~key: string,
+    ~entityId: EntityId.t,
     ~entity: option<Internal.entity>,
   ) =>
-    if inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(key)->Option.isNone {
-      let entityId = key->EntityId.unsafeOfString
+    if (
+      inMemTable.latestEntityChangeById
+      ->Utils.Dict.dangerouslyGetNonOption(inMemTable.entityIdToKey(entityId))
+      ->Option.isNone
+    ) {
       let change: Change.t<Internal.entity> = switch entity {
       | Some(entity) => Set({entityId, entity, checkpointId: Internal.loadedFromDbCheckpointId})
       | None => Delete({entityId, checkpointId: Internal.loadedFromDbCheckpointId})
@@ -312,7 +313,7 @@ module Entity = {
         switch change->mapChangeToEntity {
         | Some(entity) =>
           if index.matcher(entity) {
-            inMemTable->addToIndex(~index, ~entityId=entity->getEntityIdUnsafe)
+            inMemTable->addToIndex(~index, ~entityId=inMemTable->getEntityKeyUnsafe(entity))
           }
         | None => ()
         }

package/src/InMemoryTable.res.mjs

@@ -1,7 +1,6 @@
 // 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";
@@ -9,10 +8,10 @@ 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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
-function getEntityIdUnsafe(entity) {
+function getEntityKeyUnsafe(self, entity) {
   let id = entity.id;
   if (id !== undefined) {
-    return EntityId.toKey(Primitive_option.valFromOption(id));
+    return self.entityIdToKey(Primitive_option.valFromOption(id));
   } else {
     return Stdlib_JsError.throwWithMessage("Property 'id' does not exist on expected entity object");
   }
@@ -28,8 +27,9 @@ function addToIndex(self, index, entityId) {
   }
 }
 
-function make() {
+function make(entityIdToKey) {
   return {
+    entityIdToKey: entityIdToKey,
     latestEntityChangeById: {},
     changesCount: 0,
     dirtyIds: new Set(),
@@ -99,11 +99,10 @@ function dropCommittedChanges(self, committedCheckpointId, keepLoadedFromDb) {
   self.hasIndexes = false;
 }
 
-function updateIndexes(self, entity) {
+function updateIndexes(self, entityId, entity) {
   if (!self.hasIndexes) {
     return;
   }
-  let entityId = getEntityIdUnsafe(entity);
   let indexes = self.indexesByEntityId[entityId];
   if (indexes !== undefined) {
     let indexes$1 = Primitive_option.valFromOption(indexes);
@@ -144,7 +143,7 @@ function deleteEntityFromIndexes(self, entityId) {
 }
 
 function set(inMemTable, committedCheckpointId, change) {
-  let entityKey = EntityId.toKey(change.entityId);
+  let entityKey = inMemTable.entityIdToKey(change.entityId);
   let prev = inMemTable.latestEntityChangeById[entityKey];
   if (prev !== undefined) {
     let prevCheckpointId = prev.checkpointId;
@@ -156,9 +155,9 @@ function set(inMemTable, committedCheckpointId, change) {
     inMemTable.changesCount = inMemTable.changesCount + 1;
   }
   if (change.type === "SET") {
-    updateIndexes(inMemTable, change.entity);
+    updateIndexes(inMemTable, entityKey, change.entity);
   } else {
-    deleteEntityFromIndexes(inMemTable, EntityId.toKey(change.entityId));
+    deleteEntityFromIndexes(inMemTable, entityKey);
   }
   inMemTable.latestEntityChangeById[entityKey] = change;
   if (change.checkpointId > committedCheckpointId) {
@@ -167,18 +166,18 @@ function set(inMemTable, committedCheckpointId, change) {
   }
 }
 
-function initValue(inMemTable, committedCheckpointId, key, entity) {
-  if (!Stdlib_Option.isNone(inMemTable.latestEntityChangeById[key])) {
+function initValue(inMemTable, committedCheckpointId, entityId, entity) {
+  if (!Stdlib_Option.isNone(inMemTable.latestEntityChangeById[inMemTable.entityIdToKey(entityId)])) {
     return;
   }
   let change = entity !== undefined ? ({
       type: "SET",
-      entityId: key,
+      entityId: entityId,
       entity: entity,
       checkpointId: Internal.loadedFromDbCheckpointId
     }) : ({
       type: "DELETE",
-      entityId: key,
+      entityId: entityId,
       checkpointId: Internal.loadedFromDbCheckpointId
     });
   set(inMemTable, committedCheckpointId, change);
@@ -285,7 +284,7 @@ function addEmptyIndex(inMemTable, filter, table) {
   Utils.Dict.forEach(inMemTable.latestEntityChangeById, change => {
     let entity = mapChangeToEntity(change);
     if (entity !== undefined && index_matcher(entity)) {
-      return addToIndex(inMemTable, index, getEntityIdUnsafe(entity));
+      return addToIndex(inMemTable, index, getEntityKeyUnsafe(inMemTable, entity));
     }
   });
 }
@@ -321,7 +320,7 @@ function tryIndexFromLoadedValues(inMemTable, filter, table) {
 }
 
 let Entity = {
-  getEntityIdUnsafe: getEntityIdUnsafe,
+  getEntityKeyUnsafe: getEntityKeyUnsafe,
   addToIndex: addToIndex,
   make: make,
   snapshotChanges: snapshotChanges,

package/src/IndexerState.res

@@ -108,6 +108,12 @@ type t = {
   // in-process test runner injects a callback that resolves its run promise
   // instead, so a caught-up run doesn't kill the test process.
   onExit: option<unit => unit>,
+  // Told, in the processing pass that gets it there, that a run holding its
+  // realtime transitions has gone as far as it can on its own. The test
+  // runner's stand-in supervisor releases from it, so the release lands at a
+  // point in the indexer's own progress rather than on a timer.
+  onArrivedAtHead: option<unit => unit>,
+  mutable reportedArrivalAtHead: bool,
   // Set once on any fatal error. Every loop checks it to stop iterating and
   // every launch skips when it's set, so a single failure quiesces the indexer.
   mutable isStopped: bool,
@@ -157,10 +163,13 @@ let make = (
   ~exitAfterFirstEventBlock=false,
   ~onError: ErrorHandling.t => unit,
   ~onExit=?,
+  ~onArrivedAtHead=?,
+  ~clock=Clock.real,
 ) => {
   let chainMetaThrottler = {
     let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis
     Throttler.make(
+      ~clock,
       ~intervalMillis,
       ~logger=logger->Logger.withFields({
         "context": "Throttler for chain metadata writes",
@@ -175,7 +184,7 @@ let make = (
     persistence,
     allEntities: persistence.allEntities,
     entities: EntityTables.make(persistence.allEntities->EntityTables.crossChain),
-    effectState: EffectState.make(),
+    effectState: EffectState.make(~clock, ()),
     rollback: None,
     committedFrontier,
     processedFrontier: committedFrontier->Frontier.copy,
@@ -205,6 +214,8 @@ let make = (
     exitAfterFirstEventBlock,
     onError,
     onExit,
+    onArrivedAtHead,
+    reportedArrivalAtHead: false,
     isStopped: false,
     epoch: 0,
     simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
@@ -225,12 +236,13 @@ let make = (
 }
 
 // Check if progress is past the reorg threshold (safe block).
-// A chain is in reorg threshold when progressBlockNumber > sourceBlockNumber - maxReorgDepth.
-// This matches the logic in InternalTable.Checkpoints.makeGetReorgCheckpointsQuery.
+// A chain is in reorg threshold once its progress passes the safe block,
+// sourceBlockNumber - maxReorgDepth - 1. This matches the reorg checkpoints
+// query in packages/cli/src/postgres/internal.rs.
 let isProgressInReorgThreshold = (~progressBlockNumber, ~sourceBlockNumber, ~maxReorgDepth) => {
   maxReorgDepth > 0 &&
   sourceBlockNumber > 0 &&
-  progressBlockNumber > sourceBlockNumber - maxReorgDepth
+  progressBlockNumber > sourceBlockNumber - maxReorgDepth - 1
 }
 
 let makeFromDbState = (
@@ -249,6 +261,7 @@ let makeFromDbState = (
   ~holdRealtime=false,
   ~onError,
   ~onExit=?,
+  ~onArrivedAtHead=?,
 ) => {
   let isInReorgThreshold = if initialState.cleanRun {
     false
@@ -303,6 +316,8 @@ let makeFromDbState = (
     ~exitAfterFirstEventBlock,
     ~onError,
     ~onExit?,
+    ~onArrivedAtHead?,
+    ~clock=?sourceTiming->Option.flatMap(timing => timing.clock),
   )
   state.crossChainState->CrossChainState.markCaughtUpOnResume
   initialState.cache->Utils.Dict.forEach(({effectName, count, scope}) => {
@@ -559,6 +574,15 @@ let isHoldingRealtime = (state: t) => state.crossChainState->CrossChainState.isH
 
 let hasArrivedAtHead = (state: t) => state.crossChainState->CrossChainState.hasArrivedAtHead
 
+let reportArrivalAtHead = (state: t) =>
+  switch state.onArrivedAtHead {
+  | Some(onArrivedAtHead)
+    if !state.reportedArrivalAtHead && state->isHoldingRealtime && state->hasArrivedAtHead =>
+    state.reportedArrivalAtHead = true
+    onArrivedAtHead()
+  | _ => ()
+  }
+
 let releaseRealtime = (state: t) => {
   state.crossChainState->CrossChainState.releaseRealtime
   // Every chain is parked at the head with no batch coming, so nothing would

package/src/IndexerState.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Batch from "./Batch.res.mjs";
+import * as Clock from "./Clock.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logger from "./Logger.res.mjs";
@@ -26,25 +27,26 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
-function make(config, logger, persistence, chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt, committedFrontierOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
+function make(config, logger, persistence, chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt, committedFrontierOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit, onArrivedAtHead, clockOpt) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let holdRealtime = holdRealtimeOpt !== undefined ? holdRealtimeOpt : false;
   let committedFrontier = committedFrontierOpt !== undefined ? committedFrontierOpt : Frontier.empty();
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
+  let clock = clockOpt !== undefined ? clockOpt : Clock.real;
   let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis;
   let chainMetaThrottler = Throttler.make(intervalMillis, Logger.withFields(logger, {
     context: "Throttler for chain metadata writes",
     intervalMillis: intervalMillis
-  }));
+  }), clock);
   return {
     config: config,
     logger: logger,
     persistence: persistence,
     allEntities: persistence.allEntities,
     entities: EntityTables.make(EntityTables.crossChain(persistence.allEntities)),
-    effectState: EffectState.make(),
+    effectState: EffectState.make(clock, undefined),
     rollback: undefined,
     committedFrontier: committedFrontier,
     processedFrontier: Frontier.copy(committedFrontier),
@@ -68,6 +70,8 @@ function make(config, logger, persistence, chainStates, isRealtime, targetBuffer
     exitAfterFirstEventBlock: exitAfterFirstEventBlock,
     onError: onError,
     onExit: onExit,
+    onArrivedAtHead: onArrivedAtHead,
+    reportedArrivalAtHead: false,
     isStopped: false,
     epoch: 0,
     scheduleProcessing: () => {},
@@ -88,7 +92,7 @@ function make(config, logger, persistence, chainStates, isRealtime, targetBuffer
   };
 }
 
-function makeFromDbState(config, logger, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, sourceTiming, targetBufferSizeOpt, holdRealtimeOpt, onError, onExit) {
+function makeFromDbState(config, logger, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, sourceTiming, targetBufferSizeOpt, holdRealtimeOpt, onError, onExit, onArrivedAtHead) {
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
@@ -99,7 +103,7 @@ function makeFromDbState(config, logger, persistence, initialState, registration
       let sourceBlockNumber = resumedChainState.sourceBlockNumber;
       let maxReorgDepth = resumedChainState.maxReorgDepth;
       if (maxReorgDepth > 0 && sourceBlockNumber > 0) {
-        return progressBlockNumber > (sourceBlockNumber - maxReorgDepth | 0);
+        return progressBlockNumber > ((sourceBlockNumber - maxReorgDepth | 0) - 1 | 0);
       } else {
         return false;
       }
@@ -111,7 +115,7 @@ function makeFromDbState(config, logger, persistence, initialState, registration
     let chainConfig = ChainMap.get(config.chainMap, chainId);
     chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, initialState.contractMapping, registrationsByChainId, logger, sourceTiming);
   });
-  let state = make(config, logger, persistence, chainStates, isRealtime, targetBufferSize, holdRealtime, initialState.checkpointFrontier, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
+  let state = make(config, logger, persistence, chainStates, isRealtime, targetBufferSize, holdRealtime, initialState.checkpointFrontier, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit, onArrivedAtHead, Stdlib_Option.flatMap(sourceTiming, timing => timing.clock));
   CrossChainState.markCaughtUpOnResume(state.crossChainState);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
@@ -401,6 +405,14 @@ function hasArrivedAtHead(state) {
   return CrossChainState.hasArrivedAtHead(state.crossChainState);
 }
 
+function reportArrivalAtHead(state) {
+  let onArrivedAtHead = state.onArrivedAtHead;
+  if (onArrivedAtHead !== undefined && !state.reportedArrivalAtHead && CrossChainState.isHoldingRealtime(state.crossChainState) && CrossChainState.hasArrivedAtHead(state.crossChainState)) {
+    state.reportedArrivalAtHead = true;
+    return onArrivedAtHead();
+  }
+}
+
 function releaseRealtime(state) {
   CrossChainState.releaseRealtime(state.crossChainState);
   state.scheduleProcessing();
@@ -917,6 +929,7 @@ export {
   bindScheduleProcessing,
   isHoldingRealtime,
   hasArrivedAtHead,
+  reportArrivalAtHead,
   releaseRealtime,
   markReady,
   reportFinished,

package/src/IndexerState.resi

@@ -24,6 +24,8 @@ let make: (
   ~exitAfterFirstEventBlock: bool=?,
   ~onError: ErrorHandling.t => unit,
   ~onExit: unit => unit=?,
+  ~onArrivedAtHead: unit => unit=?,
+  ~clock: Clock.t=?,
 ) => t
 
 let makeFromDbState: (
@@ -40,6 +42,7 @@ let makeFromDbState: (
   ~holdRealtime: bool=?,
   ~onError: ErrorHandling.t => unit,
   ~onExit: unit => unit=?,
+  ~onArrivedAtHead: unit => unit=?,
 ) => t
 
 let unexpectedErrorMsg: string
@@ -106,6 +109,7 @@ let shouldFinalizeIndexes: t => bool
 let bindScheduleProcessing: (t, unit => unit) => unit
 let isHoldingRealtime: t => bool
 let hasArrivedAtHead: t => bool
+let reportArrivalAtHead: t => unit
 // The supervisor's go-ahead for a process driving part of a split run.
 let releaseRealtime: t => unit
 let markReady: (t, ~readyAt: Date.t) => unit

package/src/Internal.res

@@ -1011,55 +1011,6 @@ module EffectCache = {
     | CrossChain => cacheTablePrefix ++ effectName
     | Chain(chainId) => `envio_${chainId->ChainId.toString}_effect_${effectName}`
     }
-
-  // Only accepts a canonical decimal chain id ("7", not "007" or "1foo") —
-  // the schema's parser follows parseFloat semantics and accepts both.
-  let parseChainId = str =>
-    switch try Some(str->ChainId.normalizeOrThrow) catch {
-    | _ => None
-    } {
-    | Some(chainId) if chainId->ChainId.toString === str => Some(chainId)
-    | _ => None
-    }
-
-  let chainScopedRe = /^envio_([0-9]+)_effect_(.+)$/
-  let crossChainRe = /^envio_effect_(.+)$/
-
-  // Inverse of toTableName. Returns None for any table name that isn't a cache
-  // table. Chain-scoped is tried first: the `_effect_` separator keeps effect
-  // names that themselves start with digits unambiguous.
-  let fromTableName = (tableName): option<(string, chainScope)> =>
-    switch RegExp.exec(chainScopedRe, tableName) {
-    | Some(result) =>
-      switch (
-        RegExp.Result.matches(result)->Array.get(0),
-        RegExp.Result.matches(result)->Array.get(1),
-      ) {
-      | (Some(Some(chainIdStr)), Some(Some(effectName))) =>
-        switch parseChainId(chainIdStr) {
-        | Some(chainId) => Some((effectName, Chain(chainId)))
-        | None => None
-        }
-      | _ => None
-      }
-    | None =>
-      switch RegExp.exec(crossChainRe, tableName) {
-      | Some(result) =>
-        switch RegExp.Result.matches(result)->Array.get(0) {
-        | Some(Some(effectName)) => Some((effectName, CrossChain))
-        | _ => None
-        }
-      | None => None
-      }
-    }
-
-  // Relative posix path within .envio/cache. Chain-scoped caches live one
-  // directory level deep, named by chain id.
-  let toCachePath = (~effectName, ~scope) =>
-    switch scope {
-    | CrossChain => effectName ++ ".tsv"
-    | Chain(chainId) => `${chainId->ChainId.toString}/${effectName}.tsv`
-    }
 }
 
 let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<JSON.t> => S.t<effectOutput>)

package/src/Internal.res.mjs

@@ -271,87 +271,8 @@ function toTableName(effectName, scope) {
   }
 }
 
-function parseChainId(str) {
-  let chainId;
-  try {
-    chainId = Primitive_option.some(ChainId.normalizeOrThrow(str));
-  } catch (exn) {
-    chainId = undefined;
-  }
-  if (chainId === undefined) {
-    return;
-  }
-  let chainId$1 = Primitive_option.valFromOption(chainId);
-  if (ChainId.toString(chainId$1) === str) {
-    return Primitive_option.some(chainId$1);
-  }
-}
-
-let chainScopedRe = /^envio_([0-9]+)_effect_(.+)$/;
-
-let crossChainRe = /^envio_effect_(.+)$/;
-
-function fromTableName(tableName) {
-  let result = chainScopedRe.exec(tableName);
-  if (result == null) {
-    let result$1 = crossChainRe.exec(tableName);
-    if (result$1 == null) {
-      return;
-    }
-    let match = result$1.slice(1)[0];
-    if (match === undefined) {
-      return;
-    }
-    let effectName = Primitive_option.valFromOption(match);
-    if (effectName !== undefined) {
-      return [
-        effectName,
-        "crossChain"
-      ];
-    } else {
-      return;
-    }
-  }
-  let match$1 = result.slice(1)[0];
-  let match$2 = result.slice(1)[1];
-  if (match$1 === undefined) {
-    return;
-  }
-  let chainIdStr = Primitive_option.valFromOption(match$1);
-  if (chainIdStr === undefined) {
-    return;
-  }
-  if (match$2 === undefined) {
-    return;
-  }
-  let effectName$1 = Primitive_option.valFromOption(match$2);
-  if (effectName$1 === undefined) {
-    return;
-  }
-  let chainId = parseChainId(chainIdStr);
-  if (chainId !== undefined) {
-    return [
-      effectName$1,
-      Primitive_option.valFromOption(chainId)
-    ];
-  }
-}
-
-function toCachePath(effectName, scope) {
-  if (scope === "crossChain") {
-    return effectName + ".tsv";
-  } else {
-    return ChainId.toString(scope) + `/` + effectName + `.tsv`;
-  }
-}
-
 let EffectCache = {
-  toTableName: toTableName,
-  parseChainId: parseChainId,
-  chainScopedRe: chainScopedRe,
-  crossChainRe: crossChainRe,
-  fromTableName: fromTableName,
-  toCachePath: toCachePath
+  toTableName: toTableName
 };
 
 let cacheOutputSchema = S$RescriptSchema.json(false);

package/src/LoadLayer.res

@@ -16,7 +16,12 @@ let loadById = (
   ~entityId,
 ) => {
   let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(entityId) {
+  // The ids here are typed as strings but hold whatever scalar the id is.
+  let entityIdToKey =
+    inMemTable.entityIdToKey->(Utils.magic: (EntityId.t => string) => string => string)
+  switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(
+    entityIdToKey(entityId),
+  ) {
   // A row already in memory is final, so even a grouped call skips the load
   // manager: grouping it would only resolve it a tick later to the same value.
   | Some(change) => Promise.resolve(change->InMemoryTable.Entity.mapChangeToEntity)
@@ -53,14 +58,14 @@ let loadById = (
       //Set the entity in the in memory store
       for idx in 0 to dbEntities->Array.length - 1 {
         let entity = dbEntities->Array.getUnsafe(idx)
-        entitiesMap->Dict.set(entity.id, entity)
+        entitiesMap->Dict.set(entityIdToKey(entity.id), entity)
       }
       let committedCheckpointId = indexerState->IndexerState.committedCheckpointIdFor(~scope)
       idsToLoad->Array.forEach(entityId => {
         inMemTable->InMemoryTable.Entity.initValue(
           ~committedCheckpointId,
-          ~key=entityId,
-          ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityId),
+          ~entityId=entityId->EntityId.unsafeOfString,
+          ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityIdToKey(entityId)),
         )
       })
 
@@ -77,7 +82,7 @@ let loadById = (
       ~key,
       ~load,
       ~shouldGroup,
-      ~hasher=LoadManager.noopHasher,
+      ~hasher=entityIdToKey,
       ~getUnsafeInMemory=inMemTable->InMemoryTable.Entity.getUnsafe,
       ~hasInMemory=hash => inMemTable.latestEntityChangeById->Dict.has(hash),
       ~input=entityId,
@@ -140,7 +145,7 @@ let rec executeWithRateLimit = (
     }
 
   | Some(state) =>
-    let now = Date.now()
+    let now = state.clock.now()
 
     // Check if we need to reset the window
     if now >= state.windowStartTime +. state.durationMs->Int.toFloat {
@@ -188,7 +193,8 @@ let rec executeWithRateLimit = (
       | None =>
         millisUntilReset :=
           (state.windowStartTime +. state.durationMs->Int.toFloat -. now)->Float.toInt
-        let p = Utils.delay(millisUntilReset.contents)
+        let p =
+          state.clock->Clock.delay(~label="effect rate limit window", millisUntilReset.contents)
         state.nextWindowPromise = Some(p)
         p
       }
@@ -355,8 +361,9 @@ let getByIdInMemory = (
   ~entityId: string,
 ) => {
   let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  inMemTable.latestEntityChangeById->Dict.has(entityId)
-    ? Some((inMemTable->InMemoryTable.Entity.getUnsafe)(entityId))
+  let entityKey = inMemTable.entityIdToKey(entityId->EntityId.unsafeOfString)
+  inMemTable.latestEntityChangeById->Dict.has(entityKey)
+    ? Some((inMemTable->InMemoryTable.Entity.getUnsafe)(entityKey))
     : None
 }
 
@@ -425,7 +432,7 @@ let loadByParsedFilter = (
         entities->Array.forEach(entity => {
           inMemTable->InMemoryTable.Entity.initValue(
             ~committedCheckpointId,
-            ~key=entity.id,
+            ~entityId=entity.id->EntityId.unsafeOfString,
             ~entity=Some(entity),
           )
         })