envio 2.22.0 → 2.22.2

package/src/LogSelection.res.js

@@ -0,0 +1,203 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Utils = require("./Utils.res.js");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+
+var MissingRequiredTopic0 = /* @__PURE__ */Caml_exceptions.create("LogSelection.MissingRequiredTopic0");
+
+function makeTopicSelection(topic0, topic1Opt, topic2Opt, topic3Opt) {
+  var topic1 = topic1Opt !== undefined ? topic1Opt : [];
+  var topic2 = topic2Opt !== undefined ? topic2Opt : [];
+  var topic3 = topic3Opt !== undefined ? topic3Opt : [];
+  if (Utils.$$Array.isEmpty(topic0)) {
+    return {
+            TAG: "Error",
+            _0: {
+              RE_EXN_ID: MissingRequiredTopic0
+            }
+          };
+  } else {
+    return {
+            TAG: "Ok",
+            _0: {
+              topic0: topic0,
+              topic1: topic1,
+              topic2: topic2,
+              topic3: topic3
+            }
+          };
+  }
+}
+
+function hasFilters(param) {
+  return Belt_Option.isSome(Caml_option.undefined_to_opt([
+                    param.topic1,
+                    param.topic2,
+                    param.topic3
+                  ].find(function (topic) {
+                      return !Utils.$$Array.isEmpty(topic);
+                    })));
+}
+
+function compressTopicSelections(topicSelections) {
+  var topic0sOfSelectionsWithoutFilters = [];
+  var selectionsWithFilters = [];
+  Belt_Array.forEach(topicSelections, (function (selection) {
+          if (hasFilters(selection)) {
+            selectionsWithFilters.push(selection);
+            return ;
+          } else {
+            return Belt_Array.forEach(selection.topic0, (function (topic0) {
+                          topic0sOfSelectionsWithoutFilters.push(topic0);
+                        }));
+          }
+        }));
+  if (topic0sOfSelectionsWithoutFilters.length === 0) {
+    return selectionsWithFilters;
+  }
+  var selectionWithoutFilters_topic1 = [];
+  var selectionWithoutFilters_topic2 = [];
+  var selectionWithoutFilters_topic3 = [];
+  var selectionWithoutFilters = {
+    topic0: topic0sOfSelectionsWithoutFilters,
+    topic1: selectionWithoutFilters_topic1,
+    topic2: selectionWithoutFilters_topic2,
+    topic3: selectionWithoutFilters_topic3
+  };
+  return Belt_Array.concat([selectionWithoutFilters], selectionsWithFilters);
+}
+
+function make(addresses, topicSelections) {
+  var topicSelections$1 = compressTopicSelections(topicSelections);
+  return {
+          addresses: addresses,
+          topicSelections: topicSelections$1
+        };
+}
+
+var emptyTopics = [];
+
+function noopGetter(param) {
+  return emptyTopics;
+}
+
+function parseEventFiltersOrThrow(eventFilters, sighash, params, topic1Opt, topic2Opt, topic3Opt) {
+  var topic1 = topic1Opt !== undefined ? topic1Opt : noopGetter;
+  var topic2 = topic2Opt !== undefined ? topic2Opt : noopGetter;
+  var topic3 = topic3Opt !== undefined ? topic3Opt : noopGetter;
+  var filterByAddresses = {
+    contents: false
+  };
+  var topic0 = [sighash];
+  var $$default = {
+    topic0: topic0,
+    topic1: emptyTopics,
+    topic2: emptyTopics,
+    topic3: emptyTopics
+  };
+  var parse = function (eventFilters) {
+    var tmp;
+    tmp = !Array.isArray(eventFilters) && (eventFilters === null || typeof eventFilters !== "object") && typeof eventFilters !== "number" && typeof eventFilters !== "string" && typeof eventFilters !== "boolean" ? [eventFilters] : (
+        Array.isArray(eventFilters) ? (
+            eventFilters.length !== 0 ? eventFilters : [{}]
+          ) : [eventFilters]
+      );
+    return tmp.map(function (eventFilter) {
+                if (!Array.isArray(eventFilter) && (eventFilter === null || typeof eventFilter !== "object") && typeof eventFilter !== "number" && typeof eventFilter !== "string" && typeof eventFilter !== "boolean") {
+                  return Js_exn.raiseError("Invalid event filters configuration. Expected an object");
+                }
+                if (!(typeof eventFilter === "object" && !Array.isArray(eventFilter))) {
+                  return Js_exn.raiseError("Invalid event filters configuration. Expected an object");
+                }
+                var filterKeys = Object.keys(eventFilter);
+                if (filterKeys.length !== 0) {
+                  filterKeys.forEach(function (key) {
+                        if (!params.includes(key)) {
+                          return Js_exn.raiseError("Invalid event filters configuration. The event doesn't have an indexed parameter \"" + key + "\" and can't use it for filtering");
+                        }
+                        
+                      });
+                  return {
+                          topic0: topic0,
+                          topic1: topic1(eventFilter),
+                          topic2: topic2(eventFilter),
+                          topic3: topic3(eventFilter)
+                        };
+                } else {
+                  return $$default;
+                }
+              });
+  };
+  var getEventFiltersOrThrow;
+  if (eventFilters !== undefined) {
+    if (typeof eventFilters === "function") {
+      try {
+        var args = Object.defineProperty({
+              chainId: 0,
+              addresses: []
+            }, "addresses", {
+              get: (function () {
+                  filterByAddresses.contents = true;
+                  return [];
+                })
+            });
+        eventFilters(args);
+      }
+      catch (exn){
+        
+      }
+      getEventFiltersOrThrow = filterByAddresses.contents ? (function (chain) {
+            return {
+                    TAG: "Dynamic",
+                    _0: (function (addresses) {
+                        return parse(eventFilters({
+                                        chainId: chain,
+                                        addresses: addresses
+                                      }));
+                      })
+                  };
+          }) : (function (chain) {
+            return {
+                    TAG: "Static",
+                    _0: parse(eventFilters({
+                              chainId: chain,
+                              addresses: []
+                            }))
+                  };
+          });
+    } else {
+      var $$static = {
+        TAG: "Static",
+        _0: parse(eventFilters)
+      };
+      getEventFiltersOrThrow = (function (param) {
+          return $$static;
+        });
+    }
+  } else {
+    var $$static$1 = {
+      TAG: "Static",
+      _0: [$$default]
+    };
+    getEventFiltersOrThrow = (function (param) {
+        return $$static$1;
+      });
+  }
+  return {
+          getEventFiltersOrThrow: getEventFiltersOrThrow,
+          filterByAddresses: filterByAddresses.contents
+        };
+}
+
+exports.MissingRequiredTopic0 = MissingRequiredTopic0;
+exports.makeTopicSelection = makeTopicSelection;
+exports.hasFilters = hasFilters;
+exports.compressTopicSelections = compressTopicSelections;
+exports.make = make;
+exports.parseEventFiltersOrThrow = parseEventFiltersOrThrow;
+/* Utils Not a pure module */

package/src/Logging.res.js

@@ -0,0 +1,247 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Pino = require("./bindings/Pino.res.js");
+var Pino$1 = require("pino");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Internal = require("./Internal.res.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var EcsPinoFormat = require("@elastic/ecs-pino-format");
+
+var logLevels = Js_dict.fromArray([
+      [
+        "udebug",
+        32
+      ],
+      [
+        "uinfo",
+        34
+      ],
+      [
+        "uwarn",
+        36
+      ],
+      [
+        "uerror",
+        38
+      ],
+      [
+        "trace",
+        10
+      ],
+      [
+        "debug",
+        20
+      ],
+      [
+        "info",
+        30
+      ],
+      [
+        "warn",
+        40
+      ],
+      [
+        "error",
+        50
+      ],
+      [
+        "fatal",
+        60
+      ]
+    ]);
+
+var logger = {
+  contents: undefined
+};
+
+function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel) {
+  var pinoFile_target = "pino/file";
+  var pinoFile_options = Caml_option.some(Pino.Transport.makeTransportOptions({
+            destination: logFilePath,
+            append: true,
+            mkdir: true
+          }));
+  var pinoFile_level = defaultFileLogLevel;
+  var pinoFile = {
+    target: pinoFile_target,
+    options: pinoFile_options,
+    level: pinoFile_level
+  };
+  var makeMultiStreamLogger = function (none, none$1) {
+    return Pino.MultiStreamLogger.make(userLogLevel, logLevels, none, none$1, defaultFileLogLevel);
+  };
+  switch (logStrategy) {
+    case "ecs-file" :
+        var newrecord = Caml_obj.obj_dup(EcsPinoFormat());
+        return Pino$1((newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
+    case "ecs-console" :
+        var newrecord$1 = Caml_obj.obj_dup(EcsPinoFormat());
+        return Pino$1((newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
+    case "ecs-console-multistream" :
+        return makeMultiStreamLogger(undefined, EcsPinoFormat());
+    case "file-only" :
+        return Pino$1({
+                    level: defaultFileLogLevel,
+                    customLevels: logLevels
+                  }, Pino$1.transport(pinoFile));
+    case "console-raw" :
+    case "console-pretty" :
+        return makeMultiStreamLogger(undefined, undefined);
+    case "both-prettyconsole" :
+        return makeMultiStreamLogger(logFilePath, undefined);
+    
+  }
+}
+
+function setLogger(l) {
+  logger.contents = l;
+}
+
+function getLogger() {
+  var logger$1 = logger.contents;
+  if (logger$1 !== undefined) {
+    return logger$1;
+  } else {
+    return Js_exn.raiseError("Unreachable code. Logger not initialized");
+  }
+}
+
+function setLogLevel(level) {
+  getLogger().level = level;
+}
+
+function trace(message) {
+  getLogger().trace(Pino.createPinoMessage(message));
+}
+
+function debug(message) {
+  getLogger().debug(Pino.createPinoMessage(message));
+}
+
+function info(message) {
+  getLogger().info(Pino.createPinoMessage(message));
+}
+
+function warn(message) {
+  getLogger().warn(Pino.createPinoMessage(message));
+}
+
+function error(message) {
+  getLogger().error(Pino.createPinoMessage(message));
+}
+
+function errorWithExn(error, message) {
+  getLogger().error(Pino.createPinoMessageWithError(message, error));
+}
+
+function fatal(message) {
+  getLogger().fatal(Pino.createPinoMessage(message));
+}
+
+function childTrace(logger, params) {
+  logger.trace(Pino.createPinoMessage(params));
+}
+
+function childDebug(logger, params) {
+  logger.debug(Pino.createPinoMessage(params));
+}
+
+function childInfo(logger, params) {
+  logger.info(Pino.createPinoMessage(params));
+}
+
+function childWarn(logger, params) {
+  logger.warn(Pino.createPinoMessage(params));
+}
+
+function childError(logger, params) {
+  logger.error(Pino.createPinoMessage(params));
+}
+
+function childErrorWithExn(logger, error, params) {
+  logger.error(Pino.createPinoMessageWithError(params, error));
+}
+
+function childFatal(logger, params) {
+  logger.fatal(Pino.createPinoMessage(params));
+}
+
+function createChild(params) {
+  return getLogger().child(Pino.createChildParams(params));
+}
+
+function createChildFrom(logger, params) {
+  return logger.child(Pino.createChildParams(params));
+}
+
+function getEventLogger(eventItem) {
+  var l = eventItem.loggerCache;
+  if (l !== undefined) {
+    return l;
+  }
+  var l$1 = getLogger().child(Pino.createChildParams({
+            contractName: eventItem.eventConfig.contractName,
+            eventName: eventItem.eventConfig.name,
+            chainId: eventItem.chain,
+            block: eventItem.blockNumber,
+            logIndex: eventItem.logIndex
+          }));
+  eventItem.loggerCache = l$1;
+  return l$1;
+}
+
+function logForItem(eventItem, level, message, params) {
+  return getEventLogger(eventItem)[level](params, message);
+}
+
+function getUserLogger(eventItem) {
+  return {
+          debug: (function (message, params) {
+              getEventLogger(eventItem)["udebug"](params, message);
+            }),
+          info: (function (message, params) {
+              getEventLogger(eventItem)["uinfo"](params, message);
+            }),
+          warn: (function (message, params) {
+              getEventLogger(eventItem)["uwarn"](params, message);
+            }),
+          error: (function (message, params) {
+              getEventLogger(eventItem)["uerror"](params, message);
+            }),
+          errorWithExn: (function (message, exn) {
+              var params = {
+                err: Internal.prettifyExn(exn)
+              };
+              getEventLogger(eventItem)["uerror"](params, message);
+            })
+        };
+}
+
+exports.logLevels = logLevels;
+exports.makeLogger = makeLogger;
+exports.setLogger = setLogger;
+exports.getLogger = getLogger;
+exports.setLogLevel = setLogLevel;
+exports.trace = trace;
+exports.debug = debug;
+exports.info = info;
+exports.warn = warn;
+exports.error = error;
+exports.errorWithExn = errorWithExn;
+exports.fatal = fatal;
+exports.childTrace = childTrace;
+exports.childDebug = childDebug;
+exports.childInfo = childInfo;
+exports.childWarn = childWarn;
+exports.childError = childError;
+exports.childErrorWithExn = childErrorWithExn;
+exports.childFatal = childFatal;
+exports.createChild = createChild;
+exports.createChildFrom = createChildFrom;
+exports.getEventLogger = getEventLogger;
+exports.logForItem = logForItem;
+exports.getUserLogger = getUserLogger;
+/* logLevels Not a pure module */

package/src/Persistence.res.js

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var EntityHistory = require("./db/EntityHistory.res.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var entityHistoryActionEnumConfig_name = EntityHistory.RowAction.name;
+
+var entityHistoryActionEnumConfig_variants = EntityHistory.RowAction.variants;
+
+var entityHistoryActionEnumConfig_schema = EntityHistory.RowAction.schema;
+
+var entityHistoryActionEnumConfig = {
+  name: entityHistoryActionEnumConfig_name,
+  variants: entityHistoryActionEnumConfig_variants,
+  schema: entityHistoryActionEnumConfig_schema,
+  default: "SET"
+};
+
+function make(userEntities, dcRegistryEntityConfig, allEnums, staticTables, storage, onStorageInitialize) {
+  var allEntities = userEntities.concat([dcRegistryEntityConfig]);
+  var allEnums$1 = allEnums.concat([entityHistoryActionEnumConfig]);
+  return {
+          userEntities: userEntities,
+          staticTables: staticTables,
+          allEntities: allEntities,
+          allEnums: allEnums$1,
+          storageStatus: "Unknown",
+          storage: storage,
+          onStorageInitialize: onStorageInitialize
+        };
+}
+
+async function init(persistence, skipIsInitializedCheckOpt, resetOpt) {
+  var skipIsInitializedCheck = skipIsInitializedCheckOpt !== undefined ? skipIsInitializedCheckOpt : false;
+  var reset = resetOpt !== undefined ? resetOpt : false;
+  try {
+    var promise = persistence.storageStatus;
+    var shouldRun;
+    if (typeof promise !== "object") {
+      shouldRun = true;
+    } else if (promise.TAG === "Initializing") {
+      await promise._0;
+      shouldRun = reset;
+    } else {
+      shouldRun = reset;
+    }
+    if (!shouldRun) {
+      return ;
+    }
+    var resolveRef = {
+      contents: null
+    };
+    var promise$1 = new Promise((function (resolve, param) {
+            resolveRef.contents = resolve;
+          }));
+    persistence.storageStatus = {
+      TAG: "Initializing",
+      _0: promise$1
+    };
+    if (!(reset || skipIsInitializedCheck) && await persistence.storage.isInitialized()) {
+      persistence.storageStatus = {
+        TAG: "Ready",
+        cleanRun: false
+      };
+    } else {
+      await persistence.storage.initialize(persistence.allEntities, persistence.staticTables, persistence.allEnums, reset || !skipIsInitializedCheck);
+      persistence.storageStatus = {
+        TAG: "Ready",
+        cleanRun: true
+      };
+      var onStorageInitialize = persistence.onStorageInitialize;
+      if (onStorageInitialize !== undefined) {
+        await onStorageInitialize();
+      }
+      
+    }
+    return resolveRef.contents();
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return ErrorHandling.mkLogAndRaise(undefined, "EE800: Failed to initialize the indexer storage.", exn);
+  }
+}
+
+exports.entityHistoryActionEnumConfig = entityHistoryActionEnumConfig;
+exports.make = make;
+exports.init = init;
+/* EntityHistory Not a pure module */

package/src/PgStorage.res

@@ -52,7 +52,14 @@ let makeCreateTableSqlUnsafe = (table: Table.table, ~pgSchema) => {
       : ""});`
 }
 
-let makeInitializeTransaction = (~pgSchema, ~staticTables, ~entities, ~enums, ~cleanRun) => {
+let makeInitializeTransaction = (
+  ~pgSchema,
+  ~pgUser,
+  ~staticTables,
+  ~entities,
+  ~enums,
+  ~cleanRun,
+) => {
   let allTables = staticTables->Array.copy
   let allEntityTables = []
   entities->Js.Array2.forEach((entity: Internal.entityConfig) => {
@@ -69,7 +76,7 @@ let makeInitializeTransaction = (~pgSchema, ~staticTables, ~entities, ~enums, ~c
 CREATE SCHEMA "${pgSchema}";`
         : `CREATE SCHEMA IF NOT EXISTS "${pgSchema}";`
     ) ++
-    `GRANT ALL ON SCHEMA "${pgSchema}" TO postgres;
+    `GRANT ALL ON SCHEMA "${pgSchema}" TO ${pgUser};
 GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
   )
 
@@ -141,7 +148,7 @@ END IF;`
   ]->Js.Array2.concat(functionsQuery.contents !== "" ? [functionsQuery.contents] : [])
 }
 
-let make = (~sql: Postgres.sql, ~pgSchema): Persistence.storage => {
+let make = (~sql: Postgres.sql, ~pgSchema, ~pgUser): Persistence.storage => {
   let isInitialized = async () => {
     let schemas =
       await sql->Postgres.unsafe(
@@ -151,7 +158,14 @@ let make = (~sql: Postgres.sql, ~pgSchema): Persistence.storage => {
   }
 
   let initialize = async (~entities, ~staticTables, ~enums, ~cleanRun) => {
-    let queries = makeInitializeTransaction(~pgSchema, ~staticTables, ~entities, ~enums, ~cleanRun)
+    let queries = makeInitializeTransaction(
+      ~pgSchema,
+      ~pgUser,
+      ~staticTables,
+      ~entities,
+      ~enums,
+      ~cleanRun,
+    )
     // Execute all queries within a single transaction for integrity
     let _ = await sql->Postgres.beginSql(sql => {
       queries->Js.Array2.map(query => sql->Postgres.unsafe(query))