envio 2.31.0-alpha.2 → 2.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.31.0-alpha.2",
+  "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.2",
-    "envio-linux-arm64": "v2.31.0-alpha.2",
-    "envio-darwin-x64": "v2.31.0-alpha.2",
-    "envio-darwin-arm64": "v2.31.0-alpha.2"
+    "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

@@ -251,6 +251,7 @@ let fuelTransferParamsSchema = S.schema(s => {
 type entity = private {id: string}
 type genericEntityConfig<'entity> = {
   name: string,
+  index: int,
   schema: S.t<'entity>,
   rowsSchema: S.t<array<'entity>>,
   table: Table.table,
@@ -289,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 = {
@@ -301,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

@@ -156,13 +156,13 @@ let init = {
           Logging.info(`Found existing indexer storage. Resuming indexing state...`)
           let initialState = await persistence.storage.resumeInitialState()
           persistence.storageStatus = Ready(initialState)
-          let checkpoints = Js.Dict.empty()
+          let progress = Js.Dict.empty()
           initialState.chains->Js.Array2.forEach(c => {
-            checkpoints->Utils.Dict.setByInt(c.id, c.progressBlockNumber)
+            progress->Utils.Dict.setByInt(c.id, c.progressBlockNumber)
           })
           Logging.info({
             "msg": `Successfully resumed indexing state! Continuing from the last checkpoint.`,
-            "checkpoints": checkpoints,
+            "progress": progress,
           })
         }
         resolveRef.contents()
@@ -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

@@ -82,13 +82,13 @@ async function init(persistence, chainConfigs, resetOpt) {
           TAG: "Ready",
           _0: initialState$1
         };
-        var checkpoints = {};
+        var progress = {};
         initialState$1.chains.forEach(function (c) {
-              checkpoints[c.id] = c.progressBlockNumber;
+              progress[c.id] = c.progressBlockNumber;
             });
         Logging.info({
               msg: "Successfully resumed indexing state! Continuing from the last checkpoint.",
-              checkpoints: checkpoints
+              progress: progress
             });
       }
       
@@ -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

@@ -42,9 +42,20 @@ type t<'entity> = {
   makeGetRollbackRestoredEntitiesQuery: (~pgSchema: string) => string,
 }
 
-let historyTableName = (~entityName) => "envio_history_" ++ entityName
+let maxPgTableNameLength = 63
+let historyTablePrefix = "envio_history_"
+let historyTableName = (~entityName, ~entityIndex) => {
+  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) ++
+      entityIndexStr
+  } else {
+    fullName
+  }
+}
 
-let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
+let fromTable = (table: table, ~schema: S.t<'entity>, ~entityIndex): t<'entity> => {
   let id = "id"
 
   let dataFields = table.fields->Belt.Array.keepMap(field =>
@@ -76,10 +87,8 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
     ~isPrimaryKey=true,
   )
 
-  // let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
-
   let entityTableName = table.tableName
-  let historyTableName = historyTableName(~entityName=entityTableName)
+  let historyTableName = historyTableName(~entityName=entityTableName, ~entityIndex)
   //ignore composite indices
   let table = mkTable(
     historyTableName,
@@ -179,8 +188,8 @@ type safeReorgBlocks = {
 // - Rollbacks will not cross the safe checkpoint id, so rows older than the anchor can never be referenced again.
 // - If nothing changed in reorg threshold (after the safe checkpoint), the current state for that id can be reconstructed from the
 //   origin table; we do not need a pre-safe anchor for it.
-let makePruneStaleEntityHistoryQuery = (~entityName, ~pgSchema) => {
-  let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName)}"`
+let makePruneStaleEntityHistoryQuery = (~entityName, ~entityIndex, ~pgSchema) => {
+  let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
 
   `WITH anchors AS (
   SELECT t.id, MAX(t.${checkpointIdFieldName}) AS keep_checkpoint_id
@@ -202,16 +211,23 @@ WHERE d.id = a.id
   );`
 }
 
-let pruneStaleEntityHistory = (sql, ~entityName, ~pgSchema, ~safeCheckpointId): promise<unit> => {
+let pruneStaleEntityHistory = (
+  sql,
+  ~entityName,
+  ~entityIndex,
+  ~pgSchema,
+  ~safeCheckpointId,
+): promise<unit> => {
   sql->Postgres.preparedUnsafe(
-    makePruneStaleEntityHistoryQuery(~entityName, ~pgSchema),
+    makePruneStaleEntityHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
     [safeCheckpointId]->Utils.magic,
   )
 }
 
 // If an entity doesn't have a history before the update
 // we create it automatically with checkpoint_id 0
-let makeBackfillHistoryQuery = (~pgSchema, ~entityName) => {
+let makeBackfillHistoryQuery = (~pgSchema, ~entityName, ~entityIndex) => {
+  let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   `WITH target_ids AS (
   SELECT UNNEST($1::${(Text: Table.fieldType :> string)}[]) AS id
 ),
@@ -219,17 +235,20 @@ missing_history AS (
   SELECT e.*
   FROM "${pgSchema}"."${entityName}" e
   JOIN target_ids t ON e.id = t.id
-  LEFT JOIN "${pgSchema}"."${historyTableName(~entityName)}" h ON h.id = e.id
+  LEFT JOIN ${historyTableRef} h ON h.id = e.id
   WHERE h.id IS NULL
 )
-INSERT INTO "${pgSchema}"."${historyTableName(~entityName)}"
+INSERT INTO ${historyTableRef}
 SELECT *, 0 AS ${checkpointIdFieldName}, '${(RowAction.SET :> string)}' as ${changeFieldName}
 FROM missing_history;`
 }
 
-let backfillHistory = (sql, ~pgSchema, ~entityName, ~ids: array<string>) => {
+let backfillHistory = (sql, ~pgSchema, ~entityName, ~entityIndex, ~ids: array<string>) => {
   sql
-  ->Postgres.preparedUnsafe(makeBackfillHistoryQuery(~entityName, ~pgSchema), [ids]->Obj.magic)
+  ->Postgres.preparedUnsafe(
+    makeBackfillHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
+    [ids]->Obj.magic,
+  )
   ->Promise.ignoreValue
 }
 
@@ -248,11 +267,12 @@ let insertDeleteUpdates = (
   ->Promise.ignoreValue
 }
 
-let rollback = (sql, ~pgSchema, ~entityName, ~rollbackTargetCheckpointId: int) => {
+let rollback = (sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: int) => {
   sql
   ->Postgres.preparedUnsafe(
     `DELETE FROM "${pgSchema}"."${historyTableName(
         ~entityName,
+        ~entityIndex,
       )}" WHERE "${checkpointIdFieldName}" > $1;`,
     [rollbackTargetCheckpointId]->Utils.magic,
   )

package/src/db/EntityHistory.res.js

@@ -2,6 +2,7 @@
 'use strict';
 
 var Table = require("./Table.res.js");
+var Js_string = require("rescript/lib/js/js_string.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 
@@ -38,11 +39,18 @@ function makeSetUpdateSchema(entitySchema) {
             });
 }
 
-function historyTableName(entityName) {
-  return "envio_history_" + entityName;
+var historyTablePrefix = "envio_history_";
+
+function historyTableName(entityName, entityIndex) {
+  var fullName = historyTablePrefix + entityName;
+  if (fullName.length <= 63) {
+    return fullName;
+  }
+  var entityIndexStr = String(entityIndex);
+  return Js_string.slice(0, 63 - entityIndexStr.length | 0, fullName) + entityIndexStr;
 }
 
-function fromTable(table, schema) {
+function fromTable(table, schema, entityIndex) {
   var dataFields = Belt_Array.keepMap(table.fields, (function (field) {
           if (field.TAG !== "Field") {
             return ;
@@ -84,8 +92,8 @@ function fromTable(table, schema) {
   var actionField = Table.mkField(changeFieldName, name, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined);
   var checkpointIdField = Table.mkField(checkpointIdFieldName, "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined);
   var entityTableName = table.tableName;
-  var historyTableName = "envio_history_" + entityTableName;
-  var table$1 = Table.mkTable(historyTableName, undefined, Belt_Array.concat(dataFields, [
+  var historyTableName$1 = historyTableName(entityTableName, entityIndex);
+  var table$1 = Table.mkTable(historyTableName$1, undefined, Belt_Array.concat(dataFields, [
             checkpointIdField,
             actionField
           ]));
@@ -109,7 +117,7 @@ function fromTable(table, schema) {
         }));
   var selectPartsStr = selectParts.join(", ");
   var makeInsertDeleteUpdatesQuery = function (pgSchema) {
-    return "INSERT INTO \"" + pgSchema + "\".\"" + historyTableName + "\" (" + allFieldNamesStr + ")\nSELECT " + selectPartsStr + "\nFROM UNNEST($1::text[], $2::int[]) AS u(id, checkpoint_id)";
+    return "INSERT INTO \"" + pgSchema + "\".\"" + historyTableName$1 + "\" (" + allFieldNamesStr + ")\nSELECT " + selectPartsStr + "\nFROM UNNEST($1::text[], $2::int[]) AS u(id, checkpoint_id)";
   };
   var dataFieldNames = Belt_Array.keep(Belt_Array.map(table$1.fields, (function (field) {
               return Table.getFieldName(field);
@@ -124,10 +132,10 @@ function fromTable(table, schema) {
             return "\"" + name + "\"";
           })).join(", ");
   var makeGetRollbackRemovedIdsQuery = function (pgSchema) {
-    return "SELECT DISTINCT id\nFROM \"" + pgSchema + "\".\"" + historyTableName + "\"\nWHERE \"" + checkpointIdFieldName + "\" > $1\n  AND NOT EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName + "\" h\n    WHERE h.id = \"" + historyTableName + "\".id\n      AND h.\"" + checkpointIdFieldName + "\" <= $1\n  )";
+    return "SELECT DISTINCT id\nFROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\"\nWHERE \"" + checkpointIdFieldName + "\" > $1\n  AND NOT EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\" h\n    WHERE h.id = \"" + historyTableName$1 + "\".id\n      AND h.\"" + checkpointIdFieldName + "\" <= $1\n  )";
   };
   var makeGetRollbackRestoredEntitiesQuery = function (pgSchema) {
-    return "SELECT DISTINCT ON (id) " + dataFieldsCommaSeparated + "\nFROM \"" + pgSchema + "\".\"" + historyTableName + "\"\nWHERE \"" + checkpointIdFieldName + "\" <= $1\n  AND EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName + "\" h\n    WHERE h.id = \"" + historyTableName + "\".id\n      AND h.\"" + checkpointIdFieldName + "\" > $1\n  )\nORDER BY id, \"" + checkpointIdFieldName + "\" DESC";
+    return "SELECT DISTINCT ON (id) " + dataFieldsCommaSeparated + "\nFROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\"\nWHERE \"" + checkpointIdFieldName + "\" <= $1\n  AND EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\" h\n    WHERE h.id = \"" + historyTableName$1 + "\".id\n      AND h.\"" + checkpointIdFieldName + "\" > $1\n  )\nORDER BY id, \"" + checkpointIdFieldName + "\" DESC";
   };
   return {
           table: table$1,
@@ -139,21 +147,22 @@ function fromTable(table, schema) {
         };
 }
 
-function makePruneStaleEntityHistoryQuery(entityName, pgSchema) {
-  var historyTableRef = "\"" + pgSchema + "\".\"envio_history_" + entityName + "\"";
+function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema) {
+  var historyTableRef = "\"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\"";
   return "WITH anchors AS (\n  SELECT t.id, MAX(t." + checkpointIdFieldName + ") AS keep_checkpoint_id\n  FROM " + historyTableRef + " t WHERE t." + checkpointIdFieldName + " <= $1\n  GROUP BY t.id\n)\nDELETE FROM " + historyTableRef + " d\nUSING anchors a\nWHERE d.id = a.id\n  AND (\n    d." + checkpointIdFieldName + " < a.keep_checkpoint_id\n    OR (\n      d." + checkpointIdFieldName + " = a.keep_checkpoint_id AND\n      NOT EXISTS (\n        SELECT 1 FROM " + historyTableRef + " ps \n        WHERE ps.id = d.id AND ps." + checkpointIdFieldName + " > $1\n      ) \n    )\n  );";
 }
 
-function pruneStaleEntityHistory(sql, entityName, pgSchema, safeCheckpointId) {
-  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, pgSchema), [safeCheckpointId], {prepare: true});
+function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId) {
+  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema), [safeCheckpointId], {prepare: true});
 }
 
-function makeBackfillHistoryQuery(pgSchema, entityName) {
-  return "WITH target_ids AS (\n  SELECT UNNEST($1::TEXT[]) AS id\n),\nmissing_history AS (\n  SELECT e.*\n  FROM \"" + pgSchema + "\".\"" + entityName + "\" e\n  JOIN target_ids t ON e.id = t.id\n  LEFT JOIN \"" + pgSchema + "\".\"envio_history_" + entityName + "\" h ON h.id = e.id\n  WHERE h.id IS NULL\n)\nINSERT INTO \"" + pgSchema + "\".\"envio_history_" + entityName + "\"\nSELECT *, 0 AS " + checkpointIdFieldName + ", '" + "SET" + "' as " + changeFieldName + "\nFROM missing_history;";
+function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex) {
+  var historyTableRef = "\"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\"";
+  return "WITH target_ids AS (\n  SELECT UNNEST($1::TEXT[]) AS id\n),\nmissing_history AS (\n  SELECT e.*\n  FROM \"" + pgSchema + "\".\"" + entityName + "\" e\n  JOIN target_ids t ON e.id = t.id\n  LEFT JOIN " + historyTableRef + " h ON h.id = e.id\n  WHERE h.id IS NULL\n)\nINSERT INTO " + historyTableRef + "\nSELECT *, 0 AS " + checkpointIdFieldName + ", '" + "SET" + "' as " + changeFieldName + "\nFROM missing_history;";
 }
 
-function backfillHistory(sql, pgSchema, entityName, ids) {
-  return sql.unsafe(makeBackfillHistoryQuery(pgSchema, entityName), [ids], {prepare: true});
+function backfillHistory(sql, pgSchema, entityName, entityIndex, ids) {
+  return sql.unsafe(makeBackfillHistoryQuery(pgSchema, entityName, entityIndex), [ids], {prepare: true});
 }
 
 function insertDeleteUpdates(sql, pgSchema, entityHistory, batchDeleteEntityIds, batchDeleteCheckpointIds) {
@@ -163,14 +172,18 @@ function insertDeleteUpdates(sql, pgSchema, entityHistory, batchDeleteEntityIds,
             ], {prepare: true});
 }
 
-function rollback(sql, pgSchema, entityName, rollbackTargetCheckpointId) {
-  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"envio_history_" + entityName + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId], {prepare: true});
+function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {
+  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId], {prepare: true});
 }
 
+var maxPgTableNameLength = 63;
+
 exports.RowAction = RowAction;
 exports.changeFieldName = changeFieldName;
 exports.checkpointIdFieldName = checkpointIdFieldName;
 exports.makeSetUpdateSchema = makeSetUpdateSchema;
+exports.maxPgTableNameLength = maxPgTableNameLength;
+exports.historyTablePrefix = historyTablePrefix;
 exports.historyTableName = historyTableName;
 exports.fromTable = fromTable;
 exports.makePruneStaleEntityHistoryQuery = makePruneStaleEntityHistoryQuery;

package/src/db/InternalTable.res

@@ -7,6 +7,7 @@ let isIndex = true
 
 module DynamicContractRegistry = {
   let name = "dynamic_contract_registry"
+  let index = -1
 
   let makeId = (~chainId, ~contractAddress) => {
     chainId->Belt.Int.toString ++ "-" ++ contractAddress->Address.toString
@@ -58,12 +59,13 @@ module DynamicContractRegistry = {
     ],
   )
 
-  let entityHistory = table->EntityHistory.fromTable(~schema)
+  let entityHistory = table->EntityHistory.fromTable(~schema, ~entityIndex=index)
 
   external castToInternal: t => Internal.entity = "%identity"
 
   let config = {
     name,
+    index,
     schema,
     rowsSchema,
     table,
@@ -606,35 +608,35 @@ module Views = {
 
   let makeMetaViewQuery = (~pgSchema) => {
     `CREATE VIEW "${pgSchema}"."${metaViewName}" AS 
-     SELECT 
-       "${(#id: Chains.field :> string)}" AS "chainId",
-       "${(#start_block: Chains.field :> string)}" AS "startBlock", 
-       "${(#end_block: Chains.field :> string)}" AS "endBlock",
-       "${(#progress_block: Chains.field :> string)}" AS "progressBlock",
-       "${(#buffer_block: Chains.field :> string)}" AS "bufferBlock",
-       "${(#first_event_block: Chains.field :> string)}" AS "firstEventBlock",
-       "${(#events_processed: Chains.field :> string)}" AS "eventsProcessed",
-       "${(#source_block: Chains.field :> string)}" AS "sourceBlock",
-       "${(#ready_at: Chains.field :> string)}" AS "readyAt",
-       ("${(#ready_at: Chains.field :> string)}" IS NOT NULL) AS "isReady"
-     FROM "${pgSchema}"."${Chains.table.tableName}"
-     ORDER BY "${(#id: Chains.field :> string)}";`
+SELECT 
+  "${(#id: Chains.field :> string)}" AS "chainId",
+  "${(#start_block: Chains.field :> string)}" AS "startBlock", 
+  "${(#end_block: Chains.field :> string)}" AS "endBlock",
+  "${(#progress_block: Chains.field :> string)}" AS "progressBlock",
+  "${(#buffer_block: Chains.field :> string)}" AS "bufferBlock",
+  "${(#first_event_block: Chains.field :> string)}" AS "firstEventBlock",
+  "${(#events_processed: Chains.field :> string)}" AS "eventsProcessed",
+  "${(#source_block: Chains.field :> string)}" AS "sourceBlock",
+  "${(#ready_at: Chains.field :> string)}" AS "readyAt",
+  ("${(#ready_at: Chains.field :> string)}" IS NOT NULL) AS "isReady"
+FROM "${pgSchema}"."${Chains.table.tableName}"
+ORDER BY "${(#id: Chains.field :> string)}";`
   }
 
   let makeChainMetadataViewQuery = (~pgSchema) => {
     `CREATE VIEW "${pgSchema}"."${chainMetadataViewName}" AS 
-     SELECT 
-       "${(#source_block: Chains.field :> string)}" AS "block_height",
-       "${(#id: Chains.field :> string)}" AS "chain_id",
-       "${(#end_block: Chains.field :> string)}" AS "end_block", 
-       "${(#first_event_block: Chains.field :> string)}" AS "first_event_block_number",
-       "${(#_is_hyper_sync: Chains.field :> string)}" AS "is_hyper_sync",
-       "${(#buffer_block: Chains.field :> string)}" AS "latest_fetched_block_number",
-       "${(#progress_block: Chains.field :> string)}" AS "latest_processed_block",
-       "${(#_num_batches_fetched: Chains.field :> string)}" AS "num_batches_fetched",
-       "${(#events_processed: Chains.field :> string)}" AS "num_events_processed",
-       "${(#start_block: Chains.field :> string)}" AS "start_block",
-       "${(#ready_at: Chains.field :> string)}" AS "timestamp_caught_up_to_head_or_endblock"
-     FROM "${pgSchema}"."${Chains.table.tableName}";`
+SELECT 
+  "${(#source_block: Chains.field :> string)}" AS "block_height",
+  "${(#id: Chains.field :> string)}" AS "chain_id",
+  "${(#end_block: Chains.field :> string)}" AS "end_block", 
+  "${(#first_event_block: Chains.field :> string)}" AS "first_event_block_number",
+  "${(#_is_hyper_sync: Chains.field :> string)}" AS "is_hyper_sync",
+  "${(#buffer_block: Chains.field :> string)}" AS "latest_fetched_block_number",
+  "${(#progress_block: Chains.field :> string)}" AS "latest_processed_block",
+  "${(#_num_batches_fetched: Chains.field :> string)}" AS "num_batches_fetched",
+  "${(#events_processed: Chains.field :> string)}" AS "num_events_processed",
+  "${(#start_block: Chains.field :> string)}" AS "start_block",
+  "${(#ready_at: Chains.field :> string)}" AS "timestamp_caught_up_to_head_or_endblock"
+FROM "${pgSchema}"."${Chains.table.tableName}";`
   }
 }

package/src/db/InternalTable.res.js

@@ -47,10 +47,11 @@ var table = Table.mkTable(name, undefined, [
       Table.mkField("contract_name", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined)
     ]);
 
-var entityHistory = EntityHistory.fromTable(table, schema);
+var entityHistory = EntityHistory.fromTable(table, schema, -1);
 
 var config = {
   name: name,
+  index: -1,
   schema: schema,
   rowsSchema: rowsSchema,
   table: table,
@@ -59,6 +60,7 @@ var config = {
 
 var DynamicContractRegistry = {
   name: name,
+  index: -1,
   makeId: makeId,
   schema: schema,
   rowsSchema: rowsSchema,
@@ -362,11 +364,11 @@ var metaViewName = "_meta";
 var chainMetadataViewName = "chain_metadata";
 
 function makeMetaViewQuery(pgSchema) {
-  return "CREATE VIEW \"" + pgSchema + "\".\"" + metaViewName + "\" AS \n     SELECT \n       \"" + "id" + "\" AS \"chainId\",\n       \"" + "start_block" + "\" AS \"startBlock\", \n       \"" + "end_block" + "\" AS \"endBlock\",\n       \"" + "progress_block" + "\" AS \"progressBlock\",\n       \"" + "buffer_block" + "\" AS \"bufferBlock\",\n       \"" + "first_event_block" + "\" AS \"firstEventBlock\",\n       \"" + "events_processed" + "\" AS \"eventsProcessed\",\n       \"" + "source_block" + "\" AS \"sourceBlock\",\n       \"" + "ready_at" + "\" AS \"readyAt\",\n       (\"" + "ready_at" + "\" IS NOT NULL) AS \"isReady\"\n     FROM \"" + pgSchema + "\".\"" + table$1.tableName + "\"\n     ORDER BY \"" + "id" + "\";";
+  return "CREATE VIEW \"" + pgSchema + "\".\"" + metaViewName + "\" AS \nSELECT \n  \"" + "id" + "\" AS \"chainId\",\n  \"" + "start_block" + "\" AS \"startBlock\", \n  \"" + "end_block" + "\" AS \"endBlock\",\n  \"" + "progress_block" + "\" AS \"progressBlock\",\n  \"" + "buffer_block" + "\" AS \"bufferBlock\",\n  \"" + "first_event_block" + "\" AS \"firstEventBlock\",\n  \"" + "events_processed" + "\" AS \"eventsProcessed\",\n  \"" + "source_block" + "\" AS \"sourceBlock\",\n  \"" + "ready_at" + "\" AS \"readyAt\",\n  (\"" + "ready_at" + "\" IS NOT NULL) AS \"isReady\"\nFROM \"" + pgSchema + "\".\"" + table$1.tableName + "\"\nORDER BY \"" + "id" + "\";";
 }
 
 function makeChainMetadataViewQuery(pgSchema) {
-  return "CREATE VIEW \"" + pgSchema + "\".\"" + chainMetadataViewName + "\" AS \n     SELECT \n       \"" + "source_block" + "\" AS \"block_height\",\n       \"" + "id" + "\" AS \"chain_id\",\n       \"" + "end_block" + "\" AS \"end_block\", \n       \"" + "first_event_block" + "\" AS \"first_event_block_number\",\n       \"" + "_is_hyper_sync" + "\" AS \"is_hyper_sync\",\n       \"" + "buffer_block" + "\" AS \"latest_fetched_block_number\",\n       \"" + "progress_block" + "\" AS \"latest_processed_block\",\n       \"" + "_num_batches_fetched" + "\" AS \"num_batches_fetched\",\n       \"" + "events_processed" + "\" AS \"num_events_processed\",\n       \"" + "start_block" + "\" AS \"start_block\",\n       \"" + "ready_at" + "\" AS \"timestamp_caught_up_to_head_or_endblock\"\n     FROM \"" + pgSchema + "\".\"" + table$1.tableName + "\";";
+  return "CREATE VIEW \"" + pgSchema + "\".\"" + chainMetadataViewName + "\" AS \nSELECT \n  \"" + "source_block" + "\" AS \"block_height\",\n  \"" + "id" + "\" AS \"chain_id\",\n  \"" + "end_block" + "\" AS \"end_block\", \n  \"" + "first_event_block" + "\" AS \"first_event_block_number\",\n  \"" + "_is_hyper_sync" + "\" AS \"is_hyper_sync\",\n  \"" + "buffer_block" + "\" AS \"latest_fetched_block_number\",\n  \"" + "progress_block" + "\" AS \"latest_processed_block\",\n  \"" + "_num_batches_fetched" + "\" AS \"num_batches_fetched\",\n  \"" + "events_processed" + "\" AS \"num_events_processed\",\n  \"" + "start_block" + "\" AS \"start_block\",\n  \"" + "ready_at" + "\" AS \"timestamp_caught_up_to_head_or_endblock\"\nFROM \"" + pgSchema + "\".\"" + table$1.tableName + "\";";
 }
 
 var Views = {