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

package/src/GlobalStateManager.res

@@ -0,0 +1,68 @@
+open Belt
+module type State = {
+  type t
+  type action
+  type task
+
+  let taskReducer: (t, task, ~dispatchAction: action => unit) => promise<unit>
+  let actionReducer: (t, action) => (t, array<task>)
+  let invalidatedActionReducer: (t, action) => (t, array<task>)
+  let getId: t => int
+}
+
+module MakeManager = (S: State) => {
+  type t = {mutable state: S.t, onError: exn => unit}
+
+  let make = (
+    state: S.t,
+    ~onError=e => {
+      e->ErrorHandling.make(~msg="Indexer has failed with an unexpected error")->ErrorHandling.log
+      NodeJs.process->NodeJs.exitWithCode(Failure)
+    },
+  ) => {
+    state,
+    onError,
+  }
+
+  let rec dispatchAction = (~stateId=0, self: t, action: S.action) => {
+    try {
+      let reducer = if stateId == self.state->S.getId {
+        S.actionReducer
+      } else {
+        S.invalidatedActionReducer
+      }
+      let (nextState, nextTasks) = reducer(self.state, action)
+      self.state = nextState
+      nextTasks->Array.forEach(task => dispatchTask(self, task))
+    } catch {
+    | e => e->self.onError
+    }
+  }
+  and dispatchTask = (self, task: S.task) => {
+    let stateId = self.state->S.getId
+    Js.Global.setTimeout(() => {
+      if stateId !== self.state->S.getId {
+        Logging.info("Invalidated task discarded")
+      } else {
+        try {
+          S.taskReducer(self.state, task, ~dispatchAction=action =>
+            dispatchAction(~stateId, self, action)
+          )
+          ->Promise.catch(e => {
+            e->self.onError
+            Promise.resolve()
+          })
+          ->ignore
+        } catch {
+        | e => e->self.onError
+        }
+      }
+    }, 0)->ignore
+  }
+
+  let getState = self => self.state
+  let setState = (self: t, state: S.t) => self.state = state
+}
+
+module Manager = MakeManager(GlobalState)
+include Manager

package/src/GlobalStateManager.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logging from "./Logging.res.mjs";
+import * as $$Promise from "./bindings/Promise.res.mjs";
+import * as Process from "process";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as GlobalState from "./GlobalState.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+
+function make(state, onErrorOpt) {
+  var onError = onErrorOpt !== undefined ? onErrorOpt : (function (e) {
+        ErrorHandling.log(ErrorHandling.make(e, undefined, "Indexer has failed with an unexpected error"));
+        Process.exit(1);
+      });
+  return {
+          state: state,
+          onError: onError
+        };
+}
+
+function dispatchAction(stateIdOpt, self, action) {
+  var stateId = stateIdOpt !== undefined ? stateIdOpt : 0;
+  try {
+    var reducer = stateId === GlobalState.getId(self.state) ? GlobalState.actionReducer : GlobalState.invalidatedActionReducer;
+    var match = reducer(self.state, action);
+    self.state = match[0];
+    return Belt_Array.forEach(match[1], (function (task) {
+                  dispatchTask(self, task);
+                }));
+  }
+  catch (raw_e){
+    var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+    return self.onError(e);
+  }
+}
+
+function dispatchTask(self, task) {
+  var stateId = GlobalState.getId(self.state);
+  setTimeout((function () {
+          if (stateId !== GlobalState.getId(self.state)) {
+            return Logging.info("Invalidated task discarded");
+          }
+          try {
+            $$Promise.$$catch(GlobalState.taskReducer(self.state, task, (function (action) {
+                        dispatchAction(stateId, self, action);
+                      })), (function (e) {
+                    self.onError(e);
+                    return Promise.resolve();
+                  }));
+            return ;
+          }
+          catch (raw_e){
+            var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+            return self.onError(e);
+          }
+        }), 0);
+}
+
+function getState(self) {
+  return self.state;
+}
+
+function setState(self, state) {
+  self.state = state;
+}
+
+export {
+  make ,
+  dispatchAction ,
+  dispatchTask ,
+  getState ,
+  setState ,
+}
+/* Logging Not a pure module */

package/src/GlobalStateManager.resi

@@ -0,0 +1,7 @@
+type t
+
+let make: (GlobalState.t, ~onError: exn => unit=?) => t
+let dispatchAction: (~stateId: int=?, t, GlobalState.action) => unit
+let dispatchTask: (t, GlobalState.task) => unit
+let getState: t => GlobalState.t
+let setState: (t, GlobalState.t) => unit

package/src/HandlerLoader.res

@@ -0,0 +1,89 @@
+@module("node:fs/promises")
+external globIterator: string => Utils.asyncIterator<string> = "glob"
+
+// Register tsx for TypeScript handler support
+// Wrapped in try-catch because if tsx is already loaded via --import (e.g., in tests),
+// calling module.register again will throw an error
+try {
+  NodeJs.Module.register("tsx/esm", NodeJs.ImportMeta.url)
+} catch {
+| _ => () // tsx already loaded, ignore
+}
+
+// Convert a relative path to a file:// URL for dynamic import
+// Paths are resolved relative to process.cwd() (project root)
+let toImportUrl = (relativePath: string) => {
+  let absolutePath = NodeJs.Path.resolve([NodeJs.Process.cwd(), relativePath])->NodeJs.Path.toString
+  NodeJs.Url.pathToFileURL(absolutePath)->NodeJs.Url.toString
+}
+
+let registerContractHandlers = async (~contractName, ~handler: option<string>) => {
+  switch handler {
+  | None => ()
+  | Some(handlerPath) =>
+    try {
+      let _ = await Utils.importPath(toImportUrl(handlerPath))
+    } catch {
+    | exn =>
+      Logging.errorWithExn(
+        exn,
+        `Failed to load handler file for contract ${contractName}: ${handlerPath}`,
+      )
+      Js.Exn.raiseError(`Failed to load handler file for contract ${contractName}: ${handlerPath}`)
+    }
+  }
+}
+
+let autoLoadFromSrcHandlers = async (~handlers: string) => {
+  // Relative to cwd (project root)
+  let srcPattern = `./${handlers}/**/*.{js,mjs,ts}`
+  let handlerFiles = try {
+    let iterator = globIterator(srcPattern)
+    let files = await iterator->Utils.Array.fromAsyncIterator
+    // Filter out test and spec files
+    files->Js.Array2.filter(file => {
+      !(
+        file->Js.String2.includes(".test.") ||
+        file->Js.String2.includes(".spec.") ||
+        file->Js.String2.includes("_test.")
+      )
+    })
+  } catch {
+  | exn =>
+    Js.Exn.raiseError(
+      `Failed to glob src/handlers directory for auto-loading handlers. Pattern: ${srcPattern}. Before continuing, check that you're using Node.js >=22 version. Error: ${exn
+        ->Utils.prettifyExn
+        ->Obj.magic}`,
+    )
+  }
+
+  // Import handler files using absolute file:// URLs resolved from cwd
+  let _ =
+    await handlerFiles
+    ->Js.Array2.map(file => {
+      Utils.importPath(toImportUrl(file))->Promise.catch(exn => {
+        Logging.errorWithExn(exn, `Failed to auto-load handler file: ${file}`)
+        Js.Exn.raiseError(`Failed to auto-load handler file: ${file}`)
+      })
+    })
+    ->Promise.all
+}
+
+// Register all handlers - must be called BEFORE creating the final config
+// so that event registrations are captured in the config
+let registerAllHandlers = async (~config: Config.t) => {
+  HandlerRegister.startRegistration(~ecosystem=config.ecosystem, ~multichain=config.multichain)
+
+  // Auto-load all .js files from src/handlers directory
+  await autoLoadFromSrcHandlers(~handlers=config.handlers)
+
+  // Load contract-specific handlers
+  let _ =
+    await config.contractHandlers
+    ->Js.Array2.map(({name, handler}) => {
+      registerContractHandlers(~contractName=name, ~handler)
+    })
+    ->Promise.all
+
+  HandlerRegister.finishRegistration()
+}

package/src/HandlerLoader.res.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Url from "url";
+import * as Path from "path";
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Logging from "./Logging.res.mjs";
+import * as $$Promise from "./bindings/Promise.res.mjs";
+import * as Process from "process";
+import * as Nodemodule from "node:module";
+import * as HandlerRegister from "./HandlerRegister.res.mjs";
+import * as Promises from "node:fs/promises";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+
+try {
+  Nodemodule.register("tsx/esm", import.meta.url);
+}
+catch (exn){
+  
+}
+
+function toImportUrl(relativePath) {
+  var absolutePath = Path.resolve(Process.cwd(), relativePath);
+  return Url.pathToFileURL(absolutePath).toString();
+}
+
+async function registerContractHandlers(contractName, handler) {
+  if (handler === undefined) {
+    return ;
+  }
+  try {
+    await import(toImportUrl(handler));
+    return ;
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    Logging.errorWithExn(exn, "Failed to load handler file for contract " + contractName + ": " + handler);
+    return Js_exn.raiseError("Failed to load handler file for contract " + contractName + ": " + handler);
+  }
+}
+
+async function autoLoadFromSrcHandlers(handlers) {
+  var srcPattern = "./" + handlers + "/**/*.{js,mjs,ts}";
+  var handlerFiles;
+  try {
+    var iterator = Promises.glob(srcPattern);
+    var files = await Utils.$$Array.fromAsyncIterator(iterator);
+    handlerFiles = files.filter(function (file) {
+          return !(file.includes(".test.") || file.includes(".spec.") || file.includes("_test."));
+        });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    handlerFiles = Js_exn.raiseError("Failed to glob src/handlers directory for auto-loading handlers. Pattern: " + srcPattern + ". Before continuing, check that you're using Node.js >=22 version. Error: " + Utils.prettifyExn(exn));
+  }
+  await Promise.all(handlerFiles.map(function (file) {
+            return $$Promise.$$catch(import(toImportUrl(file)), (function (exn) {
+                          Logging.errorWithExn(exn, "Failed to auto-load handler file: " + file);
+                          return Js_exn.raiseError("Failed to auto-load handler file: " + file);
+                        }));
+          }));
+}
+
+async function registerAllHandlers(config) {
+  HandlerRegister.startRegistration(config.ecosystem, config.multichain);
+  await autoLoadFromSrcHandlers(config.handlers);
+  await Promise.all(config.contractHandlers.map(function (param) {
+            return registerContractHandlers(param.name, param.handler);
+          }));
+  return HandlerRegister.finishRegistration();
+}
+
+export {
+  toImportUrl ,
+  registerContractHandlers ,
+  autoLoadFromSrcHandlers ,
+  registerAllHandlers ,
+}
+/*  Not a pure module */

package/src/HandlerRegister.res

@@ -0,0 +1,357 @@
+type eventRegistration = {
+  handler: option<Internal.handler>,
+  contractRegister: option<Internal.contractRegister>,
+  eventOptions: option<Internal.eventOptions<Internal.eventFilters>>,
+}
+
+let empty = {
+  handler: None,
+  contractRegister: None,
+  eventOptions: None,
+}
+
+let eventRegistrations: Js.Dict.t<eventRegistration> = Js.Dict.empty()
+
+let getKey = (~contractName, ~eventName) => contractName ++ "." ++ eventName
+
+let get = (~contractName, ~eventName) => {
+  switch eventRegistrations->Utils.Dict.dangerouslyGetNonOption(getKey(~contractName, ~eventName)) {
+  | Some(existing) => existing
+  | None => empty
+  }
+}
+
+let set = (~contractName, ~eventName, registration) => {
+  eventRegistrations->Js.Dict.set(getKey(~contractName, ~eventName), registration)
+}
+
+type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+
+type activeRegistration = {
+  ecosystem: Ecosystem.t,
+  multichain: Config.multichain,
+  registrations: registrations,
+  mutable finished: bool,
+}
+
+let activeRegistration = ref(None)
+
+// Might happen for tests when the handler file
+// is imported by a non-envio process (eg mocha)
+// and initialized before we started registration.
+// So we track them here to register when the startRegistration is called.
+// Theoretically we could keep preRegistration without an explicit start
+// but I want it to be this way, so for the actual indexer run
+// an error is thrown with the exact stack trace where the handler was registered.
+let preRegistered = []
+
+let withRegistration = (fn: activeRegistration => unit) => {
+  switch activeRegistration.contents {
+  | None => preRegistered->Belt.Array.push(fn)
+  | Some(r) =>
+    if r.finished {
+      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 {
+      fn(r)
+    }
+  }
+}
+
+let startRegistration = (~ecosystem, ~multichain) => {
+  let r = {
+    ecosystem,
+    multichain,
+    registrations: {
+      onBlockByChainId: Js.Dict.empty(),
+    },
+    finished: false,
+  }
+  activeRegistration.contents = Some(r)
+  while preRegistered->Js.Array2.length > 0 {
+    // Loop + cleanup in one go
+    switch preRegistered->Js.Array2.pop {
+    | Some(fn) => fn(r)
+    | None => ()
+    }
+  }
+}
+
+let finishRegistration = () => {
+  switch activeRegistration.contents {
+  | Some(r) => {
+      r.finished = true
+      r.registrations
+    }
+  | None =>
+    Js.Exn.raiseError("The indexer has not started registering handlers, so can't finish it.")
+  }
+}
+
+let isPendingRegistration = () => {
+  switch activeRegistration.contents {
+  | Some(r) => !r.finished
+  | None => false
+  }
+}
+
+let onBlockOptionsSchema = S.schema(s =>
+  {
+    "name": s.matches(S.string),
+    "chain": s.matches(S.int),
+    "interval": s.matches(S.option(S.int->S.intMin(1))->S.Option.getOr(1)),
+    "startBlock": s.matches(S.option(S.int)),
+    "endBlock": s.matches(S.option(S.int)),
+  }
+)
+
+let onBlock = (rawOptions: unknown, handler: Internal.onBlockArgs => promise<unit>) => {
+  withRegistration(registration => {
+    // We need to get timestamp for ordered multichain mode
+    switch registration.multichain {
+    | Unordered => ()
+    | 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.",
+      )
+    }
+
+    let options = rawOptions->S.parseOrThrow(onBlockOptionsSchema)
+    let chainId = switch options["chain"] {
+    | chainId => chainId
+    // Dmitry: I want to add names for chains in the future
+    // and to be able to use them as a lookup.
+    // To do so, we'll need to pass a config during reigstration
+    // instead of isInitialized check.
+    }
+
+    let onBlockByChainId = registration.registrations.onBlockByChainId
+
+    switch onBlockByChainId->Utils.Dict.dangerouslyGetNonOption(chainId->Belt.Int.toString) {
+    | None =>
+      onBlockByChainId->Utils.Dict.setByInt(
+        chainId,
+        [
+          (
+            {
+              index: 0,
+              name: options["name"],
+              startBlock: options["startBlock"],
+              endBlock: options["endBlock"],
+              interval: options["interval"],
+              chainId,
+              handler,
+            }: Internal.onBlockConfig
+          ),
+        ],
+      )
+    | Some(onBlockConfigs) =>
+      onBlockConfigs->Belt.Array.push(
+        (
+          {
+            index: onBlockConfigs->Belt.Array.length,
+            name: options["name"],
+            startBlock: options["startBlock"],
+            endBlock: options["endBlock"],
+            interval: options["interval"],
+            chainId,
+            handler,
+          }: Internal.onBlockConfig
+        ),
+      )
+    }
+  })
+}
+
+let getHandler = (~contractName, ~eventName) => get(~contractName, ~eventName).handler
+
+let getContractRegister = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).contractRegister
+
+let getEventFilters = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).eventOptions
+  ->Belt.Option.flatMap(value => value.eventFilters)
+  ->(Utils.magic: option<Internal.eventFilters> => option<Js.Json.t>)
+
+let isWildcard = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).eventOptions
+  ->Belt.Option.flatMap(value => value.wildcard)
+  ->Belt.Option.getWithDefault(false)
+
+let hasRegistration = (~contractName, ~eventName) => {
+  let r = get(~contractName, ~eventName)
+  r.handler->Belt.Option.isSome || r.contractRegister->Belt.Option.isSome
+}
+
+type eventNamespace = {contractName: string, eventName: string}
+
+let raiseDuplicateRegistration = (~contractName, ~eventName, ~msg, ~logger) => {
+  let fullMsg = msg ++ " for " ++ contractName ++ "." ++ eventName
+  Logging.createChildFrom(~logger, ~params={contractName, eventName})->Logging.childError(fullMsg)
+  Js.Exn.raiseError(fullMsg)
+}
+
+let eventFiltersMatch = (a: option<Internal.eventFilters>, b: option<Internal.eventFilters>) => {
+  switch (a, b) {
+  | (None, None) => true
+  | (Some(Static(a)), Some(Static(b))) => a == b
+  | (Some(Dynamic(a)), Some(Dynamic(b))) => a === b
+  | _ => false
+  }
+}
+
+let eventOptionsMatch = (
+  existing: option<Internal.eventOptions<Internal.eventFilters>>,
+  incoming: option<Internal.eventOptions<Internal.eventFilters>>,
+) => {
+  switch (existing, incoming) {
+  | (None, None) => true
+  | (Some(a), Some(b)) =>
+    a.wildcard === b.wildcard && eventFiltersMatch(a.eventFilters, b.eventFilters)
+  | _ => false
+  }
+}
+
+let setEventOptions = (~contractName, ~eventName, ~eventOptions, ~logger=Logging.getLogger()) => {
+  switch eventOptions {
+  | Some(value) =>
+    let value =
+      value->(
+        Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<
+          Internal.eventFilters,
+        >
+      )
+    let t = get(~contractName, ~eventName)
+    switch t.eventOptions {
+    | None => set(~contractName, ~eventName, {...t, eventOptions: Some(value)})
+    | Some(existingValue) =>
+      if !eventOptionsMatch(Some(existingValue), Some(value)) {
+        raiseDuplicateRegistration(
+          ~contractName,
+          ~eventName,
+          ~msg="Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)",
+          ~logger,
+        )
+      }
+    }
+  | None => ()
+  }
+}
+
+let setHandler = (
+  ~contractName,
+  ~eventName,
+  handler,
+  ~eventOptions,
+  ~logger=Logging.getLogger(),
+) => {
+  withRegistration(_registration => {
+    let t = get(~contractName, ~eventName)
+    let newHandler = handler->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
+    switch t.handler {
+    | None =>
+      setEventOptions(~contractName, ~eventName, ~eventOptions, ~logger)
+      let t = get(~contractName, ~eventName)
+      set(
+        ~contractName,
+        ~eventName,
+        {
+          ...t,
+          handler: Some(newHandler),
+        },
+      )
+    | Some(prevHandler) =>
+      let incomingEventOptions =
+        eventOptions->Belt.Option.map(v =>
+          v->(
+            Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<
+              Internal.eventFilters,
+            >
+          )
+        )
+      if eventOptionsMatch(t.eventOptions, incomingEventOptions) {
+        let composedHandler: Internal.handler = async args => {
+          await prevHandler(args)
+          await newHandler(args)
+        }
+        set(
+          ~contractName,
+          ~eventName,
+          {
+            ...t,
+            handler: Some(composedHandler),
+          },
+        )
+      } else {
+        raiseDuplicateRegistration(
+          ~contractName,
+          ~eventName,
+          ~msg="Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)",
+          ~logger,
+        )
+      }
+    }
+  })
+}
+
+let setContractRegister = (
+  ~contractName,
+  ~eventName,
+  contractRegister,
+  ~eventOptions,
+  ~logger=Logging.getLogger(),
+) => {
+  withRegistration(_registration => {
+    let t = get(~contractName, ~eventName)
+    let newContractRegister =
+      contractRegister->(
+        Utils.magic: Internal.genericContractRegister<
+          Internal.genericContractRegisterArgs<'event, 'context>,
+        > => Internal.contractRegister
+      )
+    switch t.contractRegister {
+    | None =>
+      setEventOptions(~contractName, ~eventName, ~eventOptions, ~logger)
+      let t = get(~contractName, ~eventName)
+      set(
+        ~contractName,
+        ~eventName,
+        {
+          ...t,
+          contractRegister: Some(newContractRegister),
+        },
+      )
+    | Some(prevContractRegister) =>
+      let incomingEventOptions =
+        eventOptions->Belt.Option.map(v =>
+          v->(
+            Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<
+              Internal.eventFilters,
+            >
+          )
+        )
+      if eventOptionsMatch(t.eventOptions, incomingEventOptions) {
+        let composedContractRegister: Internal.contractRegister = async args => {
+          await prevContractRegister(args)
+          await newContractRegister(args)
+        }
+        set(
+          ~contractName,
+          ~eventName,
+          {
+            ...t,
+            contractRegister: Some(composedContractRegister),
+          },
+        )
+      } else {
+        raiseDuplicateRegistration(
+          ~contractName,
+          ~eventName,
+          ~msg="Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, eventFilters)",
+          ~logger,
+        )
+      }
+    }
+  })
+}