envio 2.26.0-rc.2 → 2.27.0

package/evm.schema.json

@@ -106,6 +106,13 @@
         "boolean",
         "null"
       ]
+    },
+    "preload_handlers": {
+      "description": "Makes handlers run twice to enable preload optimisations. Removes handlerWithLoader API, since it's not needed. (recommended, default: false)",
+      "type": [
+        "boolean",
+        "null"
+      ]
     }
   },
   "additionalProperties": false,
@@ -576,6 +583,15 @@
           "description": "A single address or a list of addresses to be indexed. This can be left as null in the case where this contracts addresses will be registered dynamically.",
           "$ref": "#/$defs/Addresses"
         },
+        "start_block": {
+          "description": "The block at which the indexer should start ingesting data for this specific contract. If not specified, uses the network start_block. Can be greater than the network start_block for more specific indexing.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0
+        },
         "abi_file_path": {
           "description": "Relative path (from config) to a json abi. If this is used then each configured event should simply be referenced by its name",
           "type": [

package/fuel.schema.json

@@ -56,6 +56,13 @@
         "boolean",
         "null"
       ]
+    },
+    "preload_handlers": {
+      "description": "Makes handlers run twice to enable preload optimisations. Removes handlerWithLoader API, since it's not needed. (recommended, default: false)",
+      "type": [
+        "boolean",
+        "null"
+      ]
     }
   },
   "additionalProperties": false,
@@ -217,6 +224,15 @@
           "description": "A single address or a list of addresses to be indexed. This can be left as null in the case where this contracts addresses will be registered dynamically.",
           "$ref": "#/$defs/Addresses"
         },
+        "start_block": {
+          "description": "The block at which the indexer should start ingesting data for this specific contract. If not specified, uses the network start_block. Can be greater than the network start_block for more specific indexing.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0
+        },
         "abi_file_path": {
           "description": "Relative path (from config) to a json abi.",
           "type": "string"

package/index.d.ts

@@ -95,6 +95,7 @@ export function experimental_createEffect<
 // Important! Should match the index.js file
 export declare namespace S {
   export type Output<T> = Sury.Output<T>;
+  export type Infer<T> = Sury.Output<T>;
   export type Input<T> = Sury.Input<T>;
   export type Schema<Output, Input = unknown> = Sury.Schema<Output, Input>;
   export const string: typeof Sury.string;

package/package.json

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

package/src/EventRegister.res

@@ -0,0 +1,92 @@
+type t = {
+  contractName: string,
+  eventName: string,
+  mutable handler: option<Internal.handler>,
+  mutable contractRegister: option<Internal.contractRegister>,
+  mutable eventOptions: option<Internal.eventOptions<Js.Json.t>>,
+}
+
+let getHandler = (t: t) => t.handler
+
+let getContractRegister = (t: t) => t.contractRegister
+
+let getEventFilters = (t: t) => t.eventOptions->Belt.Option.flatMap(value => value.eventFilters)
+
+let isWildcard = (t: t) =>
+  t.eventOptions->Belt.Option.flatMap(value => value.wildcard)->Belt.Option.getWithDefault(false)
+
+let hasRegistration = ({handler, contractRegister}) =>
+  handler->Belt.Option.isSome || contractRegister->Belt.Option.isSome
+
+let make = (~contractName, ~eventName) => {
+  contractName,
+  eventName,
+  handler: None,
+  contractRegister: None,
+  eventOptions: None,
+}
+
+type eventNamespace = {contractName: string, eventName: string}
+exception DuplicateEventRegistration(eventNamespace)
+
+let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch eventOptions {
+  | Some(value) =>
+    let value =
+      value->(Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<Js.Json.t>)
+    switch t.eventOptions {
+    | None => t.eventOptions = Some(value)
+    | Some(existingValue) =>
+      if (
+        existingValue.wildcard !== value.wildcard ||
+          // TODO: Can improve the check by using deepEqual
+          existingValue.eventFilters !== value.eventFilters
+      ) {
+        let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+        DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
+          ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
+          ~msg="Duplicate eventOptions in handlers not allowed",
+        )
+      }
+    }
+  | None => ()
+  }
+}
+
+let setHandler = (t: t, handler, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch t.handler {
+  | None =>
+    t.handler =
+      handler
+      ->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
+      ->Some
+  | Some(_) =>
+    let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+    DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
+      ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
+      ~msg="Duplicate registration of event handlers not allowed",
+    )
+  }
+
+  t->setEventOptions(~eventOptions, ~logger)
+}
+
+let setContractRegister = (t: t, contractRegister, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch t.contractRegister {
+  | None =>
+    t.contractRegister = Some(
+      contractRegister->(
+        Utils.magic: Internal.genericContractRegister<
+          Internal.genericContractRegisterArgs<'event, 'context>,
+        > => Internal.contractRegister
+      ),
+    )
+  | Some(_) =>
+    let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+    DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
+      ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
+      ~msg="Duplicate contractRegister handlers not allowed",
+    )
+  }
+  t->setEventOptions(~eventOptions, ~logger)
+}

package/src/EventRegister.res.js

@@ -0,0 +1,124 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Logging = require("./Logging.res.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+
+function getHandler(t) {
+  return t.handler;
+}
+
+function getContractRegister(t) {
+  return t.contractRegister;
+}
+
+function getEventFilters(t) {
+  return Belt_Option.flatMap(t.eventOptions, (function (value) {
+                return value.eventFilters;
+              }));
+}
+
+function isWildcard(t) {
+  return Belt_Option.getWithDefault(Belt_Option.flatMap(t.eventOptions, (function (value) {
+                    return value.wildcard;
+                  })), false);
+}
+
+function hasRegistration(param) {
+  var handler = param.handler;
+  var contractRegister = param.contractRegister;
+  if (Belt_Option.isSome(handler)) {
+    return true;
+  } else {
+    return Belt_Option.isSome(contractRegister);
+  }
+}
+
+function make(contractName, eventName) {
+  return {
+          contractName: contractName,
+          eventName: eventName,
+          handler: undefined,
+          contractRegister: undefined,
+          eventOptions: undefined
+        };
+}
+
+var DuplicateEventRegistration = /* @__PURE__ */Caml_exceptions.create("EventRegister.DuplicateEventRegistration");
+
+function setEventOptions(t, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  if (eventOptions === undefined) {
+    return ;
+  }
+  var existingValue = t.eventOptions;
+  if (existingValue === undefined) {
+    t.eventOptions = eventOptions;
+    return ;
+  }
+  if (!(existingValue.wildcard !== eventOptions.wildcard || existingValue.eventFilters !== eventOptions.eventFilters)) {
+    return ;
+  }
+  var eventNamespace_contractName = t.contractName;
+  var eventNamespace_eventName = t.eventName;
+  var eventNamespace = {
+    contractName: eventNamespace_contractName,
+    eventName: eventNamespace_eventName
+  };
+  ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate eventOptions in handlers not allowed", {
+        RE_EXN_ID: DuplicateEventRegistration,
+        _1: eventNamespace
+      });
+}
+
+function setHandler(t, handler, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  var match = t.handler;
+  if (match !== undefined) {
+    var eventNamespace_contractName = t.contractName;
+    var eventNamespace_eventName = t.eventName;
+    var eventNamespace = {
+      contractName: eventNamespace_contractName,
+      eventName: eventNamespace_eventName
+    };
+    ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate registration of event handlers not allowed", {
+          RE_EXN_ID: DuplicateEventRegistration,
+          _1: eventNamespace
+        });
+  } else {
+    t.handler = handler;
+  }
+  setEventOptions(t, eventOptions, logger);
+}
+
+function setContractRegister(t, contractRegister, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  var match = t.contractRegister;
+  if (match !== undefined) {
+    var eventNamespace_contractName = t.contractName;
+    var eventNamespace_eventName = t.eventName;
+    var eventNamespace = {
+      contractName: eventNamespace_contractName,
+      eventName: eventNamespace_eventName
+    };
+    ErrorHandling.mkLogAndRaise(Logging.createChildFrom(logger, eventNamespace), "Duplicate contractRegister handlers not allowed", {
+          RE_EXN_ID: DuplicateEventRegistration,
+          _1: eventNamespace
+        });
+  } else {
+    t.contractRegister = contractRegister;
+  }
+  setEventOptions(t, eventOptions, logger);
+}
+
+exports.make = make;
+exports.setHandler = setHandler;
+exports.setContractRegister = setContractRegister;
+exports.getHandler = getHandler;
+exports.getContractRegister = getContractRegister;
+exports.getEventFilters = getEventFilters;
+exports.isWildcard = isWildcard;
+exports.hasRegistration = hasRegistration;
+/* Logging Not a pure module */

package/src/EventRegister.resi

@@ -0,0 +1,21 @@
+type t
+let make: (~contractName: string, ~eventName: string) => t
+let setHandler: (
+  t,
+  Internal.genericHandler<
+    Internal.genericHandlerArgs<'event, Internal.handlerContext, 'loaderReturn>,
+  >,
+  ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
+  ~logger: Pino.t=?,
+) => unit
+let setContractRegister: (
+  t,
+  Internal.genericContractRegister<Internal.genericContractRegisterArgs<'event, 'context>>,
+  ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
+  ~logger: Pino.t=?,
+) => unit
+let getHandler: t => option<Internal.handler>
+let getContractRegister: t => option<Internal.contractRegister>
+let getEventFilters: t => option<Js.Json.t>
+let isWildcard: t => bool
+let hasRegistration: t => bool

package/src/FetchState.res

@@ -966,8 +966,7 @@ let make = (
   ~startBlock,
   ~endBlock,
   ~eventConfigs: array<Internal.eventConfig>,
-  ~staticContracts: dict<array<Address.t>>,
-  ~dynamicContracts: array<indexingContract>,
+  ~contracts: array<indexingContract>,
   ~maxAddrInPartition,
   ~chainId,
   ~blockLag=?,
@@ -1041,49 +1040,21 @@ let make = (
 
       let pendingNormalPartition = ref(makePendingNormalPartition())
 
-      let registerAddress = (contractName, address, ~dc: option<indexingContract>=?) => {
-        let pendingPartition = pendingNormalPartition.contents
-        switch pendingPartition.addressesByContractName->Utils.Dict.dangerouslyGetNonOption(
-          contractName,
-        ) {
-        | Some(addresses) => addresses->Array.push(address)
-        | None => pendingPartition.addressesByContractName->Js.Dict.set(contractName, [address])
-        }
-        indexingContracts->Js.Dict.set(
-          address->Address.toString,
-          switch dc {
-          | Some(dc) => dc
-          | None => {
-              address,
-              contractName,
-              startBlock,
-              register: Config,
-            }
-          },
-        )
-        if (
-          pendingPartition.addressesByContractName->addressesByContractNameCount ===
-            maxAddrInPartition
-        ) {
-          partitions->Array.push(pendingPartition)
-          pendingNormalPartition := makePendingNormalPartition()
-        }
-      }
-
-      staticContracts
-      ->Js.Dict.entries
-      ->Array.forEach(((contractName, addresses)) => {
-        if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          addresses->Array.forEach(a => {
-            registerAddress(contractName, a)
-          })
-        }
-      })
-
-      dynamicContracts->Array.forEach(dc => {
-        let contractName = dc.contractName
+      contracts->Array.forEach(contract => {
+        let contractName = contract.contractName
         if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          registerAddress(contractName, dc.address, ~dc)
+          let pendingPartition = pendingNormalPartition.contents
+          pendingPartition.addressesByContractName->Utils.Dict.push(contractName, contract.address)
+          indexingContracts->Js.Dict.set(contract.address->Address.toString, contract)
+          if (
+            pendingPartition.addressesByContractName->addressesByContractNameCount ===
+              maxAddrInPartition
+          ) {
+            // FIXME: should split into separate partitions
+            // depending on the start block
+            partitions->Array.push(pendingPartition)
+            pendingNormalPartition := makePendingNormalPartition()
+          }
         }
       })
 

package/src/FetchState.res.js

@@ -698,7 +698,7 @@ function getEarliestEvent(param) {
   }
 }
 
-function make(startBlock, endBlock, eventConfigs, staticContracts, dynamicContracts, maxAddrInPartition, chainId, blockLag) {
+function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, blockLag) {
   var latestFetchedBlock_blockNumber = startBlock - 1 | 0;
   var latestFetchedBlock = {
     blockNumber: latestFetchedBlock_blockNumber,
@@ -761,40 +761,18 @@ function make(startBlock, endBlock, eventConfigs, staticContracts, dynamicContra
     var pendingNormalPartition = {
       contents: makePendingNormalPartition()
     };
-    var registerAddress = function (contractName, address, dc) {
-      var pendingPartition = pendingNormalPartition.contents;
-      var addresses = pendingPartition.addressesByContractName[contractName];
-      if (addresses !== undefined) {
-        addresses.push(address);
-      } else {
-        pendingPartition.addressesByContractName[contractName] = [address];
-      }
-      indexingContracts[address] = dc !== undefined ? dc : ({
-            address: address,
-            contractName: contractName,
-            startBlock: startBlock,
-            register: "Config"
-          });
-      if (addressesByContractNameCount(pendingPartition.addressesByContractName) === maxAddrInPartition) {
-        partitions.push(pendingPartition);
-        pendingNormalPartition.contents = makePendingNormalPartition();
-        return ;
-      }
-      
-    };
-    Belt_Array.forEach(Js_dict.entries(staticContracts), (function (param) {
-            var contractName = param[0];
-            if (contractNamesWithNormalEvents.has(contractName)) {
-              return Belt_Array.forEach(param[1], (function (a) {
-                            registerAddress(contractName, a, undefined);
-                          }));
+    Belt_Array.forEach(contracts, (function (contract) {
+            var contractName = contract.contractName;
+            if (!contractNamesWithNormalEvents.has(contractName)) {
+              return ;
             }
-            
-          }));
-    Belt_Array.forEach(dynamicContracts, (function (dc) {
-            var contractName = dc.contractName;
-            if (contractNamesWithNormalEvents.has(contractName)) {
-              return registerAddress(contractName, dc.address, dc);
+            var pendingPartition = pendingNormalPartition.contents;
+            Utils.Dict.push(pendingPartition.addressesByContractName, contractName, contract.address);
+            indexingContracts[contract.address] = contract;
+            if (addressesByContractNameCount(pendingPartition.addressesByContractName) === maxAddrInPartition) {
+              partitions.push(pendingPartition);
+              pendingNormalPartition.contents = makePendingNormalPartition();
+              return ;
             }
             
           }));

package/src/Internal.gen.ts

@@ -34,6 +34,14 @@ export type genericHandlerArgs<event,context,loaderReturn> = {
 
 export type genericHandler<args> = (_1:args) => Promise<void>;
 
+export type entityHandlerContext<entity> = {
+  readonly get: (_1:string) => Promise<(undefined | entity)>; 
+  readonly getOrThrow: (_1:string, message:(undefined | string)) => Promise<entity>; 
+  readonly getOrCreate: (_1:entity) => Promise<entity>; 
+  readonly set: (_1:entity) => void; 
+  readonly deleteUnsafe: (_1:string) => void
+};
+
 export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly loader: loader; 
   readonly handler: handler; 
@@ -43,6 +51,13 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly preRegisterDynamicContracts?: boolean
 };
 
+export type eventOptions<eventFilters> = {
+  readonly wildcard?: boolean; 
+  readonly eventFilters?: eventFilters; 
+  /** @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration. */
+  readonly preRegisterDynamicContracts?: boolean
+};
+
 export type fuelSupplyParams = { readonly subId: string; readonly amount: bigint };
 
 export type fuelTransferParams = {

package/src/Internal.res

@@ -16,8 +16,6 @@ type event = genericEvent<eventParams, eventBlock, eventTransaction>
 
 external fromGenericEvent: genericEvent<'a, 'b, 'c> => event = "%identity"
 
-type loaderReturn
-
 @genType
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
@@ -26,10 +24,6 @@ type genericLoaderArgs<'event, 'context> = {
 @genType
 type genericLoader<'args, 'loaderReturn> = 'args => promise<'loaderReturn>
 
-type loaderContext
-type loaderArgs = genericLoaderArgs<event, loaderContext>
-type loader = genericLoader<loaderArgs, loaderReturn>
-
 @genType
 type genericContractRegisterArgs<'event, 'context> = {
   event: 'event,
@@ -51,8 +45,21 @@ type genericHandlerArgs<'event, 'context, 'loaderReturn> = {
 @genType
 type genericHandler<'args> = 'args => promise<unit>
 
-type handlerContext
-type handlerArgs = genericHandlerArgs<event, handlerContext, loaderReturn>
+@genType
+type entityHandlerContext<'entity> = {
+  get: string => promise<option<'entity>>,
+  getOrThrow: (string, ~message: string=?) => promise<'entity>,
+  getOrCreate: 'entity => promise<'entity>,
+  set: 'entity => unit,
+  deleteUnsafe: string => unit,
+}
+
+type loaderReturn
+type handlerContext = private {isPreload: bool}
+type handlerArgs = {
+  event: event,
+  context: handlerContext,
+}
 type handler = genericHandler<handlerArgs>
 
 @genType
@@ -81,7 +88,6 @@ type eventConfig = private {
   // Usually always false for wildcard events
   // But might be true for wildcard event with dynamic event filter by addresses
   dependsOnAddresses: bool,
-  loader: option<loader>,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
   paramsRawEventSchema: S.schema<eventParams>,
@@ -138,6 +144,16 @@ type eventItem = {
   mutable loggerCache?: Pino.t,
 }
 
+@genType
+type eventOptions<'eventFilters> = {
+  wildcard?: bool,
+  eventFilters?: 'eventFilters,
+  /**
+    @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration.
+  */
+  preRegisterDynamicContracts?: bool,
+}
+
 @genType
 type fuelSupplyParams = {
   subId: string,
@@ -214,7 +230,7 @@ let makeCacheTable = (~effectName) => {
     cacheTablePrefix ++ effectName,
     ~fields=[
       Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-      Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false)),
+      Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false), ~isNullable=true),
     ],
     ~compositeIndices=[],
   )

package/src/Internal.res.js

@@ -40,7 +40,7 @@ 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)
+              Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, true, undefined, undefined, undefined)
             ]);
 }
 

package/src/Logging.res

@@ -155,6 +155,7 @@ let getEventLogger = (eventItem: Internal.eventItem) => {
           "chainId": eventItem.chain->ChainMap.Chain.toChainId,
           "block": eventItem.blockNumber,
           "logIndex": eventItem.logIndex,
+          "address": eventItem.event.srcAddress,
         }->createChildParams,
       )
       eventItem.loggerCache = Some(l)

package/src/Logging.res.js

@@ -187,7 +187,8 @@ function getEventLogger(eventItem) {
             eventName: eventItem.eventConfig.name,
             chainId: eventItem.chain,
             block: eventItem.blockNumber,
-            logIndex: eventItem.logIndex
+            logIndex: eventItem.logIndex,
+            address: eventItem.event.srcAddress
           }));
   eventItem.loggerCache = l$1;
   return l$1;

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

package/src/bindings/Promise.res

@@ -53,6 +53,8 @@ external race: array<t<'a>> => t<'a> = "race"
 
 external done: promise<'a> => unit = "%ignore"
 
+external ignoreValue: promise<'a> => promise<unit> = "%identity"
+
 external unsafe_async: 'a => promise<'a> = "%identity"
 external unsafe_await: promise<'a> => 'a = "?await"