Refactor handler registration scoped to event modules - #151

JonoPrest · 2024-08-27T15:48:51Z

Refactors:

Handler registration now happens on each Event module and no need to pass around a registered events map
event mod lookup is instantiated and passed per chain to each chain worker
event mod lookup is refactored to not handle multichain insertions/lookups and remove the need for a generic map. It is now simply a moap for event modules.

JonoPrest · 2024-08-28T15:31:27Z


 let getContractRegisterArgs = (contextEnv, ~inMemoryStore) => {
-  RegisteredEvents.event: contextEnv.event,
+  Types.Handlers.event: contextEnv.event,


RegesteredEvents module is removed and it's types are moved into Types.Handlers

JonoPrest · 2024-08-28T15:32:46Z

-    ? executeSetEntityWithHistory
-    : executeDbFunctionsEntity
+  let entityDbExecutionComposer =
+    RegisterHandlers.getConfig()->Config.shouldRollbackOnReorg


Config.getGenerated is removed, it now needs to be accessed from RegisterHandlers.getConfig() to ensure handlers are all registered (with event options) before instantiating the workers

JonoPrest · 2024-08-28T15:33:23Z

-        {{/with}}
-      }
-      {{/if}}
+  let makeGeneratedConfig = () => {


I would suggest reviewing this with hide whitespace setting

Thanks, I didn't know about the option

JonoPrest · 2024-08-28T15:34:08Z

+              let eventModLookup =
+                contracts
+                ->Belt.Array.flatMap(contract => contract.events)
+                ->EventModLookup.fromArrayOrThrow(~chain)


evenModLookup is now instantiated when this makeGeneratedConfig is run and passed to the chain worker

JonoPrest · 2024-08-28T15:37:43Z

+@genType
+module Handlers = {
+  type args<'eventArgs, 'context> = {
+    event: eventLog<'eventArgs>,
+    context: 'context,
+  }
+
+  type contractRegisterArgs<'eventArgs> = args<'eventArgs, contractRegistrations>
+  type contractRegister<'eventArgs> = contractRegisterArgs<'eventArgs> => unit
+
+  type loaderArgs<'eventArgs> = args<'eventArgs, loaderContext>
+  type loader<'eventArgs, 'loaderReturn> = loaderArgs<'eventArgs> => promise<'loaderReturn>
+
+  type handlerArgs<'eventArgs, 'loaderReturn> = {
+    event: eventLog<'eventArgs>,
+    context: handlerContext,
+    loaderReturn: 'loaderReturn,
+  }
+
+  type handler<'eventArgs, 'loaderReturn> = handlerArgs<'eventArgs, 'loaderReturn> => promise<unit>
+
+  type loaderHandler<'eventArgs, 'loaderReturn> = {
+    loader: loader<'eventArgs, 'loaderReturn>,
+    handler: handler<'eventArgs, 'loaderReturn>,
+  }
+
+  type eventOptions = {
+    wildcard: bool,
+    topicSelections: array<LogSelection.topicSelection>,
+  }
+
+  let getDefaultEventOptions = (~topic0) => {
+    wildcard: false,
+    topicSelections: [LogSelection.makeTopicSelection(~topic0=[topic0])->Utils.unwrapResultExn],
+  }
+
+  type registeredEvent<'eventArgs, 'loaderReturn> = {
+    loaderHandler?: loaderHandler<'eventArgs, 'loaderReturn>,
+    contractRegister?: contractRegister<'eventArgs>,
+    eventOptions: eventOptions,
+  }


This chunk is basically just moved from RegisteredEvents.res

JonoPrest · 2024-08-28T15:38:30Z

+  module Register: {
+    type t<'eventArgs>
+    let make: (~topic0: string, ~contractName: string, ~eventName: string) => t<'eventArgs>
+    let setLoaderHandler: (
+      t<'eventArgs>,
+      loaderHandler<'eventArgs, 'loaderReturn>,
+      ~eventOptions: option<eventOptions>,
+      ~logger: Pino.t=?,
+    ) => unit
+    let setContractRegister: (
+      t<'eventArgs>,
+      contractRegister<'eventArgs>,
+      ~eventOptions: option<eventOptions>,
+      ~logger: Pino.t=?,
+    ) => unit
+    let getLoaderHandler: t<'eventArgs> => option<loaderHandler<'eventArgs, 'loaderReturn>>
+    let getContractRegister: t<'eventArgs> => option<contractRegister<'eventArgs>>
+    let getEventOptions: t<'eventArgs> => eventOptions
+    let hasRegistration: t<'eventArgs> => bool
+  } = {
+    type loaderReturn
+
+    type t<'eventArgs> = {
+      contractName: string,
+      eventName: string,
+      topic0: string,
+      mutable loaderHandler: option<loaderHandler<'eventArgs, loaderReturn>>,
+      mutable contractRegister: option<contractRegister<'eventArgs>>,
+      mutable eventOptions: option<eventOptions>,
+    }
+
+    let getLoaderHandler = (t: t<'eventArgs>): option<loaderHandler<'eventArgs, 'loaderReturn>> =>
+      t.loaderHandler->(
+        Utils.magic: option<loaderHandler<'eventArgs, loaderReturn>> => option<
+          loaderHandler<'eventArgs, 'loaderReturn>,
+        >
+      )
+
+    let getContractRegister = (t: t<'eventArgs>): option<contractRegister<'eventArgs>> =>
+      t.contractRegister
+
+    let getEventOptions = ({eventOptions, topic0}: t<'eventArgs>): eventOptions =>
+      switch eventOptions {
+      | Some(eventOptions) => eventOptions
+      | None => getDefaultEventOptions(~topic0)
+      }
+
+    let hasRegistration = ({loaderHandler, contractRegister}) =>
+      loaderHandler->Belt.Option.isSome || contractRegister->Belt.Option.isSome
+
+    let make = (~topic0, ~contractName, ~eventName) => {
+      contractName,
+      eventName,
+      topic0,
+      loaderHandler: None,
+      contractRegister: None,
+      eventOptions: None,
+    }
+
+    type eventNamespace = {contractName: string, eventName: string}
+    exception DuplicateEventRegistration(eventNamespace)
+
+    let setEventOptions = (t: t<'eventArgs>, value: eventOptions, ~logger=Logging.logger) => {
+      switch t.eventOptions {
+      | None => t.eventOptions = Some(value)
+      | Some(_) =>
+        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",
+        )
+      }
+    }
+
+    let setLoaderHandler = (
+      t: t<'eventArgs>,
+      value: loaderHandler<'eventArgs, 'loaderReturn>,
+      ~eventOptions,
+      ~logger=Logging.logger,
+    ) => {
+      switch t.loaderHandler {
+      | None =>
+        t.loaderHandler =
+          value
+          ->(Utils.magic: loaderHandler<'eventArgs, 'loaderReturn> => loaderHandler<
+            'eventArgs,
+            loaderReturn,
+          >)
+          ->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",
+        )
+      }
+
+      switch eventOptions {
+      | Some(eventOptions) => t->setEventOptions(eventOptions, ~logger)
+      | None => ()
+      }
+    }


This is a new abstraction for registering handlers with with options on an event module

JonoPrest · 2024-08-28T15:39:55Z

+open Belt
+type eventMod = module(Types.InternalEvent)
+
+type errorKind = WildcardSighashCollision | Duplicate
+type eventError = {eventMod: eventMod, errorKind: errorKind}
+module ContractEventMods = {
+  type t = {
+    all: array<eventMod>,
+    byContractName: dict<eventMod>,
+  }
+


Strange this wasn't tracked as a move... but there are quite a lot of changes here as well.

JonoPrest · 2024-08-28T15:45:00Z

+  let set = (
+    inMemTable: t<'entity>,
+    entityUpdate: Types.entityUpdate<'entity>,
+    ~shouldRollbackOnReorg,


Passing shouldRollbackOnReorg in here because using RegisterHandlers causes dependency cycle

Nice, we had to get rid of Config.getGenerated() anyways

DZakh · 2024-08-29T08:17:03Z

+  let findWildcard = ({all}) => {
+    all->Js.Array2.find(event => event->isWildcard)
+  }


With the new design you can add wildcard: option<eventMod> field to the ContractEventMods.t type, which will simplify the hasWildcardCollision and allow getting rid of the findWildcard function

DZakh · 2024-08-29T08:18:52Z

+
+  let set = ({all, byContractName}: t, eventMod: eventMod) => {
+    let module(Event) = eventMod
+    switch byContractName->Js.Dict.get(Event.contractName) {


A tiny thing, but there's Utils.Dict.dangerouslyGetNonOption, which doesn't have an unnecessary runtime overhead.

Ok cool, I think it makes sense to improve for the get function but these values will only be set at startup

DZakh

Amazing 👍 The only comment is about improving the wildcard eventMod lookup 👌

JonoPrest force-pushed the jp/event-routing branch from e5139de to 79978bc Compare August 28, 2024 10:34

JonoPrest force-pushed the jp/refactor-registration branch from d4b55f1 to 615eda0 Compare August 28, 2024 10:39

JonoPrest force-pushed the jp/event-routing branch from 79978bc to 04dccd4 Compare August 28, 2024 10:42

JonoPrest force-pushed the jp/refactor-registration branch from 615eda0 to dfa9fe1 Compare August 28, 2024 10:48

JonoPrest marked this pull request as ready for review August 28, 2024 15:26

JonoPrest requested a review from DZakh August 28, 2024 15:26

JonoPrest commented Aug 28, 2024

View reviewed changes

JonoPrest force-pushed the jp/refactor-registration branch from 67e050f to c7acf83 Compare August 28, 2024 15:43

JonoPrest commented Aug 28, 2024

View reviewed changes

DZakh reviewed Aug 29, 2024

View reviewed changes

DZakh approved these changes Aug 29, 2024

View reviewed changes

JonoPrest force-pushed the jp/event-routing branch from 04dccd4 to a1e2351 Compare August 30, 2024 08:11

Base automatically changed from jp/event-routing to main August 30, 2024 08:14

JonoPrest added 4 commits August 30, 2024 10:22

Refactor EventLookup data structure removing single and multiple

0182616

Refactor handler registration scoped to event modules

60a7209

Refactor event lookup and remove multi chain handling per lookup

e564dc7

Fix tests using mock configs

53d74dc

JonoPrest force-pushed the jp/refactor-registration branch from c7acf83 to 53d74dc Compare August 30, 2024 08:27

JonoPrest enabled auto-merge (squash) August 30, 2024 08:28

JonoPrest merged commit 4e076cf into main Aug 30, 2024

JonoPrest deleted the jp/refactor-registration branch August 30, 2024 08:32

Uh oh!

Conversation

JonoPrest commented Aug 27, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JonoPrest Aug 28, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

DZakh left a comment

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

JonoPrest commented Aug 27, 2024 •

edited

Loading

JonoPrest Aug 28, 2024 •

edited

Loading