envio 2.28.0-alpha.1 → 2.28.0-alpha.2

package/package.json

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

package/src/FetchState.res

@@ -818,20 +818,27 @@ let getNextQuery = (
       if (
         p->checkIsFetchingPartition->not && p.latestFetchedBlock.blockNumber < maxQueryBlockNumber
       ) {
-        switch p->makePartitionQuery(
-          ~indexingContracts,
-          ~endBlock=switch blockLag {
-          | 0 => endBlock
-          | _ =>
-            switch endBlock {
-            | Some(endBlock) => Some(Pervasives.min(headBlock, endBlock))
-            // Force head block as an endBlock when blockLag is set
-            // because otherwise HyperSync might return bigger range
-            | None => Some(headBlock)
-            }
-          },
-          ~mergeTarget,
-        ) {
+        let endBlock = switch blockLag {
+        | 0 => endBlock
+        | _ =>
+          switch endBlock {
+          | Some(endBlock) => Some(Pervasives.min(headBlock, endBlock))
+          // Force head block as an endBlock when blockLag is set
+          // because otherwise HyperSync might return bigger range
+          | None => Some(headBlock)
+          }
+        }
+        // Enforce the respose range up until target block
+        // Otherwise for indexers with 100+ partitions
+        // we might blow up the buffer size to more than 600k events
+        // simply because of HyperSync returning extra blocks
+        let endBlock = switch (endBlock, maxQueryBlockNumber < currentBlockHeight) {
+        | (Some(endBlock), true) => Some(Pervasives.min(maxQueryBlockNumber, endBlock))
+        | (None, true) => Some(maxQueryBlockNumber)
+        | (_, false) => endBlock
+        }
+
+        switch p->makePartitionQuery(~indexingContracts, ~endBlock, ~mergeTarget) {
         | Some(q) => queries->Array.push(q)
         | None => ()
         }

package/src/FetchState.res.js

@@ -571,11 +571,20 @@ function getNextQuery(param, concurrencyLimit, targetBufferSize, currentBlockHei
     if (!(!checkIsFetchingPartition(p) && p.latestFetchedBlock.blockNumber < maxQueryBlockNumber)) {
       return ;
     }
-    var q = makePartitionQuery(p, indexingContracts, blockLag !== 0 ? (
-            endBlock !== undefined ? (
-                headBlock < endBlock ? headBlock : endBlock
-              ) : headBlock
-          ) : endBlock, mergeTarget);
+    var endBlock$1 = blockLag !== 0 ? (
+        endBlock !== undefined ? (
+            headBlock < endBlock ? headBlock : endBlock
+          ) : headBlock
+      ) : endBlock;
+    var match = maxQueryBlockNumber < currentBlockHeight;
+    var endBlock$2 = endBlock$1 !== undefined ? (
+        match ? (
+            maxQueryBlockNumber < endBlock$1 ? maxQueryBlockNumber : endBlock$1
+          ) : endBlock$1
+      ) : (
+        match ? maxQueryBlockNumber : endBlock$1
+      );
+    var q = makePartitionQuery(p, indexingContracts, endBlock$2, mergeTarget);
     if (q !== undefined) {
       queries.push(q);
       return ;

package/src/Hasura.res

@@ -218,112 +218,6 @@ let createEntityRelationship = async (
   }
 }
 
-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,
-    })
-  }
-}
-
 let trackDatabase = async (
   ~endpoint,
   ~auth,
@@ -340,7 +234,11 @@ let trackDatabase = async (
     InternalTable.EndOfBlockRangeScannedData.table.tableName,
     InternalTable.DynamicContractRegistry.table.tableName,
   ]
-  let exposedInternalTableNames = [InternalTable.RawEvents.table.tableName]
+  let exposedInternalTableNames = [
+    InternalTable.RawEvents.table.tableName,
+    InternalTable.Views.metaViewName,
+    InternalTable.Views.chainMetadataViewName,
+  ]
   let userTableNames = userEntities->Js.Array2.map(entity => entity.table.tableName)
 
   Logging.info("Tracking tables in Hasura")
@@ -415,6 +313,4 @@ let trackDatabase = async (
       }),
     )
     ->Promise.all
-
-  await trackMeta(~auth, ~endpoint, ~pgSchema)
 }

package/src/Hasura.res.js

@@ -204,72 +204,6 @@ async function createEntityRelationship(pgSchema, endpoint, auth, tableName, rel
   }
 }
 
-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,
@@ -278,7 +212,11 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
     InternalTable.EndOfBlockRangeScannedData.table.tableName,
     InternalTable.DynamicContractRegistry.table.tableName
   ];
-  var exposedInternalTableNames = [InternalTable.RawEvents.table.tableName];
+  var exposedInternalTableNames = [
+    InternalTable.RawEvents.table.tableName,
+    InternalTable.Views.metaViewName,
+    InternalTable.Views.chainMetadataViewName
+  ];
   var userTableNames = userEntities.map(function (entity) {
         return entity.table.tableName;
       });
@@ -308,7 +246,6 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
                                 })
                           ].flat(1);
                 })]));
-  return await trackMeta(auth, endpoint, pgSchema);
 }
 
 exports.auth = auth;
@@ -321,6 +258,5 @@ 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/PgStorage.res

@@ -140,6 +140,10 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
     })
   })
 
+  // Create views for Hasura integration
+  query := query.contents ++ "\n" ++ InternalTable.Views.makeMetaViewQuery(~pgSchema)
+  query := query.contents ++ "\n" ++ InternalTable.Views.makeChainMetadataViewQuery(~pgSchema)
+
   // Populate initial chain data
   switch InternalTable.Chains.makeInitialValuesQuery(~pgSchema, ~chainConfigs) {
   | Some(initialChainsValuesQuery) => query := query.contents ++ "\n" ++ initialChainsValuesQuery
@@ -686,7 +690,9 @@ let make = (
     )
     // Execute all queries within a single transaction for integrity
     let _ = await sql->Postgres.beginSql(sql => {
-      queries->Js.Array2.map(query => sql->Postgres.unsafe(query))
+      // Promise.all might be not safe to use here,
+      // but it's just how it worked before.
+      Promise.all(queries->Js.Array2.map(query => sql->Postgres.unsafe(query)))
     })
 
     let cache = await restoreEffectCache(~withUpload=true)

package/src/PgStorage.res.js

@@ -121,6 +121,8 @@ function makeInitializeTransaction(pgSchema, pgUser, chainConfigsOpt, entitiesOp
               query.contents = query.contents + "\n" + makeCreateIndexQuery(derivedFromField.derivedFromEntity, [indexField], pgSchema);
             });
       });
+  query.contents = query.contents + "\n" + InternalTable.Views.makeMetaViewQuery(pgSchema);
+  query.contents = query.contents + "\n" + InternalTable.Views.makeChainMetadataViewQuery(pgSchema);
   var initialChainsValuesQuery = InternalTable.Chains.makeInitialValuesQuery(pgSchema, chainConfigs);
   if (initialChainsValuesQuery !== undefined) {
     query.contents = query.contents + "\n" + initialChainsValuesQuery;
@@ -486,9 +488,9 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
     }
     var queries = makeInitializeTransaction(pgSchema, pgUser, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
     await sql.begin(function (sql) {
-          return queries.map(function (query) {
-                      return sql.unsafe(query);
-                    });
+          return Promise.all(queries.map(function (query) {
+                          return sql.unsafe(query);
+                        }));
         });
     var cache = await restoreEffectCache(true);
     if (onInitialize !== undefined) {

package/src/bindings/Postgres.res

@@ -89,7 +89,7 @@ type poolConfig = {
 @module
 external makeSql: (~config: poolConfig) => sql = "postgres"
 
-@send external beginSql: (sql, sql => array<promise<unit>>) => promise<unit> = "begin"
+@send external beginSql: (sql, sql => promise<'result>) => promise<'result> = "begin"
 
 // TODO: can explore this approach (https://forum.rescript-lang.org/t/rfc-support-for-tagged-template-literals/3744)
 // @send @variadic

package/src/db/InternalTable.res

@@ -325,6 +325,44 @@ module RawEvents = {
   )
 }
 
+// View names for Hasura integration
+module Views = {
+  let metaViewName = "_meta"
+  let chainMetadataViewName = "chain_metadata"
+
+  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",
+       "${(#buffer_block: Chains.field :> string)}" AS "bufferBlock",
+       "${(#ready_at: Chains.field :> string)}" AS "readyAt",
+       "${(#first_event_block: Chains.field :> string)}" AS "firstEventBlock",
+       "${(#events_processed: Chains.field :> string)}" AS "eventsProcessed",
+       ("${(#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",
+       "${(#_latest_processed_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}";`
+  }
+}
+
 module DynamicContractRegistry = {
   let name = "dynamic_contract_registry"
 

package/src/db/InternalTable.res.js

@@ -221,6 +221,25 @@ var RawEvents = {
   table: table$4
 };
 
+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       \"" + "buffer_block" + "\" AS \"bufferBlock\",\n       \"" + "ready_at" + "\" AS \"readyAt\",\n       \"" + "first_event_block" + "\" AS \"firstEventBlock\",\n       \"" + "events_processed" + "\" AS \"eventsProcessed\",\n       (\"" + "ready_at" + "\" IS NOT NULL) AS \"isReady\"\n     FROM \"" + pgSchema + "\".\"" + table$1.tableName + "\"\n     ORDER 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       \"" + "_latest_processed_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 + "\";";
+}
+
+var Views = {
+  metaViewName: metaViewName,
+  chainMetadataViewName: chainMetadataViewName,
+  makeMetaViewQuery: makeMetaViewQuery,
+  makeChainMetadataViewQuery: makeChainMetadataViewQuery
+};
+
 var name = "dynamic_contract_registry";
 
 function makeId(chainId, contractAddress) {
@@ -291,5 +310,6 @@ exports.Chains = Chains;
 exports.PersistedState = PersistedState;
 exports.EndOfBlockRangeScannedData = EndOfBlockRangeScannedData;
 exports.RawEvents = RawEvents;
+exports.Views = Views;
 exports.DynamicContractRegistry = DynamicContractRegistry;
 /* table Not a pure module */