envio 3.15.0-subgraph → 3.16.0-subgraph

package/src/Clock.res.mjs

@@ -0,0 +1,72 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Performance from "./bindings/Performance.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let refuseReal = {
+  contents: false
+};
+
+function refused(what) {
+  return Stdlib_JsError.throwWithMessage(`Clock.real ` + what + ` on virtual time. Use the clock the code was given, so advanceTime can see and move it.`);
+}
+
+function real_now() {
+  if (refuseReal.contents) {
+    return refused("read the time");
+  } else {
+    return Performance.now();
+  }
+}
+
+function real_setTimeout(label, callback, millis) {
+  if (refuseReal.contents && millis > 0) {
+    return refused(`armed "` + label + `"`);
+  } else {
+    return setTimeout(callback, millis);
+  }
+}
+
+function real_clearTimeout(timer) {
+  clearTimeout(timer);
+}
+
+function real_random(prim) {
+  return Math.random();
+}
+
+let real = {
+  now: real_now,
+  setTimeout: real_setTimeout,
+  clearTimeout: real_clearTimeout,
+  random: real_random
+};
+
+function delay(clock, label, millis) {
+  return new Promise((resolve, _reject) => {
+    clock.setTimeout(label, () => resolve(), millis);
+  });
+}
+
+function jitter(clock, delay) {
+  return (delay / 2 | 0) + (clock.random() * (delay / 2 | 0) | 0) | 0;
+}
+
+function clearRef(clock, timer) {
+  let timer$1 = timer.contents;
+  if (timer$1 !== undefined) {
+    clock.clearTimeout(Primitive_option.valFromOption(timer$1));
+  }
+  timer.contents = undefined;
+}
+
+export {
+  refuseReal,
+  refused,
+  real,
+  delay,
+  jitter,
+  clearRef,
+}
+/* No side effect */

package/src/Config.res

@@ -1079,15 +1079,19 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
-        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        // One less than the 200 blocks behind the head a source checks for a
+        // lagging node, so the backfill, which stops one block below the window,
+        // ends exactly where those checks begin.
+        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(199)
         // Tower BFT roots a block once 32 votes lock it in (MAX_LOCKOUT_HISTORY
         // is 31, plus the slot itself), which is what `finalized` waits for — so
         // 32 is the protocol's own bound on how far a fork can be replaced. That
         // bound counts *blocks* while the threshold here is measured in slot
         // numbers, and skipped slots make the slot distance the larger of the
         // two, so the default keeps a wide margin over it. Slots are ~0.4s, so
-        // even this spans well under two minutes of chain.
-        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        // even this spans well under two minutes of chain. One less than 200
+        // for the same reason as EVM: the backfill stops one slot below it.
+        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(199)
         | Ecosystem.Fuel => 0
         },
         blockLag: publicChainConfig["blockLag"]->Option.getOr(0),
@@ -1156,8 +1160,16 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => []
   }
 
-  if publicConfig["subgraph"]->Option.isSome {
+  switch publicConfig["subgraph"] {
+  | Some(subgraph) =>
     Env.subgraphMode := true
+    Env.subgraphHasTemplates :=
+      subgraph
+      ->JSON.Decode.object
+      ->Option.flatMap(manifest => manifest->Dict.get("templates"))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.mapOr(false, templates => templates->Array.length > 0)
+  | None => ()
   }
 
   let config = {

package/src/Config.res.mjs

@@ -765,7 +765,7 @@ function fromPublic(publicConfigJson) {
         break;
       case "evm" :
       case "svm" :
-        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 200);
+        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 199);
         break;
     }
     return {
@@ -810,8 +810,10 @@ function fromPublic(publicConfigJson) {
       name: Utils.$$String.capitalize(param[0]),
       handler: param[1].handler
     })) : [];
-  if (Stdlib_Option.isSome(publicConfig.subgraph)) {
+  let subgraph = publicConfig.subgraph;
+  if (subgraph !== undefined) {
     Env.subgraphMode.contents = true;
+    Env.subgraphHasTemplates.contents = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(subgraph), manifest => manifest["templates"]), Stdlib_JSON.Decode.array), false, templates => templates.length !== 0);
   }
   let config_name = publicConfig.name;
   let config_description = publicConfig.description;
@@ -981,7 +983,7 @@ function diffPaths(stored, current) {
         }
         return;
       }
-    } else {
+    } else if (s !== null) {
       switch (typeof s) {
         case "object" :
           if (typeof c === "object" && c !== null && !Array.isArray(c)) {

package/src/Core.res

@@ -18,6 +18,8 @@ type loggerCtor
 type mockHyperSyncServerCtor
 // Test-only: the ledger behind envio-tests' MockSource.
 type mockSourceCtor
+// Test-only: the virtual clock a scenario's source layer runs on.
+type virtualClockCtor
 type fromUserApiOptions = {
   schema?: string,
   env?: dict<string>,
@@ -48,46 +50,6 @@ type filledGeneratedFile = {
   undeclared: bool,
 }
 
-// One column of a Postgres table, flattened for the boundary: napi carries no
-// tagged union, so the field type arrives as its name plus whichever of the
-// modifiers it takes.
-type pgColumnInput = {
-  // The database column name, renames already resolved.
-  name: string,
-  fieldType: string,
-  isArray: bool,
-  isNullable: bool,
-  isPrimaryKey: bool,
-  defaultValue?: string,
-  precision?: int,
-  scale?: int,
-  enumName?: string,
-}
-
-type pgTableInput = {
-  // In the order the table declares them.
-  columns: array<pgColumnInput>,
-  // The columns a batch's rows carry, in the order they are laid out.
-  writeColumns: array<string>,
-  partitionByColumn?: string,
-  appendOnly: bool,
-  // An entity's history table, and the column its chain is in when it is
-  // per-chain.
-  historyTable?: string,
-  chainIdColumn?: string,
-}
-
-type pgIndexColumnInput = {
-  name: string,
-  direction: string,
-}
-
-type pgIndexInput = {
-  tableName: string,
-  columns: array<pgIndexColumnInput>,
-  method: string,
-}
-
 type addon = {
   getConfigJson: (
     ~configPath: Null.t<string>,
@@ -142,6 +104,8 @@ type addon = {
   mockHyperSyncServer: mockHyperSyncServerCtor,
   @as("MockSource")
   mockSource: mockSourceCtor,
+  @as("VirtualClock")
+  virtualClock: virtualClockCtor,
   encodeAddresses: (~ecosystem: string, ~addresses: array<Address.t>) => array<NodeJs.Buffer.t>,
   normalizeEvmAddress: (~address: string, ~shouldChecksum: bool) => Null.t<Address.t>,
   renderAddresses: (

package/src/CrossChainState.res

@@ -25,16 +25,20 @@ type t = {
 }
 
 // The whole-indexer fetch buffer pool, independent of chain count. A subgraph
-// run keeps far more per fetched event than a handler run does: the payload
-// with its transaction and block fields, a register pass with its pending
-// contract calls, and (for a chain kept open by a template) responses well past
-// the block the handlers are at. Venus on BSC held 100k of them and its heap
-// passed 4 GB, so the default there is a tenth of that.
+// with templates keeps far more per fetched event than a handler run does: a
+// register pass with its pending contract calls, and (for a chain kept open by
+// a template) responses well past the block the handlers are at. Venus on BSC
+// held 100k of them and its heap passed 4 GB, so the default there is a tenth
+// of that. Without templates there is neither, and a pool that small leaves
+// one query in flight at a time: fetching stops overlapping processing.
 let defaultSubgraphTargetBufferSize = 10_000
 let calculateTargetBufferSize = () =>
   switch Env.targetBufferSize {
   | Some(size) => size
-  | None => Env.subgraphMode.contents ? defaultSubgraphTargetBufferSize : 100_000
+  | None =>
+    Env.subgraphMode.contents && Env.subgraphHasTemplates.contents
+      ? defaultSubgraphTargetBufferSize
+      : 100_000
   }
 
 let make = (

package/src/CrossChainState.res.mjs

@@ -15,7 +15,7 @@ import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 function calculateTargetBufferSize() {
   if (Env.targetBufferSize !== undefined) {
     return Env.targetBufferSize;
-  } else if (Env.subgraphMode.contents) {
+  } else if (Env.subgraphMode.contents && Env.subgraphHasTemplates.contents) {
     return 10000;
   } else {
     return 100000;

package/src/EffectState.res

@@ -11,6 +11,8 @@ type effectRateLimitState = {
   mutable availableCalls: int,
   mutable windowStartTime: float,
   mutable nextWindowPromise: option<promise<unit>>,
+  // The run's clock: a test on virtual time opens the next window by advancing.
+  clock: Clock.t,
 }
 
 // Per-(effect, scope) counters rendered into the envio_effect_* metrics. Live
@@ -80,9 +82,14 @@ type t = {
   // rollback; stats and the rate-limit window survive because the table does.
   tables: dict<effectCacheInMemTable>,
   unregisteredCacheCounts: dict<unregisteredCacheCount>,
+  clock: Clock.t,
 }
 
-let make = (): t => {tables: Dict.make(), unregisteredCacheCounts: Dict.make()}
+let make = (~clock=Clock.real, ()): t => {
+  tables: Dict.make(),
+  unregisteredCacheCounts: Dict.make(),
+  clock,
+}
 
 let setUnregisteredCacheCount = (self: t, ~effectName, ~scope, ~count) => {
   let tableName = Internal.EffectCache.toTableName(~effectName, ~scope)
@@ -214,8 +221,9 @@ let getTable = (self: t, ~effect: Internal.effect, ~scope: Internal.chainScope)
         callsPerDuration,
         durationMs,
         availableCalls: callsPerDuration,
-        windowStartTime: Date.now(),
+        windowStartTime: self.clock.now(),
         nextWindowPromise: None,
+        clock: self.clock,
       })
     }
     let inMemTable: effectCacheInMemTable = {

package/src/EffectState.res.mjs

@@ -1,13 +1,16 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Clock from "./Clock.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 
-function make() {
+function make(clockOpt, param) {
+  let clock = clockOpt !== undefined ? clockOpt : Clock.real;
   return {
     tables: {},
-    unregisteredCacheCounts: {}
+    unregisteredCacheCounts: {},
+    clock: clock
   };
 }
 
@@ -130,8 +133,9 @@ function getTable(self, effect, scope) {
       callsPerDuration: callsPerDuration,
       durationMs: match$1.durationMs,
       availableCalls: callsPerDuration,
-      windowStartTime: Date.now(),
-      nextWindowPromise: undefined
+      windowStartTime: self.clock.now(),
+      nextWindowPromise: undefined,
+      clock: self.clock
     };
   } else {
     rateLimitState = undefined;

package/src/EffectState.resi

@@ -4,6 +4,8 @@ type effectRateLimitState = {
   mutable availableCalls: int,
   mutable windowStartTime: float,
   mutable nextWindowPromise: option<promise<unit>>,
+  // The run's clock: a test on virtual time opens the next window by advancing.
+  clock: Clock.t,
 }
 
 // Per-(effect, scope) metric counters. Survive rollback so they stay monotonic.
@@ -32,7 +34,7 @@ type effectCacheInMemTable = {
 // Opaque store of all per-(effect, scope) runtime state.
 type t
 
-let make: unit => t
+let make: (~clock: Clock.t=?, unit) => t
 // Get, or lazily create, the in-mem table for an (effect, scope). Reuses the
 // surviving rate-limit window when the table is recreated after a rollback.
 let getTable: (t, ~effect: Internal.effect, ~scope: Internal.chainScope) => effectCacheInMemTable

package/src/EntityId.res

@@ -1,15 +1,10 @@
 // Opaque representation of an entity id. The generated per-entity types expose
-// the real scalar (string / int / bigint); the generic storage and in-memory
+// the real scalar (string / int / bigint / Uint8Array); the generic storage and in-memory
 // layers work with any entity's id through this type without knowing which
 // scalar backs it. The runtime value is always the real id, never a stringified
-// form — `toKey` derives the string only where a JS object/dict key is needed.
+// form — a table's `entityIdToKey` derives the string only where a dict or Set key is needed.
 type t
 
 external unsafeOfAny: 'a => t = "%identity"
 external unsafeToAny: t => 'a = "%identity"
 external unsafeOfString: string => t = "%identity"
-
-// Stringified id used as a JS object/dict key. `String` matches how JS coerces
-// a value used as an object key, so an id indexes the same whether the raw
-// value or its key form is used for lookup, across string/int/bigint.
-let toKey: t => string = %raw(`String`)

package/src/EntityId.res.mjs

@@ -1,9 +1,2 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let toKey = String;
-
-export {
-  toKey,
-}
-/* toKey Not a pure module */
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/EntityTables.res

@@ -6,7 +6,10 @@ type t = dict<InMemoryTable.Entity.t>
 let make = (entities: array<Internal.entityConfig>): t => {
   let init = Dict.make()
   entities->Array.forEach(entityConfig => {
-    init->Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
+    init->Dict.set(
+      (entityConfig.name :> string),
+      InMemoryTable.Entity.make(~entityIdToKey=entityConfig.table.entityIdToKey),
+    )
   })
   init
 }

package/src/EntityTables.res.mjs

@@ -6,7 +6,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 function make(entities) {
   let init = {};
   entities.forEach(entityConfig => {
-    init[entityConfig.name] = InMemoryTable.Entity.make();
+    init[entityConfig.name] = InMemoryTable.Entity.make(entityConfig.table.entityIdToKey);
   });
   return init;
 }

package/src/Env.res

@@ -11,6 +11,10 @@ let targetBufferSize = envSafe->EnvSafe.get("ENVIO_INDEXING_MAX_BUFFER_SIZE", S.
 // the pool of events ready to process is sized for that (CrossChainState).
 let subgraphMode = ref(false)
 
+// Set with subgraphMode when the manifest declares templates: without one no
+// event can create a data source, so none holds a register pass.
+let subgraphHasTemplates = ref(false)
+
 // Most events with a register pass one subgraph response may hold before it is
 // cut after a block and the rest fetched again. 0 turns the cut off; unset, it
 // follows what the register passes cost (ChainFetching).

package/src/Env.res.mjs

@@ -17,6 +17,10 @@ let subgraphMode = {
   contents: false
 };
 
+let subgraphHasTemplates = {
+  contents: false
+};
+
 let subgraphRegisterChunk = EnvSafe.get(envSafe, "ENVIO_SUBGRAPH_REGISTER_CHUNK", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);
 
 let subgraphPreloadLookahead = EnvSafe.get(envSafe, "ENVIO_SUBGRAPH_PRELOAD_LOOKAHEAD", S$RescriptSchema.int, undefined, 256, undefined, undefined);
@@ -225,6 +229,7 @@ let maxChainConcurrency = 100;
 export {
   targetBufferSize,
   subgraphMode,
+  subgraphHasTemplates,
   subgraphRegisterChunk,
   subgraphPreloadLookahead,
   maxAddrInPartition,