envio 2.26.0-rc.1 → 2.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.26.0-rc.1",
+  "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.1",
-    "envio-linux-arm64": "v2.26.0-rc.1",
-    "envio-darwin-x64": "v2.26.0-rc.1",
-    "envio-darwin-arm64": "v2.26.0-rc.1"
+    "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/Envio.res

@@ -42,6 +42,8 @@ let experimental_createEffect = (
   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>)
   {
     name: options.name,
     handler: handler->(
@@ -57,9 +59,21 @@ let experimental_createEffect = (
     input: S.schema(_ => options.input)->(
       Utils.magic: S.t<S.t<'input>> => S.t<Internal.effectInput>
     ),
-    output: S.schema(_ => options.output)->(
-      Utils.magic: S.t<S.t<'output>> => S.t<Internal.effectOutput>
-    ),
-    cache: options.cache->Belt.Option.getWithDefault(false),
+    output: outputSchema,
+    cache: switch options.cache {
+    | Some(true) =>
+      let itemSchema = S.schema((s): Internal.effectCacheItem => {
+        id: s.matches(S.string),
+        output: s.matches(outputSchema),
+      })
+      Some({
+        table: Internal.makeCacheTable(~effectName=options.name),
+        rowsSchema: S.array(itemSchema),
+        itemSchema,
+      })
+    | None
+    | Some(false) =>
+      None
+    },
   }->(Utils.magic: Internal.effect => effect<'input, 'output>)
 }

package/src/Envio.res.js

@@ -1,19 +1,37 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
+var Internal = require("./Internal.res.js");
 var Prometheus = require("./Prometheus.res.js");
-var Belt_Option = require("rescript/lib/js/belt_Option.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;
+      });
+  var match = options.cache;
+  var tmp;
+  if (match !== undefined && match) {
+    var itemSchema = S$RescriptSchema.schema(function (s) {
+          return {
+                  id: s.m(S$RescriptSchema.string),
+                  output: s.m(outputSchema)
+                };
+        });
+    tmp = {
+      itemSchema: itemSchema,
+      rowsSchema: S$RescriptSchema.array(itemSchema),
+      table: Internal.makeCacheTable(options.name)
+    };
+  } else {
+    tmp = undefined;
+  }
   return {
           name: options.name,
           handler: handler,
-          cache: Belt_Option.getWithDefault(options.cache, false),
-          output: S$RescriptSchema.schema(function (param) {
-                return options.output;
-              }),
+          cache: tmp,
+          output: outputSchema,
           input: S$RescriptSchema.schema(function (param) {
                 return options.input;
               }),
@@ -22,4 +40,4 @@ function experimental_createEffect(options, handler) {
 }
 
 exports.experimental_createEffect = experimental_createEffect;
-/* Prometheus Not a pure module */
+/* Internal Not a pure module */

package/src/Internal.res

@@ -194,14 +194,31 @@ type effectArgs = {
   context: effectContext,
   cacheKey: string,
 }
+type effectCacheItem = {id: string, output: effectOutput}
+type effectCacheMeta = {
+  itemSchema: S.t<effectCacheItem>,
+  rowsSchema: S.t<array<effectCacheItem>>,
+  table: Table.table,
+}
 type effect = {
   name: string,
   handler: effectArgs => promise<effectOutput>,
-  cache: bool,
+  cache: option<effectCacheMeta>,
   output: S.t<effectOutput>,
   input: S.t<effectInput>,
   mutable callsCount: int,
 }
+let cacheTablePrefix = "envio_effect_"
+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)),
+    ],
+    ~compositeIndices=[],
+  )
+}
 
 @genType.import(("./Types.ts", "Invalid"))
 type noEventFilters

package/src/Internal.res.js

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
+var Table = require("./db/Table.res.js");
 var $$BigInt = require("./bindings/BigInt.res.js");
 var Js_exn = require("rescript/lib/js/js_exn.js");
 var Address = require("./Address.res.js");
@@ -34,6 +35,15 @@ function makeEnumConfig(name, variants) {
         };
 }
 
+var cacheTablePrefix = "envio_effect_";
+
+function makeCacheTable(effectName) {
+  return Table.mkTable(cacheTablePrefix + effectName, [], [
+              Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
+              Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
+            ]);
+}
+
 function prettifyExn(exn) {
   var e = Caml_js_exceptions.internalToOCamlException(exn);
   if (e.RE_EXN_ID === Js_exn.$$Error) {
@@ -46,5 +56,7 @@ function prettifyExn(exn) {
 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/Persistence.res

@@ -49,13 +49,15 @@ type storage = {
   ) => promise<unit>,
   @raises("StorageError")
   setEffectCacheOrThrow: (
-    ~effectName: string,
-    ~ids: array<string>,
-    ~outputs: array<Internal.effectOutput>,
-    ~outputSchema: S.t<Internal.effectOutput>,
+    ~effect: Internal.effect,
+    ~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>>,
 }
 
@@ -176,13 +178,14 @@ let getInitializedStorageOrThrow = persistence => {
   }
 }
 
-let setEffectCacheOrThrow = async (persistence, ~effectName, ~ids, ~outputs, ~outputSchema) => {
+let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items) => {
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
     Js.Exn.raiseError(`Failed to access the indexer storage. The Persistence layer is not initialized.`)
   | Ready({cache}) => {
       let storage = persistence.storage
+      let effectName = effect.name
       let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(effectName) {
       | Some(c) => c
       | None => {
@@ -192,8 +195,8 @@ let setEffectCacheOrThrow = async (persistence, ~effectName, ~ids, ~outputs, ~ou
         }
       }
       let initialize = effectCacheRecord.count === 0
-      await storage.setEffectCacheOrThrow(~effectName, ~ids, ~outputs, ~outputSchema, ~initialize)
-      effectCacheRecord.count = effectCacheRecord.count + ids->Js.Array2.length
+      await storage.setEffectCacheOrThrow(~effect, ~items, ~initialize)
+      effectCacheRecord.count = effectCacheRecord.count + items->Js.Array2.length
       Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
     }
   }

package/src/Persistence.res.js

@@ -113,7 +113,7 @@ function getInitializedStorageOrThrow(persistence) {
   }
 }
 
-async function setEffectCacheOrThrow(persistence, effectName, ids, outputs, outputSchema) {
+async function setEffectCacheOrThrow(persistence, effect, items) {
   var match = persistence.storageStatus;
   if (typeof match !== "object") {
     return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
@@ -123,6 +123,7 @@ async function setEffectCacheOrThrow(persistence, effectName, ids, outputs, outp
   }
   var cache = match.cache;
   var storage = persistence.storage;
+  var effectName = effect.name;
   var c = cache[effectName];
   var effectCacheRecord;
   if (c !== undefined) {
@@ -136,8 +137,8 @@ async function setEffectCacheOrThrow(persistence, effectName, ids, outputs, outp
     effectCacheRecord = c$1;
   }
   var initialize = effectCacheRecord.count === 0;
-  await storage.setEffectCacheOrThrow(effectName, ids, outputs, outputSchema, initialize);
-  effectCacheRecord.count = effectCacheRecord.count + ids.length | 0;
+  await storage.setEffectCacheOrThrow(effect, items, initialize);
+  effectCacheRecord.count = effectCacheRecord.count + items.length | 0;
   return Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName);
 }
 

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] : [],
@@ -433,8 +435,7 @@ let makeSchemaTableNamesQuery = (~pgSchema) => {
   `SELECT table_name FROM information_schema.tables WHERE table_schema = '${pgSchema}';`
 }
 
-let cacheTablePrefix = "envio_effect_"
-let cacheTablePrefixLength = cacheTablePrefix->String.length
+let cacheTablePrefixLength = Internal.cacheTablePrefix->String.length
 
 type schemaCacheTableInfo = {
   @as("table_name")
@@ -446,10 +447,10 @@ 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 '${cacheTablePrefix}%';`
+   AND t.table_name LIKE '${Internal.cacheTablePrefix}%';`
 }
 
 type psqlExecState =
@@ -578,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 => ()
@@ -681,49 +683,28 @@ let make = (
   }
 
   let setEffectCacheOrThrow = async (
-    ~effectName: string,
-    ~ids: array<string>,
-    ~outputs: array<Internal.effectOutput>,
-    ~outputSchema: S.t<Internal.effectOutput>,
+    ~effect: Internal.effect,
+    ~items: array<Internal.effectCacheItem>,
     ~initialize: bool,
   ) => {
-    let table = Table.mkTable(
-      cacheTablePrefix ++ effectName,
-      ~fields=[
-        Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-        Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false)),
-      ],
-      ~compositeIndices=[],
-    )
+    let {table, itemSchema} = switch effect.cache {
+    | Some(cacheMeta) => cacheMeta
+    | None =>
+      Js.Exn.raiseError(
+        `Failed to set effect cache for "${effect.name}". Effect has no cache enabled.`,
+      )
+    }
 
     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 => ()
       }
     }
 
-    let items = []
-    for idx in 0 to outputs->Array.length - 1 {
-      items
-      ->Js.Array2.push({
-        "id": ids[idx],
-        "output": outputs[idx],
-      })
-      ->ignore
-    }
-
-    await setOrThrow(
-      ~items,
-      ~table,
-      ~itemSchema=S.schema(s =>
-        {
-          "id": s.matches(S.string),
-          "output": s.matches(outputSchema),
-        }
-      ),
-    )
+    await setOrThrow(~items, ~table, ~itemSchema)
   }
 
   let dumpEffectCache = async () => {
@@ -807,23 +788,15 @@ let make = (
           let _ =
             await cacheFiles
             ->Js.Array2.map(entry => {
-              let cacheName = entry->Js.String2.slice(~from=0, ~to_=-4) // Remove .tsv extension
-              let tableName = cacheTablePrefix ++ cacheName
-              let table = Table.mkTable(
-                tableName,
-                ~fields=[
-                  Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-                  Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false)),
-                ],
-                ~compositeIndices=[],
-              )
+              let effectName = entry->Js.String2.slice(~from=0, ~to_=-4) // Remove .tsv extension
+              let table = Internal.makeCacheTable(~effectName)
 
               sql
               ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema))
               ->Promise.then(() => {
                 let inputFile = NodeJs.Path.join(cacheDirPath, entry)->NodeJs.Path.toString
 
-                let command = `${psqlExec} -c 'COPY "${pgSchema}"."${tableName}" FROM STDIN WITH (FORMAT text, HEADER);' < ${inputFile}`
+                let command = `${psqlExec} -c 'COPY "${pgSchema}"."${table.tableName}" FROM STDIN WITH (FORMAT text, HEADER);' < ${inputFile}`
 
                 Promise.make(
                   (resolve, reject) => {
@@ -859,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

@@ -13,7 +13,6 @@ var Logging = require("./Logging.res.js");
 var $$Promise = require("./bindings/Promise.res.js");
 var Internal = require("./Internal.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
-var Caml_array = require("rescript/lib/js/caml_array.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var Persistence = require("./Persistence.res.js");
@@ -22,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) {
@@ -112,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] : []);
 }
 
@@ -297,12 +298,10 @@ function makeSchemaTableNamesQuery(pgSchema) {
   return "SELECT table_name FROM information_schema.tables WHERE table_schema = '" + pgSchema + "';";
 }
 
-var cacheTablePrefix = "envio_effect_";
-
-var cacheTablePrefixLength = cacheTablePrefix.length;
+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 '" + 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 = {
@@ -467,11 +466,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
   var setOrThrow$1 = function (items, table, itemSchema) {
     return setOrThrow(sql, items, table, itemSchema, pgSchema);
   };
-  var setEffectCacheOrThrow = async function (effectName, ids, outputs, outputSchema, initialize) {
-    var table = Table.mkTable(cacheTablePrefix + effectName, [], [
-          Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-          Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
-        ]);
+  var setEffectCacheOrThrow = async function (effect, items, initialize) {
+    var cacheMeta = effect.cache;
+    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));
       if (onNewTables !== undefined) {
@@ -479,19 +477,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
       }
       
     }
-    var items = [];
-    for(var idx = 0 ,idx_finish = outputs.length; idx < idx_finish; ++idx){
-      items.push({
-            id: Caml_array.get(ids, idx),
-            output: Caml_array.get(outputs, idx)
-          });
-    }
-    return await setOrThrow$1(items, table, S$RescriptSchema.schema(function (s) {
-                    return {
-                            id: s.m(S$RescriptSchema.string),
-                            output: s.m(outputSchema)
-                          };
-                  }));
+    return await setOrThrow$1(items, table, match.itemSchema);
   };
   var dumpEffectCache = async function () {
     try {
@@ -568,15 +554,11 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
                 return entry.endsWith(".tsv");
               });
           await Promise.all(cacheFiles.map(function (entry) {
-                    var cacheName = entry.slice(0, -4);
-                    var tableName = cacheTablePrefix + cacheName;
-                    var table = Table.mkTable(tableName, [], [
-                          Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-                          Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined)
-                        ]);
+                    var effectName = entry.slice(0, -4);
+                    var table = Internal.makeCacheTable(effectName);
                     return sql.unsafe(makeCreateTableQuery(table, pgSchema)).then(function () {
                                 var inputFile = Path.join(cacheDirPath, entry);
-                                var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
+                                var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + table.tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
                                 return new Promise((function (resolve, reject) {
                                               Child_process.exec(command, psqlExecOptions, (function (error, stdout, param) {
                                                       if (error === null) {
@@ -633,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;
@@ -654,7 +637,6 @@ exports.setQueryCache = setQueryCache;
 exports.setOrThrow = setOrThrow;
 exports.setEntityHistoryOrThrow = setEntityHistoryOrThrow;
 exports.makeSchemaTableNamesQuery = makeSchemaTableNamesQuery;
-exports.cacheTablePrefix = cacheTablePrefix;
 exports.cacheTablePrefixLength = cacheTablePrefixLength;
 exports.makeSchemaCacheTableInfoQuery = makeSchemaCacheTableInfoQuery;
 exports.getConnectedPsqlExec = getConnectedPsqlExec;

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 */