Fix handler registration for old test framework ran with vitest

codegenerator/cli/npm/envio/src/ChainFetcher.res

@@ -30,7 +30,7 @@ let make = (
   ~firstEventBlock=None,
   ~progressBlockNumber,
   ~config: Config.t,
-  ~registrations: EventRegister.registrations,
+  ~registrations: HandlerRegister.registrations,
   ~targetBufferSize,
   ~logger,
   ~timestampCaughtUpToHeadOrEndblock,
@@ -148,7 +148,7 @@ let make = (
     registrations.onBlockByChainId->Utils.Dict.dangerouslyGetNonOption(chainConfig.id->Int.toString)
   switch onBlockConfigs {
   | Some(onBlockConfigs) =>
-    // TODO: Move it to the EventRegister module
+    // TODO: Move it to the HandlerRegister module
     // so the error is thrown with better stack trace
     onBlockConfigs->Array.forEach(onBlockConfig => {
       if onBlockConfig.startBlock->Option.getWithDefault(startBlock) < startBlock {

codegenerator/cli/npm/envio/src/Ctx.res

@@ -1,5 +1,5 @@
 type t = {
-  registrations: EventRegister.registrations,
+  registrations: HandlerRegister.registrations,
   config: Config.t,
   persistence: Persistence.t,
 }

codegenerator/cli/npm/envio/src/HandlerLoader.res

@@ -72,7 +72,7 @@ let autoLoadFromSrcHandlers = async (~handlers: string) => {
 // 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) => {
-  EventRegister.startRegistration(~ecosystem=config.ecosystem, ~multichain=config.multichain)
+  HandlerRegister.startRegistration(~ecosystem=config.ecosystem, ~multichain=config.multichain)
 
   // Auto-load all .js files from src/handlers directory
   await autoLoadFromSrcHandlers(~handlers=config.handlers)
@@ -85,5 +85,5 @@ let registerAllHandlers = async (~config: Config.t) => {
     })
     ->Promise.all
 
-  EventRegister.finishRegistration()
+  HandlerRegister.finishRegistration()
 }

codegenerator/cli/npm/envio/src/EventRegister.res → codegenerator/cli/npm/envio/src/HandlerRegister.res

@@ -1,6 +1,32 @@
+type eventRegistration = {
+  handler: option<Internal.handler>,
+  contractRegister: option<Internal.contractRegister>,
+  eventOptions: option<Internal.eventOptions<Js.Json.t>>,
+}
+
+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>>,
-  mutable hasEvents: bool,
 }
 
 type activeRegistration = {
@@ -41,7 +67,6 @@ let startRegistration = (~ecosystem, ~multichain) => {
     multichain,
     registrations: {
       onBlockByChainId: Js.Dict.empty(),
-      hasEvents: false,
     },
     finished: false,
   }
@@ -141,51 +166,44 @@ let onBlock = (rawOptions: unknown, handler: Internal.onBlockArgs => promise<uni
   })
 }
 
-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 getHandler = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).handler
 
-let getEventFilters = (t: t) => t.eventOptions->Belt.Option.flatMap(value => value.eventFilters)
+let getContractRegister = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).contractRegister
 
-let isWildcard = (t: t) =>
-  t.eventOptions->Belt.Option.flatMap(value => value.wildcard)->Belt.Option.getWithDefault(false)
+let getEventFilters = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).eventOptions
+  ->Belt.Option.flatMap(value => value.eventFilters)
 
-let hasRegistration = ({handler, contractRegister}) =>
-  handler->Belt.Option.isSome || contractRegister->Belt.Option.isSome
+let isWildcard = (~contractName, ~eventName) =>
+  get(~contractName, ~eventName).eventOptions
+  ->Belt.Option.flatMap(value => value.wildcard)
+  ->Belt.Option.getWithDefault(false)
 
-let make = (~contractName, ~eventName) => {
-  contractName,
-  eventName,
-  handler: None,
-  contractRegister: None,
-  eventOptions: None,
+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}
 exception DuplicateEventRegistration(eventNamespace)
 
-let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
+let setEventOptions = (~contractName, ~eventName, ~eventOptions, ~logger=Logging.getLogger()) => {
   switch eventOptions {
   | Some(value) =>
     let value =
       value->(Utils.magic: Internal.eventOptions<'eventFilters> => Internal.eventOptions<Js.Json.t>)
+    let t = get(~contractName, ~eventName)
     switch t.eventOptions {
-    | None => t.eventOptions = Some(value)
+    | None => set(~contractName, ~eventName, {...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}
+        let eventNamespace = {contractName, eventName}
         DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
           ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
           ~msg="Duplicate eventOptions in handlers not allowed",
@@ -196,46 +214,49 @@ let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
   }
 }
 
-let setHandler = (t: t, handler, ~eventOptions, ~logger=Logging.getLogger()) => {
-  withRegistration(registration => {
-    registration.registrations.hasEvents = true
+let setHandler = (~contractName, ~eventName, handler, ~eventOptions, ~logger=Logging.getLogger()) => {
+  withRegistration(_registration => {
+    let t = get(~contractName, ~eventName)
     switch t.handler {
     | None =>
-      t.handler =
-        handler
-        ->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
-        ->Some
+      set(~contractName, ~eventName, {
+        ...t,
+        handler: handler
+          ->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
+          ->Some,
+      })
     | Some(_) =>
-      let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+      let eventNamespace = {contractName, eventName}
       DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
         ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
         ~msg="Duplicate registration of event handlers not allowed",
       )
     }
 
-    t->setEventOptions(~eventOptions, ~logger)
+    setEventOptions(~contractName, ~eventName, ~eventOptions, ~logger)
   })
 }
 
-let setContractRegister = (t: t, contractRegister, ~eventOptions, ~logger=Logging.getLogger()) => {
-  withRegistration(registration => {
-    registration.registrations.hasEvents = true
+let setContractRegister = (~contractName, ~eventName, contractRegister, ~eventOptions, ~logger=Logging.getLogger()) => {
+  withRegistration(_registration => {
+    let t = get(~contractName, ~eventName)
     switch t.contractRegister {
     | None =>
-      t.contractRegister = Some(
-        contractRegister->(
+      set(~contractName, ~eventName, {
+        ...t,
+        contractRegister: contractRegister->(
           Utils.magic: Internal.genericContractRegister<
             Internal.genericContractRegisterArgs<'event, 'context>,
           > => Internal.contractRegister
-        ),
-      )
+        )->Some,
+      })
     | Some(_) =>
-      let eventNamespace = {contractName: t.contractName, eventName: t.eventName}
+      let eventNamespace = {contractName, eventName}
       DuplicateEventRegistration(eventNamespace)->ErrorHandling.mkLogAndRaise(
         ~logger=Logging.createChildFrom(~logger, ~params=eventNamespace),
         ~msg="Duplicate contractRegister handlers not allowed",
       )
     }
-    t->setEventOptions(~eventOptions, ~logger)
+    setEventOptions(~contractName, ~eventName, ~eventOptions, ~logger)
   })
 }

codegenerator/cli/npm/envio/src/EventRegister.resi → codegenerator/cli/npm/envio/src/HandlerRegister.resi

@@ -1,31 +1,29 @@
 type registrations = {
   onBlockByChainId: dict<array<Internal.onBlockConfig>>,
-  mutable hasEvents: bool,
 }
 
 let startRegistration: (~ecosystem: Ecosystem.t, ~multichain: Config.multichain) => unit
 let isPendingRegistration: unit => bool
 let finishRegistration: unit => registrations
 
-@genType
-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