envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/HandlerRegister.res.mjs

@@ -0,0 +1,299 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Logging from "./Logging.res.mjs";
+import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var eventRegistrations = {};
+
+function getKey(contractName, eventName) {
+  return contractName + "." + eventName;
+}
+
+function get(contractName, eventName) {
+  var existing = eventRegistrations[getKey(contractName, eventName)];
+  if (existing !== undefined) {
+    return existing;
+  } else {
+    return {
+            handler: undefined,
+            contractRegister: undefined,
+            eventOptions: undefined
+          };
+  }
+}
+
+function set(contractName, eventName, registration) {
+  eventRegistrations[getKey(contractName, eventName)] = registration;
+}
+
+var activeRegistration = {
+  contents: undefined
+};
+
+var preRegistered = [];
+
+function withRegistration(fn) {
+  var r = activeRegistration.contents;
+  if (r !== undefined) {
+    if (r.finished) {
+      return Js_exn.raiseError("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
+    } else {
+      return fn(r);
+    }
+  } else {
+    preRegistered.push(fn);
+    return ;
+  }
+}
+
+function startRegistration(ecosystem, multichain) {
+  var r = {
+    ecosystem: ecosystem,
+    multichain: multichain,
+    registrations: {
+      onBlockByChainId: {}
+    },
+    finished: false
+  };
+  activeRegistration.contents = r;
+  while(preRegistered.length > 0) {
+    var fn = preRegistered.pop();
+    if (fn !== undefined) {
+      fn(r);
+    }
+    
+  };
+}
+
+function finishRegistration() {
+  var r = activeRegistration.contents;
+  if (r !== undefined) {
+    r.finished = true;
+    return r.registrations;
+  } else {
+    return Js_exn.raiseError("The indexer has not started registering handlers, so can't finish it.");
+  }
+}
+
+function isPendingRegistration() {
+  var r = activeRegistration.contents;
+  if (r !== undefined) {
+    return !r.finished;
+  } else {
+    return false;
+  }
+}
+
+var onBlockOptionsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              name: s.m(S$RescriptSchema.string),
+              chain: s.m(S$RescriptSchema.$$int),
+              interval: s.m(S$RescriptSchema.$$Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.$$int, 1, undefined)), 1)),
+              startBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
+            };
+    });
+
+function onBlock(rawOptions, handler) {
+  withRegistration(function (registration) {
+        var match = registration.multichain;
+        if (match === "ordered") {
+          Js_exn.raiseError("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.");
+        }
+        var options = S$RescriptSchema.parseOrThrow(rawOptions, onBlockOptionsSchema);
+        var chainId = options.chain;
+        var onBlockByChainId = registration.registrations.onBlockByChainId;
+        var onBlockConfigs = onBlockByChainId[String(chainId)];
+        if (onBlockConfigs !== undefined) {
+          onBlockConfigs.push({
+                index: onBlockConfigs.length,
+                name: options.name,
+                chainId: chainId,
+                startBlock: options.startBlock,
+                endBlock: options.endBlock,
+                interval: options.interval,
+                handler: handler
+              });
+        } else {
+          onBlockByChainId[chainId] = [{
+              index: 0,
+              name: options.name,
+              chainId: chainId,
+              startBlock: options.startBlock,
+              endBlock: options.endBlock,
+              interval: options.interval,
+              handler: handler
+            }];
+        }
+      });
+}
+
+function getHandler(contractName, eventName) {
+  return get(contractName, eventName).handler;
+}
+
+function getContractRegister(contractName, eventName) {
+  return get(contractName, eventName).contractRegister;
+}
+
+function getEventFilters(contractName, eventName) {
+  return Belt_Option.flatMap(get(contractName, eventName).eventOptions, (function (value) {
+                return value.eventFilters;
+              }));
+}
+
+function isWildcard(contractName, eventName) {
+  return Belt_Option.getWithDefault(Belt_Option.flatMap(get(contractName, eventName).eventOptions, (function (value) {
+                    return value.wildcard;
+                  })), false);
+}
+
+function hasRegistration(contractName, eventName) {
+  var r = get(contractName, eventName);
+  if (Belt_Option.isSome(r.handler)) {
+    return true;
+  } else {
+    return Belt_Option.isSome(r.contractRegister);
+  }
+}
+
+function raiseDuplicateRegistration(contractName, eventName, msg, logger) {
+  var fullMsg = msg + " for " + contractName + "." + eventName;
+  Logging.childError(Logging.createChildFrom(logger, {
+            contractName: contractName,
+            eventName: eventName
+          }), fullMsg);
+  return Js_exn.raiseError(fullMsg);
+}
+
+function eventOptionsMatch(existing, incoming) {
+  if (existing !== undefined) {
+    if (incoming !== undefined && existing.wildcard === incoming.wildcard) {
+      var a = existing.eventFilters;
+      var b = incoming.eventFilters;
+      if (a !== undefined) {
+        if (a.TAG === "Static") {
+          if (b !== undefined && b.TAG === "Static") {
+            return Caml_obj.equal(a._0, b._0);
+          } else {
+            return false;
+          }
+        } else if (b !== undefined && b.TAG !== "Static") {
+          return a._0 === b._0;
+        } else {
+          return false;
+        }
+      } else {
+        return b === undefined;
+      }
+    } else {
+      return false;
+    }
+  } else {
+    return incoming === undefined;
+  }
+}
+
+function setEventOptions(contractName, eventName, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  if (eventOptions === undefined) {
+    return ;
+  }
+  var t = get(contractName, eventName);
+  var existingValue = t.eventOptions;
+  if (existingValue !== undefined) {
+    if (!eventOptionsMatch(existingValue, eventOptions)) {
+      return raiseDuplicateRegistration(contractName, eventName, "Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)", logger);
+    } else {
+      return ;
+    }
+  } else {
+    return set(contractName, eventName, {
+                handler: t.handler,
+                contractRegister: t.contractRegister,
+                eventOptions: eventOptions
+              });
+  }
+}
+
+function setHandler(contractName, eventName, handler, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  withRegistration(function (_registration) {
+        var t = get(contractName, eventName);
+        var prevHandler = t.handler;
+        if (prevHandler !== undefined) {
+          var incomingEventOptions = Belt_Option.map(eventOptions, (function (v) {
+                  return v;
+                }));
+          if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
+            return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)", logger);
+          }
+          var composedHandler = async function (args) {
+            await prevHandler(args);
+            return await handler(args);
+          };
+          return set(contractName, eventName, {
+                      handler: composedHandler,
+                      contractRegister: t.contractRegister,
+                      eventOptions: t.eventOptions
+                    });
+        }
+        setEventOptions(contractName, eventName, eventOptions, logger);
+        var t$1 = get(contractName, eventName);
+        set(contractName, eventName, {
+              handler: handler,
+              contractRegister: t$1.contractRegister,
+              eventOptions: t$1.eventOptions
+            });
+      });
+}
+
+function setContractRegister(contractName, eventName, contractRegister, eventOptions, loggerOpt) {
+  var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
+  withRegistration(function (_registration) {
+        var t = get(contractName, eventName);
+        var prevContractRegister = t.contractRegister;
+        if (prevContractRegister !== undefined) {
+          var incomingEventOptions = Belt_Option.map(eventOptions, (function (v) {
+                  return v;
+                }));
+          if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
+            return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)", logger);
+          }
+          var composedContractRegister = async function (args) {
+            await prevContractRegister(args);
+            return await contractRegister(args);
+          };
+          return set(contractName, eventName, {
+                      handler: t.handler,
+                      contractRegister: composedContractRegister,
+                      eventOptions: t.eventOptions
+                    });
+        }
+        setEventOptions(contractName, eventName, eventOptions, logger);
+        var t$1 = get(contractName, eventName);
+        set(contractName, eventName, {
+              handler: t$1.handler,
+              contractRegister: contractRegister,
+              eventOptions: t$1.eventOptions
+            });
+      });
+}
+
+export {
+  startRegistration ,
+  isPendingRegistration ,
+  finishRegistration ,
+  setHandler ,
+  setContractRegister ,
+  getHandler ,
+  getContractRegister ,
+  getEventFilters ,
+  isWildcard ,
+  hasRegistration ,
+  onBlock ,
+}
+/* onBlockOptionsSchema Not a pure module */

package/src/{EventRegister.resi → HandlerRegister.resi}

@@ -1,30 +1,30 @@
-type registrations = {
-  onBlockByChainId: dict<array<Internal.onBlockConfig>>,
-  mutable hasEvents: bool,
-}
+type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
 
 let startRegistration: (~ecosystem: Ecosystem.t, ~multichain: Config.multichain) => unit
 let isPendingRegistration: unit => bool
 let finishRegistration: unit => registrations
 
-type t
-let make: (~contractName: string, ~eventName: string) => t
 let setHandler: (
-  t,
+  ~contractName: string,
+  ~eventName: string,
   Internal.genericHandler<Internal.genericHandlerArgs<'event, Internal.handlerContext>>,
   ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
   ~logger: Pino.t=?,
 ) => unit
 let setContractRegister: (
-  t,
+  ~contractName: string,
+  ~eventName: string,
   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
+let getHandler: (~contractName: string, ~eventName: string) => option<Internal.handler>
+let getContractRegister: (
+  ~contractName: string,
+  ~eventName: string,
+) => option<Internal.contractRegister>
+let getEventFilters: (~contractName: string, ~eventName: string) => option<Js.Json.t>
+let isWildcard: (~contractName: string, ~eventName: string) => bool
+let hasRegistration: (~contractName: string, ~eventName: string) => bool
 
 let onBlock: (unknown, Internal.onBlockArgs => promise<unit>) => unit