envio 2.31.0-alpha.3 → 2.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.31.0-alpha.3",
+  "version": "v2.31.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.31.0-alpha.3",
-    "envio-linux-arm64": "v2.31.0-alpha.3",
-    "envio-darwin-x64": "v2.31.0-alpha.3",
-    "envio-darwin-arm64": "v2.31.0-alpha.3"
+    "envio-linux-x64": "v2.31.0",
+    "envio-linux-arm64": "v2.31.0",
+    "envio-darwin-x64": "v2.31.0",
+    "envio-darwin-arm64": "v2.31.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.6",

package/src/Envio.res

@@ -59,7 +59,6 @@ let experimental_createEffect = (
   options: effectOptions<'input, 'output>,
   handler: effectArgs<'input> => promise<'output>,
 ) => {
-  Prometheus.EffectCallsCount.set(~callsCount=0, ~effectName=options.name)
   let outputSchema =
     S.schema(_ => options.output)->(Utils.magic: S.t<S.t<'output>> => S.t<Internal.effectOutput>)
   {
@@ -86,7 +85,7 @@ let experimental_createEffect = (
       })
       Some({
         table: Internal.makeCacheTable(~effectName=options.name),
-        rowsSchema: S.array(itemSchema),
+        outputSchema,
         itemSchema,
       })
     | None

package/src/Envio.res.js

@@ -2,11 +2,9 @@
 'use strict';
 
 var Internal = require("./Internal.res.js");
-var Prometheus = require("./Prometheus.res.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 
 function experimental_createEffect(options, handler) {
-  Prometheus.EffectCallsCount.set(0, options.name);
   var outputSchema = S$RescriptSchema.schema(function (param) {
         return options.output;
       });
@@ -21,7 +19,7 @@ function experimental_createEffect(options, handler) {
         });
     tmp = {
       itemSchema: itemSchema,
-      rowsSchema: S$RescriptSchema.array(itemSchema),
+      outputSchema: outputSchema,
       table: Internal.makeCacheTable(options.name)
     };
   } else {

package/src/FetchState.res

@@ -351,8 +351,11 @@ let registerDynamicContracts = (
     switch item->Internal.getItemDcs {
     | None => ()
     | Some(dcs) =>
-      for idx in 0 to dcs->Array.length - 1 {
-        let dc = dcs->Js.Array2.unsafe_get(idx)
+      let idx = ref(0)
+      while idx.contents < dcs->Array.length {
+        let dc = dcs->Js.Array2.unsafe_get(idx.contents)
+
+        let shouldRemove = ref(false)
 
         switch fetchState.contractConfigs->Utils.Dict.dangerouslyGetNonOption(dc.contractName) {
         | Some({filterByAddresses}) =>
@@ -378,8 +381,7 @@ let registerDynamicContracts = (
               )
               logger->Logging.childWarn(`Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`)
             }
-            // Remove the DC from item to prevent it from saving to the db
-            let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx)
+            shouldRemove := true
           | None =>
             let shouldUpdate = switch registeringContracts->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
@@ -401,8 +403,7 @@ let registerDynamicContracts = (
                 Pervasives.min(earliestRegisteringEventBlockNumber.contents, dc.startBlock)
               registeringContracts->Js.Dict.set(dc.address->Address.toString, dc)
             } else {
-              // Remove the DC from item to prevent it from saving to the db
-              let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx)
+              shouldRemove := true
             }
           }
         | None => {
@@ -414,9 +415,17 @@ let registerDynamicContracts = (
               },
             )
             logger->Logging.childWarn(`Skipping contract registration: Contract doesn't have any events to fetch.`)
-            let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx)
+            shouldRemove := true
           }
         }
+
+        if shouldRemove.contents {
+          // Remove the DC from item to prevent it from saving to the db
+          let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx.contents)
+          // Don't increment idx - next element shifted into current position
+        } else {
+          idx := idx.contents + 1
+        }
       }
     }
   }

package/src/FetchState.res.js

@@ -237,8 +237,10 @@ function registerDynamicContracts(fetchState, items) {
     var item = items[itemIdx];
     var dcs = item.dcs;
     if (dcs !== undefined) {
-      for(var idx = 0 ,idx_finish = dcs.length; idx < idx_finish; ++idx){
+      var idx = 0;
+      while(idx < dcs.length) {
         var dc = dcs[idx];
+        var shouldRemove = false;
         var match = fetchState.contractConfigs[dc.contractName];
         if (match !== undefined) {
           var existingContract = indexingContracts[dc.address];
@@ -254,7 +256,7 @@ function registerDynamicContracts(fetchState, items) {
                   });
               Logging.childWarn(logger, "Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.");
             }
-            dcs.splice(idx, 1);
+            shouldRemove = true;
           } else {
             var registeringContract = registeringContracts[dc.address];
             var shouldUpdate;
@@ -274,7 +276,7 @@ function registerDynamicContracts(fetchState, items) {
               earliestRegisteringEventBlockNumber = earliestRegisteringEventBlockNumber < dc.startBlock ? earliestRegisteringEventBlockNumber : dc.startBlock;
               registeringContracts[dc.address] = dc;
             } else {
-              dcs.splice(idx, 1);
+              shouldRemove = true;
             }
           }
         } else {
@@ -284,9 +286,14 @@ function registerDynamicContracts(fetchState, items) {
                 contractName: dc.contractName
               });
           Logging.childWarn(logger$1, "Skipping contract registration: Contract doesn't have any events to fetch.");
+          shouldRemove = true;
+        }
+        if (shouldRemove) {
           dcs.splice(idx, 1);
+        } else {
+          idx = idx + 1 | 0;
         }
-      }
+      };
     }
     
   }
@@ -331,7 +338,7 @@ function registerDynamicContracts(fetchState, items) {
             addressesByContractName: pendingAddressesByContractName.contents
           });
     };
-    for(var idx$1 = 0 ,idx_finish$1 = Object.keys(addressesByContractName).length; idx$1 < idx_finish$1; ++idx$1){
+    for(var idx$1 = 0 ,idx_finish = Object.keys(addressesByContractName).length; idx$1 < idx_finish; ++idx$1){
       var contractName = Object.keys(addressesByContractName)[idx$1];
       var addresses = addressesByContractName[contractName];
       var contractConfig = fetchState.contractConfigs[contractName];

package/src/Internal.res

@@ -290,7 +290,7 @@ type effectArgs = {
 type effectCacheItem = {id: string, output: effectOutput}
 type effectCacheMeta = {
   itemSchema: S.t<effectCacheItem>,
-  rowsSchema: S.t<array<effectCacheItem>>,
+  outputSchema: S.t<effectOutput>,
   table: Table.table,
 }
 type effect = {
@@ -302,14 +302,17 @@ type effect = {
   mutable callsCount: int,
 }
 let cacheTablePrefix = "envio_effect_"
+let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<Js.Json.t> => S.t<effectOutput>)
+let effectCacheItemRowsSchema = S.array(
+  S.schema(s => {id: s.matches(S.string), output: s.matches(cacheOutputSchema)}),
+)
 let makeCacheTable = (~effectName) => {
   Table.mkTable(
     cacheTablePrefix ++ effectName,
     ~fields=[
       Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-      Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false), ~isNullable=true),
+      Table.mkField("output", JsonB, ~fieldSchema=cacheOutputSchema, ~isNullable=true),
     ],
-    ~compositeIndices=[],
   )
 }
 

package/src/Internal.res.js

@@ -36,10 +36,19 @@ function makeEnumConfig(name, variants) {
 
 var cacheTablePrefix = "envio_effect_";
 
+var cacheOutputSchema = S$RescriptSchema.json(false);
+
+var effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(function (s) {
+          return {
+                  id: s.m(S$RescriptSchema.string),
+                  output: s.m(cacheOutputSchema)
+                };
+        }));
+
 function makeCacheTable(effectName) {
-  return Table.mkTable(cacheTablePrefix + effectName, [], [
+  return Table.mkTable(cacheTablePrefix + effectName, undefined, [
               Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-              Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, true, undefined, undefined, undefined)
+              Table.mkField("output", "JSONB", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
             ]);
 }
 
@@ -47,5 +56,7 @@ exports.fuelSupplyParamsSchema = fuelSupplyParamsSchema;
 exports.fuelTransferParamsSchema = fuelTransferParamsSchema;
 exports.makeEnumConfig = makeEnumConfig;
 exports.cacheTablePrefix = cacheTablePrefix;
+exports.cacheOutputSchema = cacheOutputSchema;
+exports.effectCacheItemRowsSchema = effectCacheItemRowsSchema;
 exports.makeCacheTable = makeCacheTable;
 /* fuelSupplyParamsSchema Not a pure module */

package/src/Persistence.res

@@ -192,7 +192,12 @@ let getInitializedState = persistence => {
   }
 }
 
-let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items) => {
+let setEffectCacheOrThrow = async (
+  persistence,
+  ~effect: Internal.effect,
+  ~items,
+  ~invalidationsCount,
+) => {
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
@@ -210,7 +215,8 @@ let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items
       }
       let initialize = effectCacheRecord.count === 0
       await storage.setEffectCacheOrThrow(~effect, ~items, ~initialize)
-      effectCacheRecord.count = effectCacheRecord.count + items->Js.Array2.length
+      effectCacheRecord.count =
+        effectCacheRecord.count + items->Js.Array2.length - invalidationsCount
       Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
     }
   }

package/src/Persistence.res.js

@@ -119,7 +119,7 @@ function getInitializedState(persistence) {
   }
 }
 
-async function setEffectCacheOrThrow(persistence, effect, items) {
+async function setEffectCacheOrThrow(persistence, effect, items, invalidationsCount) {
   var match = persistence.storageStatus;
   if (typeof match !== "object") {
     return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
@@ -144,7 +144,7 @@ async function setEffectCacheOrThrow(persistence, effect, items) {
   }
   var initialize = effectCacheRecord.count === 0;
   await storage.setEffectCacheOrThrow(effect, items, initialize);
-  effectCacheRecord.count = effectCacheRecord.count + items.length | 0;
+  effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0;
   return Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName);
 }
 

package/src/PgStorage.res

@@ -22,7 +22,7 @@ let makeCreateTableIndicesQuery = (table: Table.table, ~pgSchema) => {
     compositeIndices->Array.map(createCompositeIndex)->Js.Array2.joinWith("\n")
 }
 
-let makeCreateTableQuery = (table: Table.table, ~pgSchema) => {
+let makeCreateTableQuery = (table: Table.table, ~pgSchema, ~isNumericArrayAsText) => {
   open Belt
   let fieldsMapped =
     table
@@ -34,6 +34,8 @@ let makeCreateTableQuery = (table: Table.table, ~pgSchema) => {
       {
         `"${fieldName}" ${switch fieldType {
           | Custom(name) if !(name->Js.String2.startsWith("NUMERIC(")) => `"${pgSchema}".${name}`
+          // Workaround for Hasura bug https://github.com/enviodev/hyperindex/issues/788
+          | Numeric if isArray && isNumericArrayAsText => (Table.Text :> string)
           | _ => (fieldType :> string)
           }}${isArray ? "[]" : ""}${switch defaultValue {
           | Some(defaultValue) => ` DEFAULT ${defaultValue}`
@@ -57,6 +59,7 @@ let makeCreateTableQuery = (table: Table.table, ~pgSchema) => {
 let makeInitializeTransaction = (
   ~pgSchema,
   ~pgUser,
+  ~isHasuraEnabled,
   ~chainConfigs=[],
   ~entities=[],
   ~enums=[],
@@ -105,7 +108,10 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
 
   // Batch all table creation first (optimal for PostgreSQL)
   allTables->Js.Array2.forEach((table: Table.table) => {
-    query := query.contents ++ "\n" ++ makeCreateTableQuery(table, ~pgSchema)
+    query :=
+      query.contents ++
+      "\n" ++
+      makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=isHasuraEnabled)
   })
 
   // Then batch all indices (better performance when tables exist)
@@ -263,7 +269,7 @@ let makeTableBatchSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema: S.t<'
   // Currently history update table uses S.object with transformation for schema,
   // which is being lossed during conversion to dbSchema.
   // So use simple insert values for now.
-  let isHistoryUpdate = table.tableName->Js.String2.startsWith("envio_history_")
+  let isHistoryUpdate = table.tableName->Js.String2.startsWith(EntityHistory.historyTablePrefix)
 
   // Should experiment how much it'll affect performance
   // Although, it should be fine not to perform the validation check,
@@ -329,7 +335,7 @@ let removeInvalidUtf8InPlace = entities =>
         // This is unsafe, but we rely that it'll use
         // the mutated reference on retry.
         // TODO: Test it properly after we start using
-        // in-memory PGLite for indexer test framework.
+        // real pg for indexer test framework.
         dict->Js.Dict.set(
           key,
           value
@@ -507,6 +513,7 @@ let make = (
   ~pgUser,
   ~pgDatabase,
   ~pgPassword,
+  ~isHasuraEnabled,
   ~onInitialize=?,
   ~onNewTables=?,
 ): Persistence.storage => {
@@ -552,7 +559,7 @@ let make = (
               let table = Internal.makeCacheTable(~effectName)
 
               sql
-              ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema))
+              ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false))
               ->Promise.then(() => {
                 let inputFile = NodeJs.Path.join(cacheDirPath, entry)->NodeJs.Path.toString
 
@@ -645,6 +652,7 @@ let make = (
       ~enums,
       ~chainConfigs,
       ~isEmptyPgSchema=schemaTableNames->Utils.Array.isEmpty,
+      ~isHasuraEnabled,
     )
     // Execute all queries within a single transaction for integrity
     let _ = await sql->Postgres.beginSql(sql => {
@@ -790,7 +798,10 @@ let make = (
     }
 
     if initialize {
-      let _ = await sql->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema))
+      let _ =
+        await sql->Postgres.unsafe(
+          makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false),
+        )
       // Integration with other tools like Hasura
       switch onNewTables {
       | Some(onNewTables) => await onNewTables(~tableNames=[table.tableName])

package/src/PgStorage.res.js

@@ -15,6 +15,7 @@ var Internal = require("./Internal.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var Persistence = require("./Persistence.res.js");
+var EntityHistory = require("./db/EntityHistory.res.js");
 var InternalTable = require("./db/InternalTable.res.js");
 var Child_process = require("child_process");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
@@ -44,15 +45,20 @@ function makeCreateTableIndicesQuery(table, pgSchema) {
   return Belt_Array.map(singleIndices, createIndex).join("\n") + Belt_Array.map(compositeIndices, createCompositeIndex).join("\n");
 }
 
-function makeCreateTableQuery(table, pgSchema) {
+function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText) {
   var fieldsMapped = Belt_Array.map(Table.getFields(table), (function (field) {
             var defaultValue = field.defaultValue;
+            var isArray = field.isArray;
             var fieldType = field.fieldType;
             var fieldName = Table.getDbFieldName(field);
             var tmp;
-            tmp = fieldType === "TIMESTAMP" || fieldType === "TIMESTAMP WITH TIME ZONE" || fieldType === "JSONB" || fieldType === "SERIAL" || fieldType === "TEXT" || fieldType === "DOUBLE PRECISION" || fieldType === "NUMERIC" || fieldType === "BOOLEAN" || fieldType === "BIGINT" || fieldType === "INTEGER" || fieldType === "TIMESTAMP WITH TIME ZONE NULL" || fieldType.startsWith("NUMERIC(") ? fieldType : "\"" + pgSchema + "\"." + fieldType;
+            tmp = fieldType === "TIMESTAMP" || fieldType === "TIMESTAMP WITH TIME ZONE" || fieldType === "JSONB" || fieldType === "SERIAL" || fieldType === "TEXT" || fieldType === "DOUBLE PRECISION" || fieldType === "NUMERIC" || fieldType === "BOOLEAN" || fieldType === "BIGINT" || fieldType === "INTEGER" || fieldType === "TIMESTAMP WITH TIME ZONE NULL" ? (
+                fieldType === "NUMERIC" && isArray && isNumericArrayAsText ? "TEXT" : fieldType
+              ) : (
+                fieldType.startsWith("NUMERIC(") ? fieldType : "\"" + pgSchema + "\"." + fieldType
+              );
             return "\"" + fieldName + "\" " + tmp + (
-                    field.isArray ? "[]" : ""
+                    isArray ? "[]" : ""
                   ) + (
                     defaultValue !== undefined ? " DEFAULT " + defaultValue : (
                         field.isNullable ? "" : " NOT NULL"
@@ -68,7 +74,7 @@ function makeCreateTableQuery(table, pgSchema) {
         ) + ");";
 }
 
-function makeInitializeTransaction(pgSchema, pgUser, chainConfigsOpt, entitiesOpt, enumsOpt, isEmptyPgSchemaOpt) {
+function makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigsOpt, entitiesOpt, enumsOpt, isEmptyPgSchemaOpt) {
   var chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
   var entities = entitiesOpt !== undefined ? entitiesOpt : [];
   var enums = enumsOpt !== undefined ? enumsOpt : [];
@@ -99,7 +105,7 @@ function makeInitializeTransaction(pgSchema, pgUser, chainConfigsOpt, entitiesOp
         query.contents = query.contents + "\n" + enumCreateQuery;
       });
   allTables.forEach(function (table) {
-        query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema);
+        query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema, isHasuraEnabled);
       });
   allTables.forEach(function (table) {
         var indices = makeCreateTableIndicesQuery(table, pgSchema);
@@ -194,7 +200,7 @@ function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
 function makeTableBatchSetQuery(pgSchema, table, itemSchema) {
   var match = Table.toSqlParams(table, itemSchema, pgSchema);
   var isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
-  var isHistoryUpdate = table.tableName.startsWith("envio_history_");
+  var isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
   if ((isRawEvents || !match.hasArrayField) && !isHistoryUpdate) {
     return {
             query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
@@ -354,7 +360,7 @@ async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort) {
   return result;
 }
 
-function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onInitialize, onNewTables) {
+function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, onInitialize, onNewTables) {
   var psqlExecOptions_env = Js_dict.fromArray([
         [
           "PGPASSWORD",
@@ -403,7 +409,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
           await Promise.all(cacheFiles.map(function (entry) {
                     var effectName = entry.slice(0, -4);
                     var table = Internal.makeCacheTable(effectName);
-                    return sql.unsafe(makeCreateTableQuery(table, pgSchema)).then(function () {
+                    return sql.unsafe(makeCreateTableQuery(table, pgSchema, false)).then(function () {
                                 var inputFile = Path.join(cacheDirPath, entry);
                                 var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + table.tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
                                 return new Promise((function (resolve, reject) {
@@ -461,7 +467,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
           })) {
       Js_exn.raiseError("Cannot run Envio migrations on PostgreSQL schema \"" + pgSchema + "\" because it contains non-Envio tables. Running migrations would delete all data in this schema.\n\nTo resolve this:\n1. If you want to use this schema, first backup any important data, then drop it with: \"pnpm envio local db-migrate down\"\n2. Or specify a different schema name by setting the \"ENVIO_PG_PUBLIC_SCHEMA\" environment variable\n3. Or manually drop the schema in your database if you're certain the data is not needed.");
     }
-    var queries = makeInitializeTransaction(pgSchema, pgUser, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
+    var queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
     await sql.begin(function (sql) {
           return Promise.all(queries.map(function (query) {
                           return sql.unsafe(query);
@@ -568,7 +574,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
     var match = cacheMeta !== undefined ? cacheMeta : Js_exn.raiseError("Failed to set effect cache for \"" + effect.name + "\". Effect has no cache enabled.");
     var table = match.table;
     if (initialize) {
-      await sql.unsafe(makeCreateTableQuery(table, pgSchema));
+      await sql.unsafe(makeCreateTableQuery(table, pgSchema, false));
       if (onNewTables !== undefined) {
         await onNewTables([table.tableName]);
       }

package/src/Prometheus.res

@@ -525,30 +525,6 @@ module RollbackTargetBlockNumber = {
   }
 }
 
-module ProcessingBlockNumber = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_processing_block_number",
-    ~help="The latest item block number included in the currently processing batch for the chain.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
-
-  let set = (~blockNumber, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=blockNumber)
-  }
-}
-
-module ProcessingBatchSize = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_processing_batch_size",
-    ~help="The number of items included in the currently processing batch for the chain.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
-
-  let set = (~batchSize, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=batchSize)
-  }
-}
-
 module ProcessingMaxBatchSize = {
   let gauge = PromClient.Gauge.makeGauge({
     "name": "envio_processing_max_batch_size",
@@ -593,6 +569,17 @@ module ProgressEventsCount = {
   }
 }
 
+module ProgressBatchCount = {
+  let counter = PromClient.Counter.makeCounter({
+    "name": "envio_progress_batches_count",
+    "help": "The number of batches processed and reflected in the database.",
+  })
+
+  let increment = () => {
+    counter->PromClient.Counter.inc
+  }
+}
+
 let effectLabelsSchema = S.object(s => {
   s.field("effect", S.string)
 })
@@ -621,6 +608,18 @@ module EffectCacheCount = {
   }
 }
 
+module EffectCacheInvalidationsCount = {
+  let counter = SafeCounter.makeOrThrow(
+    ~name="envio_effect_cache_invalidations_count",
+    ~help="The number of effect cache invalidations.",
+    ~labelSchema=effectLabelsSchema,
+  )
+
+  let increment = (~effectName) => {
+    counter->SafeCounter.increment(~labels=effectName)
+  }
+}
+
 module StorageLoad = {
   let operationLabelsSchema = S.object(s => s.field("operation", S.string))
 

package/src/Prometheus.res.js

@@ -628,51 +628,29 @@ var RollbackTargetBlockNumber = {
   set: set$15
 };
 
-var gauge$17 = makeOrThrow$1("envio_processing_block_number", "The latest item block number included in the currently processing batch for the chain.", chainIdLabelsSchema);
-
-function set$16(blockNumber, chainId) {
-  handleInt$1(gauge$17, chainId, blockNumber);
-}
-
-var ProcessingBlockNumber = {
-  gauge: gauge$17,
-  set: set$16
-};
-
-var gauge$18 = makeOrThrow$1("envio_processing_batch_size", "The number of items included in the currently processing batch for the chain.", chainIdLabelsSchema);
-
-function set$17(batchSize, chainId) {
-  handleInt$1(gauge$18, chainId, batchSize);
-}
-
-var ProcessingBatchSize = {
-  gauge: gauge$18,
-  set: set$17
-};
-
-var gauge$19 = new PromClient.Gauge({
+var gauge$17 = new PromClient.Gauge({
       name: "envio_processing_max_batch_size",
       help: "The maximum number of items to process in a single batch."
     });
 
-function set$18(maxBatchSize) {
-  gauge$19.set(maxBatchSize);
+function set$16(maxBatchSize) {
+  gauge$17.set(maxBatchSize);
 }
 
 var ProcessingMaxBatchSize = {
-  gauge: gauge$19,
-  set: set$18
+  gauge: gauge$17,
+  set: set$16
 };
 
-var gauge$20 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+var gauge$18 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$19(blockNumber, chainId) {
-  handleInt$1(gauge$20, chainId, blockNumber);
+function set$17(blockNumber, chainId) {
+  handleInt$1(gauge$18, chainId, blockNumber);
 }
 
 var ProgressBlockNumber = {
-  gauge: gauge$20,
-  set: set$19
+  gauge: gauge$18,
+  set: set$17
 };
 
 var deprecatedGauge$1 = new PromClient.Gauge({
@@ -681,45 +659,70 @@ var deprecatedGauge$1 = new PromClient.Gauge({
       labelNames: ["chainId"]
     });
 
-var gauge$21 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+var gauge$19 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$20(processedCount, chainId) {
+function set$18(processedCount, chainId) {
   deprecatedGauge$1.labels({
           chainId: chainId
         }).set(processedCount);
-  handleInt$1(gauge$21, chainId, processedCount);
+  handleInt$1(gauge$19, chainId, processedCount);
 }
 
 var ProgressEventsCount = {
   deprecatedGauge: deprecatedGauge$1,
-  gauge: gauge$21,
-  set: set$20
+  gauge: gauge$19,
+  set: set$18
+};
+
+var counter$5 = new PromClient.Counter({
+      name: "envio_progress_batches_count",
+      help: "The number of batches processed and reflected in the database."
+    });
+
+function increment$5() {
+  counter$5.inc();
+}
+
+var ProgressBatchCount = {
+  counter: counter$5,
+  increment: increment$5
 };
 
 var effectLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("effect", S$RescriptSchema.string);
     });
 
-var gauge$22 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
+var gauge$20 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
 
-function set$21(callsCount, effectName) {
-  handleInt$1(gauge$22, effectName, callsCount);
+function set$19(callsCount, effectName) {
+  handleInt$1(gauge$20, effectName, callsCount);
 }
 
 var EffectCallsCount = {
-  gauge: gauge$22,
-  set: set$21
+  gauge: gauge$20,
+  set: set$19
 };
 
-var gauge$23 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
+var gauge$21 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$22(count, effectName) {
-  handleInt$1(gauge$23, effectName, count);
+function set$20(count, effectName) {
+  handleInt$1(gauge$21, effectName, count);
 }
 
 var EffectCacheCount = {
-  gauge: gauge$23,
-  set: set$22
+  gauge: gauge$21,
+  set: set$20
+};
+
+var counter$6 = makeOrThrow("envio_effect_cache_invalidations_count", "The number of effect cache invalidations.", effectLabelsSchema);
+
+function increment$6(effectName) {
+  increment(counter$6, effectName);
+}
+
+var EffectCacheInvalidationsCount = {
+  counter: counter$6,
+  increment: increment$6
 };
 
 var operationLabelsSchema = S$RescriptSchema.object(function (s) {
@@ -730,7 +733,7 @@ var timeCounter$2 = makeOrThrow("envio_storage_load_time", "Processing time take
 
 var totalTimeCounter = makeOrThrow("envio_storage_load_total_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
 
-var counter$5 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
+var counter$7 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
 
 var whereSizeCounter = makeOrThrow("envio_storage_load_where_size", "Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.", operationLabelsSchema);
 
@@ -759,7 +762,7 @@ function endOperation(timerRef, operation, whereSize, size) {
     Utils.Dict.deleteInPlace(operations, operation);
   }
   handleInt(totalTimeCounter, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
-  increment(counter$5, operation);
+  increment(counter$7, operation);
   handleInt(whereSizeCounter, operation, whereSize);
   handleInt(sizeCounter, operation, size);
 }
@@ -768,7 +771,7 @@ var StorageLoad = {
   operationLabelsSchema: operationLabelsSchema,
   timeCounter: timeCounter$2,
   totalTimeCounter: totalTimeCounter,
-  counter: counter$5,
+  counter: counter$7,
   whereSizeCounter: whereSizeCounter,
   sizeCounter: sizeCounter,
   operations: operations,
@@ -817,13 +820,13 @@ exports.RollbackEnabled = RollbackEnabled;
 exports.RollbackSuccess = RollbackSuccess;
 exports.RollbackHistoryPrune = RollbackHistoryPrune;
 exports.RollbackTargetBlockNumber = RollbackTargetBlockNumber;
-exports.ProcessingBlockNumber = ProcessingBlockNumber;
-exports.ProcessingBatchSize = ProcessingBatchSize;
 exports.ProcessingMaxBatchSize = ProcessingMaxBatchSize;
 exports.ProgressBlockNumber = ProgressBlockNumber;
 exports.ProgressEventsCount = ProgressEventsCount;
+exports.ProgressBatchCount = ProgressBatchCount;
 exports.effectLabelsSchema = effectLabelsSchema;
 exports.EffectCallsCount = EffectCallsCount;
 exports.EffectCacheCount = EffectCacheCount;
+exports.EffectCacheInvalidationsCount = EffectCacheInvalidationsCount;
 exports.StorageLoad = StorageLoad;
 /* loadEntitiesDurationCounter Not a pure module */

package/src/SafeCheckpointTracking.res

@@ -36,32 +36,31 @@ let make = (
 let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) => {
   let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
 
-  if safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(0) > safeBlockNumber {
-    0
-  } else {
-    let trackingCheckpointsCount = safeCheckpointTracking.checkpointBlockNumbers->Array.length
-    switch trackingCheckpointsCount {
-    | 1 => safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(0)
-    | _ => {
-        let result = ref(None)
-        let idx = ref(1)
+  switch safeCheckpointTracking.checkpointIds {
+  | [] => 0
+  | _
+    if safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(0) > safeBlockNumber => 0
+  | [checkpointId] => checkpointId
+  | _ => {
+      let trackingCheckpointsCount = safeCheckpointTracking.checkpointIds->Array.length
+      let result = ref(None)
+      let idx = ref(1)
 
-        while idx.contents < trackingCheckpointsCount && result.contents === None {
-          if (
-            safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx.contents) >
-              safeBlockNumber
-          ) {
-            result :=
-              Some(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx.contents - 1))
-          }
-          idx := idx.contents + 1
+      while idx.contents < trackingCheckpointsCount && result.contents === None {
+        if (
+          safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx.contents) >
+            safeBlockNumber
+        ) {
+          result :=
+            Some(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx.contents - 1))
         }
+        idx := idx.contents + 1
+      }
 
-        switch result.contents {
-        | Some(checkpointId) => checkpointId
-        | None =>
-          safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(trackingCheckpointsCount - 1)
-        }
+      switch result.contents {
+      | Some(checkpointId) => checkpointId
+      | None =>
+        safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(trackingCheckpointsCount - 1)
       }
     }
   }

package/src/SafeCheckpointTracking.res.js

@@ -21,13 +21,17 @@ function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
 
 function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
   var safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  var match = safeCheckpointTracking.checkpointIds;
+  if (match.length === 0) {
+    return 0;
+  }
   if (safeCheckpointTracking.checkpointBlockNumbers[0] > safeBlockNumber) {
     return 0;
   }
-  var trackingCheckpointsCount = safeCheckpointTracking.checkpointBlockNumbers.length;
-  if (trackingCheckpointsCount === 1) {
-    return safeCheckpointTracking.checkpointIds[0];
+  if (match.length === 1) {
+    return match[0];
   }
+  var trackingCheckpointsCount = safeCheckpointTracking.checkpointIds.length;
   var result;
   var idx = 1;
   while(idx < trackingCheckpointsCount && result === undefined) {

package/src/db/EntityHistory.res

@@ -43,8 +43,9 @@ type t<'entity> = {
 }
 
 let maxPgTableNameLength = 63
+let historyTablePrefix = "envio_history_"
 let historyTableName = (~entityName, ~entityIndex) => {
-  let fullName = "envio_history_" ++ entityName
+  let fullName = historyTablePrefix ++ entityName
   if fullName->String.length > maxPgTableNameLength {
     let entityIndexStr = entityIndex->Belt.Int.toString
     fullName->Js.String.slice(~from=0, ~to_=maxPgTableNameLength - entityIndexStr->String.length) ++
@@ -86,8 +87,6 @@ let fromTable = (table: table, ~schema: S.t<'entity>, ~entityIndex): t<'entity>
     ~isPrimaryKey=true,
   )
 
-  // let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
-
   let entityTableName = table.tableName
   let historyTableName = historyTableName(~entityName=entityTableName, ~entityIndex)
   //ignore composite indices

package/src/db/EntityHistory.res.js

@@ -39,8 +39,10 @@ function makeSetUpdateSchema(entitySchema) {
             });
 }
 
+var historyTablePrefix = "envio_history_";
+
 function historyTableName(entityName, entityIndex) {
-  var fullName = "envio_history_" + entityName;
+  var fullName = historyTablePrefix + entityName;
   if (fullName.length <= 63) {
     return fullName;
   }
@@ -181,6 +183,7 @@ exports.changeFieldName = changeFieldName;
 exports.checkpointIdFieldName = checkpointIdFieldName;
 exports.makeSetUpdateSchema = makeSetUpdateSchema;
 exports.maxPgTableNameLength = maxPgTableNameLength;
+exports.historyTablePrefix = historyTablePrefix;
 exports.historyTableName = historyTableName;
 exports.fromTable = fromTable;
 exports.makePruneStaleEntityHistoryQuery = makePruneStaleEntityHistoryQuery;