envio 2.26.0-rc.2 → 2.26.0

package/package.json

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

package/src/Persistence.res

@@ -53,7 +53,11 @@ type storage = {
     ~items: array<Internal.effectCacheItem>,
     ~initialize: bool,
   ) => promise<unit>,
+  // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
+  // This is not good, but the function does two things:
+  // - Gets info about existing cache tables
+  // - if withUpload is true, it also populates the cache from .envio/cache to the database
   restoreEffectCache: (~withUpload: bool) => promise<array<effectCacheRecord>>,
 }
 

package/src/PgStorage.res

@@ -1,3 +1,5 @@
+let getCacheRowCountFnName = "get_cache_row_count"
+
 let makeCreateIndexQuery = (~tableName, ~indexFields, ~pgSchema) => {
   let indexName = tableName ++ "_" ++ indexFields->Js.Array2.joinWith("_")
   let index = indexFields->Belt.Array.map(idx => `"${idx}"`)->Js.Array2.joinWith(", ")
@@ -133,15 +135,15 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
   functionsQuery :=
     functionsQuery.contents ++
     "\n" ++
-    `CREATE OR REPLACE FUNCTION get_cache_row_count(table_name text) 
-   RETURNS integer AS $$
-   DECLARE
-     result integer;
-   BEGIN
-     EXECUTE format('SELECT COUNT(*) FROM "${pgSchema}".%I', table_name) INTO result;
-     RETURN result;
-   END;
-   $$ LANGUAGE plpgsql;`
+    `CREATE OR REPLACE FUNCTION ${getCacheRowCountFnName}(table_name text) 
+RETURNS integer AS $$
+DECLARE
+  result integer;
+BEGIN
+  EXECUTE format('SELECT COUNT(*) FROM "${pgSchema}".%I', table_name) INTO result;
+  RETURN result;
+END;
+$$ LANGUAGE plpgsql;`
 
   [query.contents]->Js.Array2.concat(
     functionsQuery.contents !== "" ? [functionsQuery.contents] : [],
@@ -445,7 +447,7 @@ type schemaCacheTableInfo = {
 let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
   `SELECT 
     t.table_name,
-    get_cache_row_count(t.table_name) as count
+    ${getCacheRowCountFnName}(t.table_name) as count
    FROM information_schema.tables t
    WHERE t.table_schema = '${pgSchema}' 
    AND t.table_name LIKE '${Internal.cacheTablePrefix}%';`
@@ -577,6 +579,7 @@ let make = (
       queries->Js.Array2.map(query => sql->Postgres.unsafe(query))
     })
 
+    // Integration with other tools like Hasura
     switch onInitialize {
     | Some(onInitialize) => await onInitialize()
     | None => ()
@@ -694,6 +697,7 @@ let make = (
 
     if initialize {
       let _ = await sql->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema))
+      // Integration with other tools like Hasura
       switch onNewTables {
       | Some(onNewTables) => await onNewTables(~tableNames=[table.tableName])
       | None => ()
@@ -828,6 +832,7 @@ let make = (
       await sql->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema))
 
     if withUpload && cacheTableInfo->Utils.Array.notEmpty {
+      // Integration with other tools like Hasura
       switch onNewTables {
       | Some(onNewTables) =>
         await onNewTables(

package/src/PgStorage.res.js

@@ -21,6 +21,8 @@ var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
+var getCacheRowCountFnName = "get_cache_row_count";
+
 function makeCreateIndexQuery(tableName, indexFields, pgSchema) {
   var indexName = tableName + "_" + indexFields.join("_");
   var index = Belt_Array.map(indexFields, (function (idx) {
@@ -111,7 +113,7 @@ function makeInitializeTransaction(pgSchema, pgUser, generalTablesOpt, entitiesO
               query.contents = query.contents + "\n" + makeCreateIndexQuery(derivedFromField.derivedFromEntity, [indexField], pgSchema);
             });
       });
-  functionsQuery.contents = functionsQuery.contents + "\n" + ("CREATE OR REPLACE FUNCTION get_cache_row_count(table_name text) \n   RETURNS integer AS $$\n   DECLARE\n     result integer;\n   BEGIN\n     EXECUTE format('SELECT COUNT(*) FROM \"" + pgSchema + "\".%I', table_name) INTO result;\n     RETURN result;\n   END;\n   $$ LANGUAGE plpgsql;");
+  functionsQuery.contents = functionsQuery.contents + "\n" + ("CREATE OR REPLACE FUNCTION " + getCacheRowCountFnName + "(table_name text) \nRETURNS integer AS $$\nDECLARE\n  result integer;\nBEGIN\n  EXECUTE format('SELECT COUNT(*) FROM \"" + pgSchema + "\".%I', table_name) INTO result;\n  RETURN result;\nEND;\n$$ LANGUAGE plpgsql;");
   return [query.contents].concat(functionsQuery.contents !== "" ? [functionsQuery.contents] : []);
 }
 
@@ -299,7 +301,7 @@ function makeSchemaTableNamesQuery(pgSchema) {
 var cacheTablePrefixLength = Internal.cacheTablePrefix.length;
 
 function makeSchemaCacheTableInfoQuery(pgSchema) {
-  return "SELECT \n    t.table_name,\n    get_cache_row_count(t.table_name) as count\n   FROM information_schema.tables t\n   WHERE t.table_schema = '" + pgSchema + "' \n   AND t.table_name LIKE '" + Internal.cacheTablePrefix + "%';";
+  return "SELECT \n    t.table_name,\n    " + getCacheRowCountFnName + "(t.table_name) as count\n   FROM information_schema.tables t\n   WHERE t.table_schema = '" + pgSchema + "' \n   AND t.table_name LIKE '" + Internal.cacheTablePrefix + "%';";
 }
 
 var psqlExecState = {
@@ -613,6 +615,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
 
 var maxItemsPerQuery = 500;
 
+exports.getCacheRowCountFnName = getCacheRowCountFnName;
 exports.makeCreateIndexQuery = makeCreateIndexQuery;
 exports.makeCreateTableIndicesQuery = makeCreateTableIndicesQuery;
 exports.makeCreateTableQuery = makeCreateTableQuery;

package/src/Utils.res

@@ -516,6 +516,12 @@ module Proxy = {
 }
 
 module Hash = {
+  let fail = name => {
+    Js.Exn.raiseError(
+      `Failed to get hash for ${name}. If you're using a custom Sury schema make it based on the string type with a decoder: const myTypeSchema = S.transform(S.string, undefined, (yourType) => yourType.toString())`,
+    )
+  }
+
   // Hash to JSON string. No specific reason for this,
   // just to stick to at least some sort of spec.
   // After Sury v11 is out we'll be able to do it with schema
@@ -546,13 +552,16 @@ module Hash = {
         if constructor === %raw(`Object`) {
           let hash = ref("{")
           let keys = any->Js.Dict.keys->Js.Array2.sortInPlace
+          let isFirst = ref(true)
           for i in 0 to keys->Js.Array2.length - 1 {
             let key = keys->Js.Array2.unsafe_get(i)
             let value = any->Js.Dict.unsafeGet(key)
-            if i !== 0 {
-              hash := hash.contents ++ ","
-            }
             if value !== %raw(`undefined`) {
+              if isFirst.contents {
+                isFirst := false
+              } else {
+                hash := hash.contents ++ ","
+              }
               // Ideally should escape and wrap the key in double quotes
               // but since we don't need to decode the hash,
               // it's fine to keep it super simple
@@ -563,13 +572,13 @@ module Hash = {
         } else if constructor["name"] === "BigNumber" {
           `"${(any->magic)["toString"]()}"`
         } else {
-          Js.Exn.raiseError(`Don't know how to serialize ${(constructor->magic)["name"]}`)
+          fail((constructor->magic)["name"])
         }
       }
     | "symbol"
     | "function" =>
       (any->magic)["toString"]()
-    | typeof => Js.Exn.raiseError(`Don't know how to serialize ${typeof}`)
+    | typeof => fail(typeof)
     }
   }
 }

package/src/Utils.res.js

@@ -452,6 +452,10 @@ var $$Map = {};
 
 var $$Proxy = {};
 
+function fail(name) {
+  return Js_exn.raiseError("Failed to get hash for " + name + ". If you're using a custom Sury schema make it based on the string type with a decoder: const myTypeSchema = S.transform(S.string, undefined, (yourType) => yourType.toString())");
+}
+
 function makeOrThrow(any) {
   var $$typeof = typeof any;
   switch ($$typeof) {
@@ -484,18 +488,21 @@ function makeOrThrow(any) {
           if (constructor.name === "BigNumber") {
             return "\"" + any.toString() + "\"";
           } else {
-            return Js_exn.raiseError("Don't know how to serialize " + constructor.name);
+            return fail(constructor.name);
           }
         }
         var hash$1 = "{";
         var keys = Object.keys(any).sort();
+        var isFirst = true;
         for(var i$1 = 0 ,i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1){
           var key = keys[i$1];
           var value = any[key];
-          if (i$1 !== 0) {
-            hash$1 = hash$1 + ",";
-          }
           if (value !== undefined) {
+            if (isFirst) {
+              isFirst = false;
+            } else {
+              hash$1 = hash$1 + ",";
+            }
             hash$1 = hash$1 + ("\"" + key + "\":" + makeOrThrow(any[key]));
           }
           
@@ -509,11 +516,12 @@ function makeOrThrow(any) {
     case "undefined" :
         return "null";
     default:
-      return Js_exn.raiseError("Don't know how to serialize " + $$typeof);
+      return fail($$typeof);
   }
 }
 
 var Hash = {
+  fail: fail,
   makeOrThrow: makeOrThrow
 };
 

package/src/bindings/NodeJs.res

@@ -4,6 +4,37 @@ type t
 type exitCode = | @as(0) Success | @as(1) Failure
 @send external exitWithCode: (t, exitCode) => unit = "exit"
 
+module Util = {
+  @unboxed
+  type depth = Int(int) | @as(null) Null
+  @unboxed
+  type compact = Bool(bool) | Int(int)
+  @unboxed
+  type sorted = Bool(bool) | Fn((string, string) => int)
+  @unboxed
+  type getters = | @as(true) True | @as(false) False | @as("get") Get | @as("set") Set
+
+  @unbox
+  type inspectOptions = {
+    showHidden?: bool,
+    depth?: depth,
+    colors?: bool,
+    customInspect?: bool,
+    showProxy?: bool,
+    maxArrayLength?: int,
+    maxStringLength?: int,
+    breakLength?: int,
+    @as("compact") compact?: compact,
+    sorted?: sorted,
+    getters?: string,
+    numericSeparator?: bool,
+  }
+
+  @module("util") external inspect: ('a, inspectOptions) => string = "inspect"
+
+  let inspectObj = a => inspect(a, {showHidden: false, depth: Null, colors: true})
+}
+
 module Process = {
   type t = {env: Js.Dict.t<string>}
   @module external process: t = "process"

package/src/bindings/NodeJs.res.js

@@ -1,6 +1,19 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
+var Util = require("util");
+
+function inspectObj(a) {
+  return Util.inspect(a, {
+              showHidden: false,
+              depth: null,
+              colors: true
+            });
+}
+
+var Util$1 = {
+  inspectObj: inspectObj
+};
 
 var Process = {};
 
@@ -14,8 +27,9 @@ var Fs = {
   Promises: Promises
 };
 
+exports.Util = Util$1;
 exports.Process = Process;
 exports.ChildProcess = ChildProcess;
 exports.Path = Path;
 exports.Fs = Fs;
-/* No side effect */
+/* util Not a pure module */