envio 3.3.0 → 3.3.1

package/src/TestIndexer.res.mjs

@@ -614,31 +614,12 @@ function initTestWorker() {
   }
   let patchConfig = (config, registrationsByChainId) => {
     let config$1 = SimulateItems.patchConfig(config, processConfig, registrationsByChainId);
-    if (exitAfterFirstEventBlock) {
-      return {
-        name: config$1.name,
-        description: config$1.description,
-        handlers: config$1.handlers,
-        contractHandlers: config$1.contractHandlers,
-        shouldRollbackOnReorg: config$1.shouldRollbackOnReorg,
-        shouldSaveFullHistory: config$1.shouldSaveFullHistory,
-        storage: config$1.storage,
-        chainMap: config$1.chainMap,
-        defaultChain: config$1.defaultChain,
-        ecosystem: config$1.ecosystem,
-        enableRawEvents: config$1.enableRawEvents,
-        maxAddrInPartition: config$1.maxAddrInPartition,
-        batchSize: 1,
-        lowercaseAddresses: config$1.lowercaseAddresses,
-        isDev: config$1.isDev,
-        userEntitiesByName: config$1.userEntitiesByName,
-        userEntities: config$1.userEntities,
-        allEntities: config$1.allEntities,
-        allEnums: config$1.allEnums
-      };
-    } else {
+    if (!exitAfterFirstEventBlock) {
       return config$1;
     }
+    let newrecord = {...config$1};
+    newrecord.batchSize = 1;
+    return newrecord;
   };
   Stdlib_Promise.$$catch(Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig), exn => {
     let toThrow = exn.RE_EXN_ID === Main.FatalError ? exn._1 : Utils.prettifyExn(exn);

package/src/TestIndexerProxyStorage.res

@@ -138,6 +138,7 @@ let makeStorage = (proxy: t): Persistence.storage => {
     ~updatedEffectsCache as _,
     ~updatedEntities,
     ~chainMetaData as _,
+    ~onWrite as _,
   ) => {
     // Encode entities to JSON for serialization across worker boundary
     let serializableEntities = updatedEntities->Array.map((

package/src/TestIndexerProxyStorage.res.mjs

@@ -74,7 +74,7 @@ function makeStorage(proxy) {
     getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
-    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, updatedEntities, param$5) => {
+    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, updatedEntities, param$5, param$6) => {
       let serializableEntities = updatedEntities.map(param => {
         let entityConfig = param.entityConfig;
         let encodeChange = change => {

package/src/Writing.res

@@ -61,11 +61,7 @@ let snapshotEffects = (state: IndexerState.t, ~cache): array<Persistence.updated
       }
       let shouldInitialize = effectCacheRecord.count === 0
       effectCacheRecord.count = effectCacheRecord.count + items->Array.length - invalidationsCount
-      Prometheus.EffectCacheCount.set(
-        ~count=effectCacheRecord.count,
-        ~effectName,
-        ~scope=scope->Internal.EffectCache.scopeToString,
-      )
+      inMemTable->EffectState.commitCacheCount(~count=effectCacheRecord.count)
       acc
       ->Array.push(
         (
@@ -155,6 +151,8 @@ let runOneWrite = async (state: IndexerState.t) => {
         ~updatedEntities,
         ~updatedEffectsCache,
         ~chainMetaData,
+        ~onWrite=(~storage, ~timeSeconds) =>
+          state->IndexerState.recordStorageWrite(~storage, ~timeSeconds),
       ),
       PruneStaleHistory.runConcurrent(state, ~targets=pruneTargets),
     ))

package/src/Writing.res.mjs

@@ -2,9 +2,7 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
-import * as Internal from "./Internal.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
-import * as Prometheus from "./Prometheus.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -43,7 +41,6 @@ function snapshotEffects(state, cache) {
     let invalidationsCount = inMemTable.invalidationsCount;
     let dict = inMemTable.dict;
     let table = inMemTable.table;
-    let scope = inMemTable.scope;
     let effect = inMemTable.effect;
     if (idsToStore.length !== 0) {
       let items = Stdlib_Array.filterMap(idsToStore, id => {
@@ -64,7 +61,7 @@ function snapshotEffects(state, cache) {
       } else {
         let c$1 = {
           effectName: effectName,
-          scope: scope,
+          scope: inMemTable.scope,
           tableName: tableName,
           count: 0
         };
@@ -73,7 +70,7 @@ function snapshotEffects(state, cache) {
       }
       let shouldInitialize = effectCacheRecord.count === 0;
       effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0;
-      Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName, Internal.EffectCache.scopeToString(scope));
+      EffectState.commitCacheCount(inMemTable, effectCacheRecord.count);
       acc.push({
         table: table,
         itemSchema: effect.storageMeta.itemSchema,
@@ -126,7 +123,7 @@ async function runOneWrite(state) {
   });
   let pruneTargets = PruneStaleHistory.select(state, writtenEntityNames, Stdlib_Option.isSome(rollback));
   await Promise.all([
-    persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData),
+    persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData, (storage, timeSeconds) => IndexerState.recordStorageWrite(state, storage, timeSeconds)),
     PruneStaleHistory.runConcurrent(state, pruneTargets)
   ]);
   IndexerState.markCommitted(state, upToCheckpointId);

package/src/bindings/ClickHouse.res

@@ -307,11 +307,34 @@ let setUpdatesOrThrow = async (
   }
 }
 
+// A plain database created with ON CLUSTER doesn't turn subsequent DDL into
+// cluster-wide statements; ClickHouse keeps no "this database is clustered"
+// flag. Without a Replicated database engine, every CREATE must carry its own
+// ON CLUSTER to reach all replicas, otherwise it runs only on the connected
+// node. With a Replicated database engine the DDL propagates via the database's
+// own log, and combining it with ON CLUSTER is rejected/double-applied — so
+// table-level DDL must carry the clause only in the plain-database case.
+// The '{cluster}' macro resolves to each node's configured cluster name.
+let onClusterClause = (~onCluster: bool) => onCluster ? ` ON CLUSTER '{cluster}'` : ""
+
+// Strip both engine arguments `(...)` and a trailing `SETTINGS ...` clause to
+// get the bare engine name, e.g. `Replicated('/p','{shard}','{replica}') SETTINGS x=1`
+// and `Replicated SETTINGS x=1` both yield `Replicated`.
+let databaseEngineName = (engineSpec: string) =>
+  engineSpec
+  ->String.trim
+  ->String.split("(")
+  ->Array.getUnsafe(0)
+  ->String.split(" ")
+  ->Array.getUnsafe(0)
+  ->String.trim
+
 // Generate CREATE TABLE query for entity history table
 let makeCreateHistoryTableQuery = (
   ~entityConfig: Internal.entityConfig,
   ~database: string,
   ~replicated: bool=false,
+  ~onCluster: bool=false,
 ) => {
   let tableEngine = replicated ? "ReplicatedMergeTree" : "MergeTree()"
   let fieldDefinitions = entityConfig.table.fields->Array.filterMap(field => {
@@ -333,7 +356,7 @@ let makeCreateHistoryTableQuery = (
   `CREATE TABLE IF NOT EXISTS ${database}.\`${EntityHistory.historyTableName(
       ~entityName=entityConfig.name,
       ~entityIndex=entityConfig.index,
-    )}\` (
+    )}\`${onClusterClause(~onCluster)} (
   ${fieldDefinitions->Array.joinUnsafe(",\n  ")},
   \`${EntityHistory.checkpointIdFieldName}\` ${getClickHouseFieldType(
       ~fieldType=UInt64,
@@ -351,7 +374,11 @@ ORDER BY (${Table.idFieldName}, ${EntityHistory.checkpointIdFieldName})`
 }
 
 // Generate CREATE TABLE query for checkpoints
-let makeCreateCheckpointsTableQuery = (~database: string, ~replicated: bool=false) => {
+let makeCreateCheckpointsTableQuery = (
+  ~database: string,
+  ~replicated: bool=false,
+  ~onCluster: bool=false,
+) => {
   let tableEngine = replicated ? "ReplicatedMergeTree" : "MergeTree()"
   let idField = (#id: InternalTable.Checkpoints.field :> string)
   let chainIdField = (#chain_id: InternalTable.Checkpoints.field :> string)
@@ -359,7 +386,9 @@ let makeCreateCheckpointsTableQuery = (~database: string, ~replicated: bool=fals
   let blockHashField = (#block_hash: InternalTable.Checkpoints.field :> string)
   let eventsProcessedField = (#events_processed: InternalTable.Checkpoints.field :> string)
 
-  `CREATE TABLE IF NOT EXISTS ${database}.\`${InternalTable.Checkpoints.table.tableName}\` (
+  `CREATE TABLE IF NOT EXISTS ${database}.\`${InternalTable.Checkpoints.table.tableName}\`${onClusterClause(
+      ~onCluster,
+    )} (
   \`${idField}\` ${getClickHouseFieldType(~fieldType=UInt64, ~isNullable=false, ~isArray=false)},
   \`${chainIdField}\` ${getClickHouseFieldType(
       ~fieldType=Int32,
@@ -387,7 +416,11 @@ ORDER BY (${idField})`
 }
 
 // Generate CREATE VIEW query for entity current state
-let makeCreateViewQuery = (~entityConfig: Internal.entityConfig, ~database: string) => {
+let makeCreateViewQuery = (
+  ~entityConfig: Internal.entityConfig,
+  ~database: string,
+  ~onCluster: bool=false,
+) => {
   let historyTableName = EntityHistory.historyTableName(
     ~entityName=entityConfig.name,
     ~entityIndex=entityConfig.index,
@@ -409,7 +442,7 @@ let makeCreateViewQuery = (~entityConfig: Internal.entityConfig, ~database: stri
     })
     ->Array.joinUnsafe(", ")
 
-  `CREATE VIEW IF NOT EXISTS ${database}.\`${entityConfig.name}\` AS
+  `CREATE VIEW IF NOT EXISTS ${database}.\`${entityConfig.name}\`${onClusterClause(~onCluster)} AS
 SELECT ${entityFields}
 FROM (
   SELECT ${entityFields}, \`${EntityHistory.changeFieldName}\`
@@ -429,20 +462,33 @@ let initialize = async (
   ~enums as _: array<Table.enumConfig<Table.enum>>,
 ) => {
   try {
-    let replicated = Env.ClickHouse.replicated()
     let databaseEngine = Env.ClickHouse.databaseEngine()
     let databaseEngineClause = switch databaseEngine {
     | Some(engine) => ` ENGINE = ${engine}`
     | None => ""
     }
-    // Replicated database engine requires CREATE DATABASE to run on every
-    // replica; ON CLUSTER fans the DDL out via Keeper. The '{cluster}' macro
-    // resolves to each node's configured cluster name.
-    let onClusterClause = replicated ? ` ON CLUSTER '{cluster}'` : ""
+    let hasReplicatedDatabaseEngine = switch databaseEngine {
+    | Some(engine) => engine->databaseEngineName === "Replicated"
+    | None => false
+    }
+    let envReplicated = Env.ClickHouse.replicated()
+    // A Replicated database engine only replicates data when its tables use the
+    // ReplicatedMergeTree engine, so it implies replicated mode even when
+    // ENVIO_CLICKHOUSE_REPLICATED is unset.
+    let replicated = envReplicated || hasReplicatedDatabaseEngine
+    if hasReplicatedDatabaseEngine && !envReplicated {
+      Logging.info(
+        "ENVIO_CLICKHOUSE_DATABASE_ENGINE is Replicated; enabling replicated mode so tables use the ReplicatedMergeTree engine.",
+      )
+    }
+    let databaseOnClusterClause = onClusterClause(~onCluster=replicated)
+    // DDL that a Replicated database engine propagates itself must not carry
+    // ON CLUSTER on top of it — the clause is only for the plain-database case.
+    let ddlOnCluster = replicated && !hasReplicatedDatabaseEngine
 
     switch databaseEngine {
     | Some(engineSpec) => {
-        let expectedEngineName = engineSpec->String.split("(")->Array.getUnsafe(0)->String.trim
+        let expectedEngineName = engineSpec->databaseEngineName
         let existingResult = await client->query({
           query: `SELECT engine FROM system.databases WHERE name = '${database}'`,
         })
@@ -458,22 +504,60 @@ let initialize = async (
     | None => ()
     }
 
-    await client->exec({query: `TRUNCATE DATABASE IF EXISTS ${database}${onClusterClause}`})
+    if hasReplicatedDatabaseEngine {
+      // TRUNCATE DATABASE is unsupported on Replicated databases, so a reset
+      // has to DROP and recreate instead (plain databases keep the TRUNCATE
+      // fallback below). This requires the ClickHouse user to hold the DROP
+      // privilege; without it the reset fails here with ACCESS_DENIED. ON
+      // CLUSTER removes the database from every node — the engine's own log
+      // can't replicate the drop of the database it lives in — and SYNC waits
+      // for the drop to finish before the CREATE below.
+      await client->exec({
+        query: `DROP DATABASE IF EXISTS ${database} ON CLUSTER '{cluster}' SYNC`,
+      })
+    } else {
+      await client->exec({
+        query: `TRUNCATE DATABASE IF EXISTS ${database}${onClusterClause(~onCluster=ddlOnCluster)}`,
+      })
+    }
     await client->exec({
-      query: `CREATE DATABASE IF NOT EXISTS ${database}${onClusterClause}${databaseEngineClause}`,
+      query: `CREATE DATABASE IF NOT EXISTS ${database}${databaseOnClusterClause}${databaseEngineClause}`,
     })
-    await client->exec({query: `USE ${database}`})
 
     await Promise.all(
       entities->Array.map(entityConfig =>
-        client->exec({query: makeCreateHistoryTableQuery(~entityConfig, ~database, ~replicated)})
+        client->exec({
+          query: makeCreateHistoryTableQuery(
+            ~entityConfig,
+            ~database,
+            ~replicated,
+            ~onCluster=ddlOnCluster,
+          ),
+        })
       ),
     )->Utils.Promise.ignoreValue
-    await client->exec({query: makeCreateCheckpointsTableQuery(~database, ~replicated)})
+    await client->exec({
+      query: makeCreateCheckpointsTableQuery(~database, ~replicated, ~onCluster=ddlOnCluster),
+    })
+
+    // The client pools HTTP connections, so consecutive statements may reach
+    // different replicas, while a Replicated database applies DDL from its
+    // Keeper log asynchronously. A CREATE VIEW is analyzed against the node's
+    // local metadata and can land on a replica that hasn't applied the table
+    // creates yet, failing with UNKNOWN_TABLE. Block until every replica has
+    // caught up before creating the views. ON CLUSTER must precede the
+    // database name in this command's grammar.
+    if hasReplicatedDatabaseEngine {
+      await client->exec({
+        query: `SYSTEM SYNC DATABASE REPLICA ON CLUSTER '{cluster}' ${database}`,
+      })
+    }
 
     await Promise.all(
       entities->Array.map(entityConfig =>
-        client->exec({query: makeCreateViewQuery(~entityConfig, ~database)})
+        client->exec({
+          query: makeCreateViewQuery(~entityConfig, ~database, ~onCluster=ddlOnCluster),
+        })
       ),
     )->Utils.Promise.ignoreValue
 

package/src/bindings/ClickHouse.res.mjs

@@ -235,8 +235,21 @@ async function setUpdatesOrThrow(client, cache, changes, entityConfig, database)
   }
 }
 
-function makeCreateHistoryTableQuery(entityConfig, database, replicatedOpt) {
+function onClusterClause(onCluster) {
+  if (onCluster) {
+    return ` ON CLUSTER '{cluster}'`;
+  } else {
+    return "";
+  }
+}
+
+function databaseEngineName(engineSpec) {
+  return engineSpec.trim().split("(")[0].split(" ")[0].trim();
+}
+
+function makeCreateHistoryTableQuery(entityConfig, database, replicatedOpt, onClusterOpt) {
   let replicated = replicatedOpt !== undefined ? replicatedOpt : false;
+  let onCluster = onClusterOpt !== undefined ? onClusterOpt : false;
   let tableEngine = replicated ? "ReplicatedMergeTree" : "MergeTree()";
   let fieldDefinitions = Stdlib_Array.filterMap(entityConfig.table.fields, field => {
     if (field.TAG !== "Field") {
@@ -247,7 +260,9 @@ function makeCreateHistoryTableQuery(entityConfig, database, replicatedOpt) {
     let clickHouseType = getClickHouseFieldType(field$1.fieldType, field$1.isNullable, field$1.isArray);
     return `\`` + fieldName + `\` ` + clickHouseType;
   });
-  return `CREATE TABLE IF NOT EXISTS ` + database + `.\`` + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + `\` (
+  return `CREATE TABLE IF NOT EXISTS ` + database + `.\`` + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + `\`` + (
+    onCluster ? ` ON CLUSTER '{cluster}'` : ""
+  ) + ` (
   ` + fieldDefinitions.join(",\n  ") + `,
   \`` + EntityHistory.checkpointIdFieldName + `\` ` + getClickHouseFieldType("UInt64", false, false) + `,
   \`` + EntityHistory.changeFieldName + `\` ` + getClickHouseFieldType({
@@ -259,10 +274,13 @@ ENGINE = ` + tableEngine + `
 ORDER BY (` + Table.idFieldName + `, ` + EntityHistory.checkpointIdFieldName + `)`;
 }
 
-function makeCreateCheckpointsTableQuery(database, replicatedOpt) {
+function makeCreateCheckpointsTableQuery(database, replicatedOpt, onClusterOpt) {
   let replicated = replicatedOpt !== undefined ? replicatedOpt : false;
+  let onCluster = onClusterOpt !== undefined ? onClusterOpt : false;
   let tableEngine = replicated ? "ReplicatedMergeTree" : "MergeTree()";
-  return `CREATE TABLE IF NOT EXISTS ` + database + `.\`` + InternalTable.Checkpoints.table.tableName + `\` (
+  return `CREATE TABLE IF NOT EXISTS ` + database + `.\`` + InternalTable.Checkpoints.table.tableName + `\`` + (
+    onCluster ? ` ON CLUSTER '{cluster}'` : ""
+  ) + ` (
   \`` + "id" + `\` ` + getClickHouseFieldType("UInt64", false, false) + `,
   \`` + "chain_id" + `\` ` + getClickHouseFieldType("Int32", false, false) + `,
   \`` + "block_number" + `\` ` + getClickHouseFieldType("Int32", false, false) + `,
@@ -273,7 +291,8 @@ ENGINE = ` + tableEngine + `
 ORDER BY (` + "id" + `)`;
 }
 
-function makeCreateViewQuery(entityConfig, database) {
+function makeCreateViewQuery(entityConfig, database, onClusterOpt) {
+  let onCluster = onClusterOpt !== undefined ? onClusterOpt : false;
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
   let checkpointsTableName = InternalTable.Checkpoints.table.tableName;
   let entityFields = Stdlib_Array.filterMap(entityConfig.table.fields, field => {
@@ -283,7 +302,9 @@ function makeCreateViewQuery(entityConfig, database) {
     let fieldName = Table.getClickHouseDbFieldName(field._0);
     return `\`` + fieldName + `\``;
   }).join(", ");
-  return `CREATE VIEW IF NOT EXISTS ` + database + `.\`` + entityConfig.name + `\` AS
+  return `CREATE VIEW IF NOT EXISTS ` + database + `.\`` + entityConfig.name + `\`` + (
+    onCluster ? ` ON CLUSTER '{cluster}'` : ""
+  ) + ` AS
 SELECT ` + entityFields + `
 FROM (
   SELECT ` + entityFields + `, \`` + EntityHistory.changeFieldName + `\`
@@ -297,12 +318,18 @@ WHERE \`` + EntityHistory.changeFieldName + `\` = '` + "SET" + `'`;
 
 async function initialize(client, database, entities, param) {
   try {
-    let replicated = Env.ClickHouse.replicated();
     let databaseEngine = Env.ClickHouse.databaseEngine();
     let databaseEngineClause = databaseEngine !== undefined ? ` ENGINE = ` + databaseEngine : "";
-    let onClusterClause = replicated ? ` ON CLUSTER '{cluster}'` : "";
+    let hasReplicatedDatabaseEngine = databaseEngine !== undefined ? databaseEngineName(databaseEngine) === "Replicated" : false;
+    let envReplicated = Env.ClickHouse.replicated();
+    let replicated = envReplicated || hasReplicatedDatabaseEngine;
+    if (hasReplicatedDatabaseEngine && !envReplicated) {
+      Logging.info("ENVIO_CLICKHOUSE_DATABASE_ENGINE is Replicated; enabling replicated mode so tables use the ReplicatedMergeTree engine.");
+    }
+    let databaseOnClusterClause = replicated ? ` ON CLUSTER '{cluster}'` : "";
+    let ddlOnCluster = replicated && !hasReplicatedDatabaseEngine;
     if (databaseEngine !== undefined) {
-      let expectedEngineName = databaseEngine.split("(")[0].trim();
+      let expectedEngineName = databaseEngineName(databaseEngine);
       let existingResult = await client.query({
         query: `SELECT engine FROM system.databases WHERE name = '` + database + `'`
       });
@@ -315,23 +342,33 @@ async function initialize(client, database, entities, param) {
         }
       }
     }
+    if (hasReplicatedDatabaseEngine) {
+      await client.exec({
+        query: `DROP DATABASE IF EXISTS ` + database + ` ON CLUSTER '{cluster}' SYNC`
+      });
+    } else {
+      await client.exec({
+        query: `TRUNCATE DATABASE IF EXISTS ` + database + (
+          ddlOnCluster ? ` ON CLUSTER '{cluster}'` : ""
+        )
+      });
+    }
     await client.exec({
-      query: `TRUNCATE DATABASE IF EXISTS ` + database + onClusterClause
-    });
-    await client.exec({
-      query: `CREATE DATABASE IF NOT EXISTS ` + database + onClusterClause + databaseEngineClause
-    });
-    await client.exec({
-      query: `USE ` + database
+      query: `CREATE DATABASE IF NOT EXISTS ` + database + databaseOnClusterClause + databaseEngineClause
     });
     await Promise.all(entities.map(entityConfig => client.exec({
-      query: makeCreateHistoryTableQuery(entityConfig, database, replicated)
+      query: makeCreateHistoryTableQuery(entityConfig, database, replicated, ddlOnCluster)
     })));
     await client.exec({
-      query: makeCreateCheckpointsTableQuery(database, replicated)
+      query: makeCreateCheckpointsTableQuery(database, replicated, ddlOnCluster)
     });
+    if (hasReplicatedDatabaseEngine) {
+      await client.exec({
+        query: `SYSTEM SYNC DATABASE REPLICA ON CLUSTER '{cluster}' ` + database
+      });
+    }
     await Promise.all(entities.map(entityConfig => client.exec({
-      query: makeCreateViewQuery(entityConfig, database)
+      query: makeCreateViewQuery(entityConfig, database, ddlOnCluster)
     })));
     return Logging.trace("ClickHouse storage initialization completed successfully");
   } catch (raw_exn) {
@@ -382,6 +419,8 @@ export {
   insertWithRetry,
   setCheckpointsOrThrow,
   setUpdatesOrThrow,
+  onClusterClause,
+  databaseEngineName,
   makeCreateHistoryTableQuery,
   makeCreateCheckpointsTableQuery,
   makeCreateViewQuery,

package/src/bindings/NodeJs.res

@@ -46,6 +46,70 @@ module Process = {
   @module external process: t = "process"
   @module("process") external cwd: unit => string = "cwd"
   @get external execPath: t => string = "execPath"
+
+  type memoryUsage = {
+    rss: float,
+    heapTotal: float,
+    heapUsed: float,
+    @as("external") external_: float,
+    arrayBuffers: float,
+  }
+  @module("process") external memoryUsage: unit => memoryUsage = "memoryUsage"
+
+  // Microseconds since process start.
+  type cpuUsage = {user: float, system: float}
+  @module("process") external cpuUsage: unit => cpuUsage = "cpuUsage"
+
+  @module("process") external uptime: unit => float = "uptime"
+  @module("process") external version: string = "version"
+  @module("process")
+  external getActiveResourcesInfo: unit => array<string> = "getActiveResourcesInfo"
+}
+
+module V8 = {
+  type heapSpaceStatistics = {
+    @as("space_name") spaceName: string,
+    @as("space_size") spaceSize: float,
+    @as("space_used_size") spaceUsedSize: float,
+    @as("space_available_size") spaceAvailableSize: float,
+  }
+  @module("v8")
+  external getHeapSpaceStatistics: unit => array<heapSpaceStatistics> = "getHeapSpaceStatistics"
+}
+
+module PerfHooks = {
+  type eventLoopUtilization = {idle: float, active: float, utilization: float}
+  type performance
+  @module("perf_hooks") external performance: performance = "performance"
+  @send external eventLoopUtilization: performance => eventLoopUtilization = "eventLoopUtilization"
+
+  // Sampled event-loop delay histogram; values are nanoseconds.
+  type intervalHistogram = {
+    mean: float,
+    min: float,
+    max: float,
+    stddev: float,
+  }
+  type monitorOptions = {resolution?: int}
+  @module("perf_hooks")
+  external monitorEventLoopDelay: (~options: monitorOptions=?) => intervalHistogram =
+    "monitorEventLoopDelay"
+  @send external enable: intervalHistogram => bool = "enable"
+  @send external reset: intervalHistogram => unit = "reset"
+  @send external percentile: (intervalHistogram, int) => float = "percentile"
+
+  type performanceEntry = {
+    duration: float, // milliseconds
+    detail: {"kind": int},
+  }
+  type observerList
+  @send external getEntries: observerList => array<performanceEntry> = "getEntries"
+  type performanceObserver
+  type observeOptions = {entryTypes: array<string>}
+  @new @module("perf_hooks")
+  external makePerformanceObserver: (observerList => unit) => performanceObserver =
+    "PerformanceObserver"
+  @send external observe: (performanceObserver, observeOptions) => unit = "observe"
 }
 
 module ChildProcess = {

package/src/bindings/NodeJs.res.mjs

@@ -18,6 +18,10 @@ let Util$1 = {
 
 let Process = {};
 
+let V8 = {};
+
+let PerfHooks = {};
+
 let ChildProcess = {};
 
 let Url$1 = {};
@@ -45,6 +49,8 @@ let Fs = {
 export {
   Util$1 as Util,
   Process,
+  V8,
+  PerfHooks,
   ChildProcess,
   Url$1 as Url,
   ImportMeta,

package/src/sources/HyperSyncClient.res

@@ -269,8 +269,8 @@ module Registration = {
     }
 
   let fromOnEventRegistrations = (
-      onEventRegistrations: array<Internal.evmOnEventRegistration>,
-    ): array<input> => {
+    onEventRegistrations: array<Internal.evmOnEventRegistration>,
+  ): array<input> => {
     onEventRegistrations->Array.map(reg => {
       let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
       {
@@ -282,9 +282,7 @@ module Registration = {
         isWildcard: reg.isWildcard,
         dependsOnAddresses: reg.dependsOnAddresses,
         params: event.paramsMetadata,
-        topicSelections: reg.resolvedWhere.topicSelections->Array.map((
-          ts
-        ): topicSelectionInput => {
+        topicSelections: reg.resolvedWhere.topicSelections->Array.map((ts): topicSelectionInput => {
           topic0: ts.topic0->EvmTypes.Hex.toStrings,
           topic1: ts.topic1->toTopicFilterInput,
           topic2: ts.topic2->toTopicFilterInput,
@@ -360,12 +358,8 @@ type t = {
 }
 
 @send
-external classNew: (
-  Core.evmHypersyncClientCtor,
-  cfg,
-  string,
-  array<Registration.input>,
-) => t = "new"
+external classNew: (Core.evmHypersyncClientCtor, cfg, string, array<Registration.input>) => t =
+  "new"
 
 let makeWithAgent = (cfg, ~userAgent, ~eventRegistrations) =>
   Core.getAddon().evmHypersyncClient->classNew(cfg, userAgent, eventRegistrations)