envio 3.15.0 → 3.16.0-subgraph

package/src/TestIndexer.res

@@ -53,11 +53,13 @@ let renderRows = (rows: array<AddressRows.row>, ~config: Config.t) =>
 
 // 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) =>
+let rowKey = (~table: Table.table, ~scope: Internal.chainScope, ~entityId: EntityId.t) => {
+  let entityKey = table.entityIdToKey(entityId)
   switch scope {
-  | CrossChain => entityId->EntityId.toKey
-  | Chain(chainId) => `${chainId->ChainId.toString}|${entityId->EntityId.toKey}`
+  | CrossChain => entityKey
+  | Chain(chainId) => `${chainId->ChainId.toString}|${entityKey}`
   }
+}
 
 let readChainId = (entity: Internal.entity, ~field: Table.field): option<ChainId.t> =>
   entity
@@ -158,19 +160,18 @@ let handleWriteBatch = (
       switch change {
       | Set({entityId, entity, checkpointId}) =>
         // 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.
+        // BigDecimal) work on real values.
         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)
+        entityDict->Dict.set(rowKey(~table=entityConfig.table, ~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, rowKey(~scope, ~entityId))
+        Dict.delete(entityDict->Obj.magic, rowKey(~table=entityConfig.table, ~scope, ~entityId))
         entityChangeFor(checkpointId).deleted->Array.push(entityId)->ignore
       }
     }
@@ -433,10 +434,15 @@ let getEntityFromState = (
     )
   }
   let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
+  let {entityIdToKey} = entityConfig.table
+  let key = entityIdToKey(entityId->EntityId.unsafeOfString)
   switch entityConfig.table->Table.getChainIdField {
-  | None => entityDict->Dict.get(entityId)->Option.map(copyEntity)
+  | None => entityDict->Dict.get(key)->Option.map(copyEntity)
   | Some(field) =>
-    let matches = entityDict->Dict.valuesToArray->Array.filter(entity => entity.id === entityId)
+    let matches =
+      entityDict
+      ->Dict.valuesToArray
+      ->Array.filter(entity => entityIdToKey(entity.id->EntityId.unsafeOfString) === key)
     switch matches {
     | [] => None
     | [entity] => Some(copyEntity(entity))
@@ -508,7 +514,7 @@ let makeEntitySet = (~state: testIndexerState, ~entityConfig: Internal.entityCon
       }
     }
     entityDict->Dict.set(
-      rowKey(~scope, ~entityId=entity.id->EntityId.unsafeOfString),
+      rowKey(~table=entityConfig.table, ~scope, ~entityId=entity.id->EntityId.unsafeOfString),
       copyEntity(entity),
     )
   }
@@ -568,13 +574,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   // The runner injects the config-derived initial state by setting
   // `persistence.storageStatus = Ready(...)` directly, bypassing `Persistence.init`,
   // so none of these is reached.
-  initialize: async (
-    ~chainConfigs as _=?,
-    ~entities as _=?,
-    ~enums as _=?,
-    ~contractMapping as _,
-    ~envioInfo as _,
-  ) =>
+  initialize: async (~chainConfigs as _=?, ~contractMapping as _, ~envioInfo as _) =>
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
@@ -582,11 +582,11 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: readStoredConfig should not be called; the initial state is derived from config.",
     ),
-  addChain: async (~chainConfig as _, ~entities as _, ~contractMapping as _) =>
+  addChain: async (~chainConfig as _, ~contractMapping as _) =>
     JsError.throwWithMessage(
       "TestIndexer: addChain should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async (~entities as _, ~chainIds as _, ~contractMapping as _) =>
+  resumeInitialState: async (~chainIds as _, ~contractMapping as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -596,13 +596,12 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     ->(Utils.magic: array<Internal.entity> => array<unknown>),
   // The in-memory storage has no indexes to build, and it's always ready.
   ensureQueryIndexes: async (~entityConfig as _, ~scope as _, ~filters as _) => (),
-  ensureSchemaIndexes: async (~entities as _, ~chainIds as _) => (),
-  finalizeBackfill: async (~entities as _, ~chainIds as _, ~readyAt as _) => (),
+  ensureSchemaIndexes: async (~chainIds as _) => (),
+  finalizeBackfill: async (~chainIds as _, ~readyAt as _) => (),
   writeBatch: async (
     ~batch,
     ~rollback as _,
     ~config,
-    ~allEntities as _,
     ~updatedEffectsCache as _,
     ~updatedEntities,
     ~registeredAddresses,
@@ -623,11 +622,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   setChainMeta: async _ => Obj.magic(),
   pruneStaleCheckpoints: async (~safeCheckpoints as _) => (),
   pruneStaleEntityHistory: async (~entityConfig as _, ~safeCheckpoints as _) => (),
-  getRollbackTargetCheckpoint: async (
-    ~reorgChainId as _,
-    ~lastKnownValidBlockNumber as _,
-    ~sequence as _,
-  ) =>
+  getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) =>
     JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable.",
     ),

package/src/TestIndexer.res.mjs

@@ -7,7 +7,6 @@ import * as Config from "./Config.res.mjs";
 import * as Logger from "./Logger.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
 import * as Frontier from "./db/Frontier.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
@@ -39,11 +38,12 @@ function renderRows(rows, config) {
   return AddressRows.render(rows, config.ecosystem.name, !config.lowercaseAddresses);
 }
 
-function rowKey(scope, entityId) {
+function rowKey(table, scope, entityId) {
+  let entityKey = table.entityIdToKey(entityId);
   if (scope === "crossChain") {
-    return EntityId.toKey(entityId);
+    return entityKey;
   } else {
-    return ChainId.toString(scope) + `|` + EntityId.toKey(entityId);
+    return ChainId.toString(scope) + `|` + entityKey;
   }
 }
 
@@ -126,12 +126,12 @@ function handleWriteBatch(state, config, updatedEntities, registeredAddresses, c
         let entity = change.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;
+        entityDict[rowKey(entityConfig.table, scope, change.entityId)] = storedEntity;
         entityChangeFor(change.checkpointId).sets.push(entity);
         return;
       }
       let entityId = change.entityId;
-      Stdlib_Dict.$$delete(entityDict, rowKey(scope, entityId));
+      Stdlib_Dict.$$delete(entityDict, rowKey(entityConfig.table, scope, entityId));
       entityChangeFor(change.checkpointId).deleted.push(entityId);
     };
     param.changes.forEach(processChange);
@@ -304,11 +304,14 @@ 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], {});
+  let match = entityConfig.table;
+  let entityIdToKey = match.entityIdToKey;
+  let key = entityIdToKey(entityId);
   let field = Table.getChainIdField(entityConfig.table);
   if (field === undefined) {
-    return Stdlib_Option.map(entityDict[entityId], copyEntity);
+    return Stdlib_Option.map(entityDict[key], copyEntity);
   }
-  let matches = Object.values(entityDict).filter(entity => entity.id === entityId);
+  let matches = Object.values(entityDict).filter(entity => entityIdToKey(entity.id) === key);
   let len = matches.length;
   if (len !== 1) {
     if (len === 0) {
@@ -358,7 +361,7 @@ function makeEntitySet(state, entityConfig) {
     } else {
       scope = "crossChain";
     }
-    entityDict[rowKey(scope, entity.id)] = Utils.Dict.shallowCopy(entity);
+    entityDict[rowKey(entityConfig.table, scope, entity.id)] = Utils.Dict.shallowCopy(entity);
   };
 }
 
@@ -388,23 +391,23 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     entityStoreName: param => "test-inmemory",
     holding: async () => "Initialized",
-    initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
+    initialize: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
     readStoredConfig: async () => Stdlib_JsError.throwWithMessage("TestIndexer: readStoredConfig should not be called; the initial state is derived from config."),
-    addChain: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: addChain should not be called; the initial state is derived from config."),
-    resumeInitialState: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
+    addChain: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: addChain should not be called; the initial state is derived from config."),
+    resumeInitialState: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1, param$2) => {},
-    ensureSchemaIndexes: async (param, param$1) => {},
-    finalizeBackfill: async (param, param$1, param$2) => {},
+    ensureSchemaIndexes: async param => {},
+    finalizeBackfill: async (param, param$1) => {},
     dumpEffectCache: async () => {},
     reset: async () => {},
     setChainMeta: async param => {},
     pruneStaleCheckpoints: async param => {},
     pruneStaleEntityHistory: async (param, param$1) => {},
-    getRollbackTargetCheckpoint: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
+    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."),
-    writeBatch: async (batch, param, config, param$1, param$2, updatedEntities, registeredAddresses, param$3, param$4) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
+    writeBatch: async (batch, param, config, param$1, updatedEntities, registeredAddresses, param$2, param$3) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
     close: async () => {}
   };
 }
@@ -648,7 +651,7 @@ function createTestIndexer() {
           let indexerState = IndexerState.makeFromDbState(runConfig, logger$1, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, undefined, errHandler => {
             ErrorHandling.log(errHandler);
             reject(ErrorHandling.toExn(errHandler));
-          }, () => resolve());
+          }, () => resolve(), undefined);
           indexerStateRef.contents = Primitive_option.some(indexerState);
           IndexerLoop.start(indexerState);
         });

package/src/Throttler.res

@@ -5,27 +5,30 @@ type t = {
   mutable scheduled: option<unit => promise<unit>>,
   intervalMillis: float,
   logger: Logger.t,
+  clock: Clock.t,
 }
 
-let make = (~intervalMillis: int, ~logger) => {
-  lastRunTimeMillis: 0.,
+let make = (~intervalMillis: int, ~logger, ~clock=Clock.real) => {
+  // A clock reads from its own origin, which the first run must not wait on.
+  lastRunTimeMillis: -.(intervalMillis->Int.toFloat),
   isRunning: false,
   isAwaitingInterval: false,
   scheduled: None,
   intervalMillis: intervalMillis->Int.toFloat,
   logger,
+  clock,
 }
 
 let rec startInternal = (throttler: t) => {
   switch throttler {
   | {scheduled: Some(fn), isRunning: false, isAwaitingInterval: false} =>
-    let timeSinceLastRun = Date.now() -. throttler.lastRunTimeMillis
+    let timeSinceLastRun = throttler.clock.now() -. throttler.lastRunTimeMillis
 
     //Only execute if we are passed the interval
     if timeSinceLastRun >= throttler.intervalMillis {
       throttler.isRunning = true
       throttler.scheduled = None
-      throttler.lastRunTimeMillis = Date.now()
+      throttler.lastRunTimeMillis = throttler.clock.now()
 
       // Defer off the schedule call so work queued before it (e.g. a batch) runs first.
       NodeJs.setImmediate(() => {
@@ -45,10 +48,14 @@ let rec startInternal = (throttler: t) => {
     } else {
       //Store isAwaitingInterval in state so that timers don't continuously get created
       throttler.isAwaitingInterval = true
-      let _ = setTimeout(() => {
-        throttler.isAwaitingInterval = false
-        throttler->startInternal
-      }, Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun))
+      let _ = throttler.clock.setTimeout(
+        ~label="throttled write",
+        () => {
+          throttler.isAwaitingInterval = false
+          throttler->startInternal
+        },
+        Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun),
+      )
     }
   | _ => ()
   }

package/src/Throttler.res.mjs

@@ -1,16 +1,19 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Clock from "./Clock.res.mjs";
 import * as Logger from "./Logger.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function make(intervalMillis, logger) {
+function make(intervalMillis, logger, clockOpt) {
+  let clock = clockOpt !== undefined ? clockOpt : Clock.real;
   return {
-    lastRunTimeMillis: 0,
+    lastRunTimeMillis: - intervalMillis,
     isRunning: false,
     isAwaitingInterval: false,
     scheduled: undefined,
     intervalMillis: intervalMillis,
-    logger: logger
+    logger: logger,
+    clock: clock
   };
 }
 
@@ -27,11 +30,11 @@ function startInternal(throttler) {
   if (fn === undefined) {
     return;
   }
-  let timeSinceLastRun = Date.now() - throttler.lastRunTimeMillis;
+  let timeSinceLastRun = throttler.clock.now() - throttler.lastRunTimeMillis;
   if (timeSinceLastRun >= throttler.intervalMillis) {
     throttler.isRunning = true;
     throttler.scheduled = undefined;
-    throttler.lastRunTimeMillis = Date.now();
+    throttler.lastRunTimeMillis = throttler.clock.now();
     setImmediate(() => {
       (async () => {
         try {
@@ -46,7 +49,7 @@ function startInternal(throttler) {
     });
   } else {
     throttler.isAwaitingInterval = true;
-    setTimeout(() => {
+    throttler.clock.setTimeout("throttled write", () => {
       throttler.isAwaitingInterval = false;
       startInternal(throttler);
     }, throttler.intervalMillis - timeSinceLastRun | 0);

package/src/Throttler.resi

@@ -15,7 +15,7 @@ Does NOT queue scheduled functions but rather overwrites them
 The logger will be used to log any errors that occur in the scheduled
 functions.
 */
-let make: (~intervalMillis: int, ~logger: Logger.t) => t
+let make: (~intervalMillis: int, ~logger: Logger.t, ~clock: Clock.t=?) => t
 
 /**
 Schedules a function to be run on a throttler, overwriting any