envio 2.27.5 → 2.28.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.27.5",
+  "version": "v2.28.0-alpha.1",
   "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.27.5",
-    "envio-linux-arm64": "v2.27.5",
-    "envio-darwin-x64": "v2.27.5",
-    "envio-darwin-arm64": "v2.27.5"
+    "envio-linux-x64": "v2.28.0-alpha.1",
+    "envio-linux-arm64": "v2.28.0-alpha.1",
+    "envio-darwin-x64": "v2.28.0-alpha.1",
+    "envio-darwin-arm64": "v2.28.0-alpha.1"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.5",

package/rescript.json

@@ -13,6 +13,9 @@
     "in-source": true
   },
   "gentypeconfig": {
+    "shims": {
+      "Js": "Js"
+    },
     "generatedFileExtension": ".gen.ts"
   },
   "bs-dependencies": ["rescript-schema"],

package/src/ErrorHandling.res

@@ -6,18 +6,17 @@ let make = (exn, ~logger=Logging.getLogger(), ~msg=?) => {
 
 let log = (self: t) => {
   switch self {
-  | {exn, msg: Some(msg), logger} =>
-    logger->Logging.childErrorWithExn(exn->Internal.prettifyExn, msg)
-  | {exn, msg: None, logger} => logger->Logging.childError(exn->Internal.prettifyExn)
+  | {exn, msg: Some(msg), logger} => logger->Logging.childErrorWithExn(exn->Utils.prettifyExn, msg)
+  | {exn, msg: None, logger} => logger->Logging.childError(exn->Utils.prettifyExn)
   }
 }
 
 let raiseExn = (self: t) => {
-  self.exn->Internal.prettifyExn->raise
+  self.exn->Utils.prettifyExn->raise
 }
 
 let mkLogAndRaise = (~logger=?, ~msg=?, exn) => {
-  let exn = exn->Internal.prettifyExn
+  let exn = exn->Utils.prettifyExn
   exn->make(~logger?, ~msg?)->log
   exn->raise
 }

package/src/ErrorHandling.res.js

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
+var Utils = require("./Utils.res.js");
 var Logging = require("./Logging.res.js");
-var Internal = require("./Internal.res.js");
 
 function make(exn, loggerOpt, msg) {
   var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
@@ -18,18 +18,18 @@ function log(self) {
   var exn = self.exn;
   var logger = self.logger;
   if (msg !== undefined) {
-    return Logging.childErrorWithExn(logger, Internal.prettifyExn(exn), msg);
+    return Logging.childErrorWithExn(logger, Utils.prettifyExn(exn), msg);
   } else {
-    return Logging.childError(logger, Internal.prettifyExn(exn));
+    return Logging.childError(logger, Utils.prettifyExn(exn));
   }
 }
 
 function raiseExn(self) {
-  throw Internal.prettifyExn(self.exn);
+  throw Utils.prettifyExn(self.exn);
 }
 
 function mkLogAndRaise(logger, msg, exn) {
-  var exn$1 = Internal.prettifyExn(exn);
+  var exn$1 = Utils.prettifyExn(exn);
   log(make(exn$1, logger, msg));
   throw exn$1;
 }
@@ -44,7 +44,7 @@ function unwrapLogAndRaise(logger, msg, result) {
 
 function logAndRaise(self) {
   log(self);
-  throw Internal.prettifyExn(self.exn);
+  throw Utils.prettifyExn(self.exn);
 }
 
 exports.make = make;
@@ -53,4 +53,4 @@ exports.raiseExn = raiseExn;
 exports.mkLogAndRaise = mkLogAndRaise;
 exports.unwrapLogAndRaise = unwrapLogAndRaise;
 exports.logAndRaise = logAndRaise;
-/* Logging Not a pure module */
+/* Utils Not a pure module */

package/src/Hasura.res

@@ -83,7 +83,7 @@ let clearHasuraMetadata = async (~endpoint, ~auth) => {
   | exn =>
     Logging.error({
       "msg": `EE806: There was an issue clearing metadata in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
-      "err": exn->Internal.prettifyExn,
+      "err": exn->Utils.prettifyExn,
     })
   }
 }
@@ -125,7 +125,7 @@ let trackTables = async (~endpoint, ~auth, ~pgSchema, ~tableNames: array<string>
     Logging.error({
       "msg": `EE807: There was an issue tracking tables in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
       "tableNames": tableNames,
-      "err": exn->Internal.prettifyExn,
+      "err": exn->Utils.prettifyExn,
     })
   }
 }
@@ -172,7 +172,7 @@ let createSelectPermissions = async (
     Logging.error({
       "msg": `EE808: There was an issue setting up view permissions for the ${tableName} table in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
       "tableName": tableName,
-      "err": exn->Internal.prettifyExn,
+      "err": exn->Utils.prettifyExn,
     })
   }
 }
@@ -213,7 +213,113 @@ let createEntityRelationship = async (
     Logging.error({
       "msg": `EE808: There was an issue setting up ${relationshipType} relationship for the ${tableName} table in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
       "tableName": tableName,
-      "err": exn->Internal.prettifyExn,
+      "err": exn->Utils.prettifyExn,
+    })
+  }
+}
+
+let trackMeta = async (~auth, ~endpoint, ~pgSchema) => {
+  try {
+    // Track EnvioMeta logical model with scalar fields
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_track_logical_model","args": {"source": "default","name":"EnvioMeta","fields":[{"name":"chainId","type":"int"},{"name":"startBlock","type":"int"},{"name":"endBlock","type":"int","nullable":true},{"name":"bufferBlock","type":"int"},{"name":"readyAt","type":"timestamptz","nullable":true},{"name":"firstEventBlock","type":"int","nullable":true},{"name":"eventsProcessed","type":"int"},{"name":"isReady","type":"bool"}]}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura EnvioMeta logical model created`
+    | AlreadyDone => `Hasura EnvioMeta logical model already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Update _meta native query to return hardcoded block object
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type":"pg_track_native_query","args":{"type":"query","source":"default","root_field_name":"_meta","arguments":{},"returns":"EnvioMeta","code":"SELECT \\\"${(#id: InternalTable.Chains.field :> string)}\\\" AS \\\"chainId\\\", \\\"${(#start_block: InternalTable.Chains.field :> string)}\\\" AS \\\"startBlock\\\", \\\"${(#end_block: InternalTable.Chains.field :> string)}\\\" AS \\\"endBlock\\\", \\\"${(#buffer_block: InternalTable.Chains.field :> string)}\\\" AS \\\"bufferBlock\\\", \\\"${(#ready_at: InternalTable.Chains.field :> string)}\\\" AS \\\"readyAt\\\", \\\"${(#first_event_block: InternalTable.Chains.field :> string)}\\\" AS \\\"firstEventBlock\\\", \\\"${(#events_processed: InternalTable.Chains.field :> string)}\\\" AS \\\"eventsProcessed\\\", (\\\"${(#ready_at: InternalTable.Chains.field :> string)}\\\" IS NOT NULL) AS \\\"isReady\\\" FROM \\\"${pgSchema}\\\".\\\"${InternalTable.Chains.table.tableName}\\\" ORDER BY \\\"id\\\""}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura _meta native query created`
+    | AlreadyDone => `Hasura _meta native query already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Add public select permissions for EnvioMeta logical model
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_create_logical_model_select_permission", "args": {"source": "default", "name": "EnvioMeta", "role": "public", "permission": {"columns": "*", "filter": {}}}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura _meta public select permission created`
+    | AlreadyDone => `Hasura _meta public select permission already exists`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_track_logical_model","args": {"source": "default","name":"chain_metadata","fields":[{"name":"block_height","type":"int"},{"name":"chain_id","type":"int"},{"name":"end_block","type":"int"},{"name":"first_event_block_number","type":"int"},{"name":"is_hyper_sync","type":"boolean"},{"name":"latest_fetched_block_number","type":"int"},{"name":"latest_processed_block","type":"int"},{"name":"num_batches_fetched","type":"int"},{"name":"num_events_processed","type":"int"},{"name":"start_block","type":"int"},{"name":"timestamp_caught_up_to_head_or_endblock","type":"timestamptz"}]}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura chain_metadata logical model created`
+    | AlreadyDone => `Hasura chain_metadata logical model already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Need this to keep backwards compatibility,
+    // since it's used on Hosted Service
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type":"pg_track_native_query","args":{"type":"query","source":"default","root_field_name":"chain_metadata","arguments":{},"returns":"chain_metadata","code":"SELECT \\\"${(#source_block: InternalTable.Chains.field :> string)}\\\" AS \\\"block_height\\\", \\\"${(#id: InternalTable.Chains.field :> string)}\\\" AS \\\"chain_id\\\", \\\"${(#end_block: InternalTable.Chains.field :> string)}\\\", \\\"${(#first_event_block: InternalTable.Chains.field :> string)}\\\" AS \\\"first_event_block_number\\\", \\\"${(#_is_hyper_sync: InternalTable.Chains.field :> string)}\\\" AS \\\"is_hyper_sync\\\", \\\"${(#buffer_block: InternalTable.Chains.field :> string)}\\\" AS \\\"latest_fetched_block_number\\\", \\\"${(#_latest_processed_block: InternalTable.Chains.field :> string)}\\\" AS \\\"latest_processed_block\\\", \\\"${(#_num_batches_fetched: InternalTable.Chains.field :> string)}\\\" AS \\\"num_batches_fetched\\\", \\\"${(#events_processed: InternalTable.Chains.field :> string)}\\\" AS \\\"num_events_processed\\\", \\\"${(#start_block: InternalTable.Chains.field :> string)}\\\", \\\"${(#ready_at: InternalTable.Chains.field :> string)}\\\" AS \\\"timestamp_caught_up_to_head_or_endblock\\\" FROM \\\"${pgSchema}\\\".\\\"${InternalTable.Chains.table.tableName}\\\""}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura chain_metadata native query created`
+    | AlreadyDone => `Hasura chain_metadata native query already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Add public select permissions for chain_metadata logical model
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_create_logical_model_select_permission", "args": {"source": "default", "name": "chain_metadata", "role": "public", "permission": {"columns": "*", "filter": {}}}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura chain_metadata public select permission created`
+    | AlreadyDone => `Hasura chain_metadata public select permission already exists`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+  } catch {
+  | exn =>
+    Logging.error({
+      "msg": `EE808: There was an issue setting up _meta field in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
+      "err": exn->Utils.prettifyExn,
     })
   }
 }
@@ -222,24 +328,39 @@ let trackDatabase = async (
   ~endpoint,
   ~auth,
   ~pgSchema,
-  ~allStaticTables,
-  ~allEntityTables,
+  ~userEntities: array<Internal.entityConfig>,
   ~aggregateEntities,
   ~responseLimit,
   ~schema,
 ) => {
+  let trackOnlyInternalTableNames = [
+    InternalTable.Chains.table.tableName,
+    InternalTable.EventSyncState.table.tableName,
+    InternalTable.PersistedState.table.tableName,
+    InternalTable.EndOfBlockRangeScannedData.table.tableName,
+    InternalTable.DynamicContractRegistry.table.tableName,
+  ]
+  let exposedInternalTableNames = [InternalTable.RawEvents.table.tableName]
+  let userTableNames = userEntities->Js.Array2.map(entity => entity.table.tableName)
+
   Logging.info("Tracking tables in Hasura")
 
   let _ = await clearHasuraMetadata(~endpoint, ~auth)
-  let tableNames =
-    [allStaticTables, allEntityTables]
-    ->Belt.Array.concatMany
-    ->Js.Array2.map(({tableName}: Table.table) => tableName)
 
-  await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
+  await trackTables(
+    ~endpoint,
+    ~auth,
+    ~pgSchema,
+    ~tableNames=[
+      exposedInternalTableNames,
+      trackOnlyInternalTableNames,
+      userTableNames,
+    ]->Belt.Array.concatMany,
+  )
 
   let _ =
-    await tableNames
+    await [exposedInternalTableNames, userTableNames]
+    ->Belt.Array.concatMany
     ->Js.Array2.map(tableName =>
       createSelectPermissions(
         ~endpoint,
@@ -251,11 +372,11 @@ let trackDatabase = async (
       )
     )
     ->Js.Array2.concatMany(
-      allEntityTables->Js.Array2.map(table => {
-        let {tableName} = table
+      userEntities->Js.Array2.map(entityConfig => {
+        let {tableName} = entityConfig.table
         [
           //Set array relationships
-          table
+          entityConfig.table
           ->Table.getDerivedFromFields
           ->Js.Array2.map(derivedFromField => {
             //determines the actual name of the underlying relational field (if it's an entity mapping then suffixes _id for eg.)
@@ -275,7 +396,7 @@ let trackDatabase = async (
             )
           }),
           //Set object relationships
-          table
+          entityConfig.table
           ->Table.getLinkedEntityFields
           ->Js.Array2.map(((field, linkedEntityName)) => {
             createEntityRelationship(
@@ -294,4 +415,6 @@ let trackDatabase = async (
       }),
     )
     ->Promise.all
+
+  await trackMeta(~auth, ~endpoint, ~pgSchema)
 }

package/src/Hasura.res.js

@@ -6,8 +6,8 @@ var Table = require("./db/Table.res.js");
 var Utils = require("./Utils.res.js");
 var Schema = require("./db/Schema.res.js");
 var Logging = require("./Logging.res.js");
-var Internal = require("./Internal.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var InternalTable = require("./db/InternalTable.res.js");
 var Caml_splice_call = require("rescript/lib/js/caml_splice_call.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
@@ -102,7 +102,7 @@ async function clearHasuraMetadata(endpoint, auth) {
     var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
     return Logging.error({
                 msg: "EE806: There was an issue clearing metadata in hasura - indexing may still work - but you may have issues querying the data in hasura.",
-                err: Internal.prettifyExn(exn)
+                err: Utils.prettifyExn(exn)
               });
   }
 }
@@ -138,7 +138,7 @@ async function trackTables(endpoint, auth, pgSchema, tableNames) {
     return Logging.error({
                 msg: "EE807: There was an issue tracking tables in hasura - indexing may still work - but you may have issues querying the data in hasura.",
                 tableNames: tableNames,
-                err: Internal.prettifyExn(exn)
+                err: Utils.prettifyExn(exn)
               });
   }
 }
@@ -174,7 +174,7 @@ async function createSelectPermissions(auth, endpoint, tableName, pgSchema, resp
     return Logging.error({
                 msg: "EE808: There was an issue setting up view permissions for the " + tableName + " table in hasura - indexing may still work - but you may have issues querying the data in hasura.",
                 tableName: tableName,
-                err: Internal.prettifyExn(exn)
+                err: Utils.prettifyExn(exn)
               });
   }
 }
@@ -199,36 +199,116 @@ async function createEntityRelationship(pgSchema, endpoint, auth, tableName, rel
     return Logging.error({
                 msg: "EE808: There was an issue setting up " + relationshipType + " relationship for the " + tableName + " table in hasura - indexing may still work - but you may have issues querying the data in hasura.",
                 tableName: tableName,
-                err: Internal.prettifyExn(exn)
+                err: Utils.prettifyExn(exn)
               });
   }
 }
 
-async function trackDatabase(endpoint, auth, pgSchema, allStaticTables, allEntityTables, aggregateEntities, responseLimit, schema) {
+async function trackMeta(auth, endpoint, pgSchema) {
+  try {
+    var result = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_track_logical_model\",\"args\": {\"source\": \"default\",\"name\":\"EnvioMeta\",\"fields\":[{\"name\":\"chainId\",\"type\":\"int\"},{\"name\":\"startBlock\",\"type\":\"int\"},{\"name\":\"endBlock\",\"type\":\"int\",\"nullable\":true},{\"name\":\"bufferBlock\",\"type\":\"int\"},{\"name\":\"readyAt\",\"type\":\"timestamptz\",\"nullable\":true},{\"name\":\"firstEventBlock\",\"type\":\"int\",\"nullable\":true},{\"name\":\"eventsProcessed\",\"type\":\"int\"},{\"name\":\"isReady\",\"type\":\"bool\"}]}}"
+        }, Rest.client(endpoint, undefined));
+    var msg;
+    msg = result === "QuerySucceeded" ? "Hasura EnvioMeta logical model created" : "Hasura EnvioMeta logical model already created";
+    Logging.trace({
+          msg: msg
+        });
+    var result$1 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\":\"pg_track_native_query\",\"args\":{\"type\":\"query\",\"source\":\"default\",\"root_field_name\":\"_meta\",\"arguments\":{},\"returns\":\"EnvioMeta\",\"code\":\"SELECT \\\"" + "id" + "\\\" AS \\\"chainId\\\", \\\"" + "start_block" + "\\\" AS \\\"startBlock\\\", \\\"" + "end_block" + "\\\" AS \\\"endBlock\\\", \\\"" + "buffer_block" + "\\\" AS \\\"bufferBlock\\\", \\\"" + "ready_at" + "\\\" AS \\\"readyAt\\\", \\\"" + "first_event_block" + "\\\" AS \\\"firstEventBlock\\\", \\\"" + "events_processed" + "\\\" AS \\\"eventsProcessed\\\", (\\\"" + "ready_at" + "\\\" IS NOT NULL) AS \\\"isReady\\\" FROM \\\"" + pgSchema + "\\\".\\\"" + InternalTable.Chains.table.tableName + "\\\" ORDER BY \\\"id\\\"\"}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$1;
+    msg$1 = result$1 === "QuerySucceeded" ? "Hasura _meta native query created" : "Hasura _meta native query already created";
+    Logging.trace({
+          msg: msg$1
+        });
+    var result$2 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_create_logical_model_select_permission\", \"args\": {\"source\": \"default\", \"name\": \"EnvioMeta\", \"role\": \"public\", \"permission\": {\"columns\": \"*\", \"filter\": {}}}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$2;
+    msg$2 = result$2 === "QuerySucceeded" ? "Hasura _meta public select permission created" : "Hasura _meta public select permission already exists";
+    Logging.trace({
+          msg: msg$2
+        });
+    var result$3 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_track_logical_model\",\"args\": {\"source\": \"default\",\"name\":\"chain_metadata\",\"fields\":[{\"name\":\"block_height\",\"type\":\"int\"},{\"name\":\"chain_id\",\"type\":\"int\"},{\"name\":\"end_block\",\"type\":\"int\"},{\"name\":\"first_event_block_number\",\"type\":\"int\"},{\"name\":\"is_hyper_sync\",\"type\":\"boolean\"},{\"name\":\"latest_fetched_block_number\",\"type\":\"int\"},{\"name\":\"latest_processed_block\",\"type\":\"int\"},{\"name\":\"num_batches_fetched\",\"type\":\"int\"},{\"name\":\"num_events_processed\",\"type\":\"int\"},{\"name\":\"start_block\",\"type\":\"int\"},{\"name\":\"timestamp_caught_up_to_head_or_endblock\",\"type\":\"timestamptz\"}]}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$3;
+    msg$3 = result$3 === "QuerySucceeded" ? "Hasura chain_metadata logical model created" : "Hasura chain_metadata logical model already created";
+    Logging.trace({
+          msg: msg$3
+        });
+    var result$4 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\":\"pg_track_native_query\",\"args\":{\"type\":\"query\",\"source\":\"default\",\"root_field_name\":\"chain_metadata\",\"arguments\":{},\"returns\":\"chain_metadata\",\"code\":\"SELECT \\\"" + "source_block" + "\\\" AS \\\"block_height\\\", \\\"" + "id" + "\\\" AS \\\"chain_id\\\", \\\"" + "end_block" + "\\\", \\\"" + "first_event_block" + "\\\" AS \\\"first_event_block_number\\\", \\\"" + "_is_hyper_sync" + "\\\" AS \\\"is_hyper_sync\\\", \\\"" + "buffer_block" + "\\\" AS \\\"latest_fetched_block_number\\\", \\\"" + "_latest_processed_block" + "\\\" AS \\\"latest_processed_block\\\", \\\"" + "_num_batches_fetched" + "\\\" AS \\\"num_batches_fetched\\\", \\\"" + "events_processed" + "\\\" AS \\\"num_events_processed\\\", \\\"" + "start_block" + "\\\", \\\"" + "ready_at" + "\\\" AS \\\"timestamp_caught_up_to_head_or_endblock\\\" FROM \\\"" + pgSchema + "\\\".\\\"" + InternalTable.Chains.table.tableName + "\\\"\"}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$4;
+    msg$4 = result$4 === "QuerySucceeded" ? "Hasura chain_metadata native query created" : "Hasura chain_metadata native query already created";
+    Logging.trace({
+          msg: msg$4
+        });
+    var result$5 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_create_logical_model_select_permission\", \"args\": {\"source\": \"default\", \"name\": \"chain_metadata\", \"role\": \"public\", \"permission\": {\"columns\": \"*\", \"filter\": {}}}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$5;
+    msg$5 = result$5 === "QuerySucceeded" ? "Hasura chain_metadata public select permission created" : "Hasura chain_metadata public select permission already exists";
+    return Logging.trace({
+                msg: msg$5
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Logging.error({
+                msg: "EE808: There was an issue setting up _meta field in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                err: Utils.prettifyExn(exn)
+              });
+  }
+}
+
+async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
+  var trackOnlyInternalTableNames = [
+    InternalTable.Chains.table.tableName,
+    InternalTable.EventSyncState.table.tableName,
+    InternalTable.PersistedState.table.tableName,
+    InternalTable.EndOfBlockRangeScannedData.table.tableName,
+    InternalTable.DynamicContractRegistry.table.tableName
+  ];
+  var exposedInternalTableNames = [InternalTable.RawEvents.table.tableName];
+  var userTableNames = userEntities.map(function (entity) {
+        return entity.table.tableName;
+      });
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
-  var tableNames = Belt_Array.concatMany([
-          allStaticTables,
-          allEntityTables
-        ]).map(function (param) {
-        return param.tableName;
-      });
-  await trackTables(endpoint, auth, pgSchema, tableNames);
-  await Promise.all(Caml_splice_call.spliceObjApply(tableNames.map(function (tableName) {
+  await trackTables(endpoint, auth, pgSchema, Belt_Array.concatMany([
+            exposedInternalTableNames,
+            trackOnlyInternalTableNames,
+            userTableNames
+          ]));
+  await Promise.all(Caml_splice_call.spliceObjApply(Belt_Array.concatMany([
+                  exposedInternalTableNames,
+                  userTableNames
+                ]).map(function (tableName) {
                 return createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities);
-              }), "concat", [allEntityTables.map(function (table) {
-                  var tableName = table.tableName;
+              }), "concat", [userEntities.map(function (entityConfig) {
+                  var match = entityConfig.table;
+                  var tableName = match.tableName;
                   return [
-                            Table.getDerivedFromFields(table).map(function (derivedFromField) {
+                            Table.getDerivedFromFields(entityConfig.table).map(function (derivedFromField) {
                                   var relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
                                   return createEntityRelationship(pgSchema, endpoint, auth, tableName, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true);
                                 }),
-                            Table.getLinkedEntityFields(table).map(function (param) {
+                            Table.getLinkedEntityFields(entityConfig.table).map(function (param) {
                                   var field = param[0];
                                   return createEntityRelationship(pgSchema, endpoint, auth, tableName, "object", field.fieldName, field.fieldName, param[1], false);
                                 })
                           ].flat(1);
                 })]));
+  return await trackMeta(auth, endpoint, pgSchema);
 }
 
 exports.auth = auth;
@@ -241,5 +321,6 @@ exports.clearHasuraMetadata = clearHasuraMetadata;
 exports.trackTables = trackTables;
 exports.createSelectPermissions = createSelectPermissions;
 exports.createEntityRelationship = createEntityRelationship;
+exports.trackMeta = trackMeta;
 exports.trackDatabase = trackDatabase;
 /* Rest Not a pure module */

package/src/Internal.res

@@ -176,13 +176,16 @@ let fuelTransferParamsSchema = S.schema(s => {
 })
 
 type entity = private {id: string}
-type entityConfig = {
+type genericEntityConfig<'entity> = {
   name: string,
-  schema: S.t<entity>,
-  rowsSchema: S.t<array<entity>>,
+  schema: S.t<'entity>,
+  rowsSchema: S.t<array<'entity>>,
   table: Table.table,
-  entityHistory: EntityHistory.t<entity>,
+  entityHistory: EntityHistory.t<'entity>,
 }
+type entityConfig = genericEntityConfig<entity>
+external fromGenericEntityConfig: genericEntityConfig<'entity> => entityConfig = "%identity"
+
 type enum
 type enumConfig<'enum> = {
   name: string,
@@ -238,10 +241,3 @@ let makeCacheTable = (~effectName) => {
 
 @genType.import(("./Types.ts", "Invalid"))
 type noEventFilters
-
-let prettifyExn = exn => {
-  switch exn->Js.Exn.anyToExnInternal {
-  | Js.Exn.Error(e) => e->(Utils.magic: Js.Exn.t => exn)
-  | exn => exn
-  }
-}

package/src/Internal.res.js

@@ -8,7 +8,6 @@ var Address = require("./Address.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
-var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
 var fuelSupplyParamsSchema = S$RescriptSchema.schema(function (s) {
       return {
@@ -44,19 +43,9 @@ function makeCacheTable(effectName) {
             ]);
 }
 
-function prettifyExn(exn) {
-  var e = Caml_js_exceptions.internalToOCamlException(exn);
-  if (e.RE_EXN_ID === Js_exn.$$Error) {
-    return e._1;
-  } else {
-    return e;
-  }
-}
-
 exports.fuelSupplyParamsSchema = fuelSupplyParamsSchema;
 exports.fuelTransferParamsSchema = fuelTransferParamsSchema;
 exports.makeEnumConfig = makeEnumConfig;
 exports.cacheTablePrefix = cacheTablePrefix;
 exports.makeCacheTable = makeCacheTable;
-exports.prettifyExn = prettifyExn;
 /* fuelSupplyParamsSchema Not a pure module */

package/src/InternalConfig.res

@@ -0,0 +1,20 @@
+// TODO: rename the file to Config.res after finishing the migration from codegen
+// And turn it into PublicConfig instead
+// For internal use we should create Indexer.res with a stateful type
+
+type contract = {
+  name: string,
+  abi: EvmTypes.Abi.t,
+  addresses: array<Address.t>,
+  events: array<Internal.eventConfig>,
+  startBlock: option<int>,
+}
+
+type chain = {
+  id: int,
+  startBlock: int,
+  endBlock?: int,
+  confirmedBlockThreshold: int,
+  contracts: array<contract>,
+  sources: array<Source.t>,
+}

package/src/InternalConfig.res.js

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/Js.shim.ts

@@ -0,0 +1,11 @@
+export type Json_t =
+  | string
+  | boolean
+  | number
+  | null
+  | { [key: string]: Json_t }
+  | Json_t[];
+
+export type t = unknown;
+
+export type Exn_t = Error;

package/src/LoadManager.res

@@ -66,26 +66,32 @@ let schedule = async loadManager => {
       }
     })
 
-    if inputsToLoad->Utils.Array.isEmpty->not {
+    let isSuccess = if inputsToLoad->Utils.Array.isEmpty->not {
       try {
         await group.load(inputsToLoad)
+        true
       } catch {
       | exn => {
-          let exn = exn->Internal.prettifyExn
+          let exn = exn->Utils.prettifyExn
           currentInputKeys->Array.forEach(inputKey => {
             let call = calls->Js.Dict.unsafeGet(inputKey)
             call.reject(exn)
           })
+          false
         }
       }
+    } else {
+      true
     }
 
     if currentInputKeys->Utils.Array.isEmpty->not {
-      currentInputKeys->Js.Array2.forEach(inputKey => {
-        let call = calls->Js.Dict.unsafeGet(inputKey)
-        calls->Utils.Dict.deleteInPlace(inputKey)
-        call.resolve(group.getUnsafeInMemory(inputKey))
-      })
+      if isSuccess {
+        currentInputKeys->Js.Array2.forEach(inputKey => {
+          let call = calls->Js.Dict.unsafeGet(inputKey)
+          calls->Utils.Dict.deleteInPlace(inputKey)
+          call.resolve(group.getUnsafeInMemory(inputKey))
+        })
+      }
 
       // Clean up executed batch to reset
       // provided load function which