Registering routes, but define the routing outside of the interface

[ekkinox]

Hello team, first of all, congrats for Fx, it's amazing.

In your example, you do the following:

type Route interface {
  http.Handler
  Pattern() string
}

and register a route with the following

func AsRoute(f any) any {
  return fx.Annotate(
    f,
    fx.As(new(Route)),
    fx.ResultTags(`group:"routes"`),
  )
}

fx.Provide(
    AsRoute(NewEchoHandler),
    AsRoute(NewHelloHandler),
),

I'm trying to find a way to have routes, that would NOT carry routing information (so no Pattern() method), but instead to define routing information at the moment I register my routes:

func AsRoute(pattern string, f any) any { // how to do ?}

fx.Provide(
    AsRoute("/echo", NewEchoHandler),
    AsRoute("/hello", NewHelloHandler),
),

I tried to play with Annotate and making structs that would hold the hanldler constructor function + the pattern, but I can find a way to make this work.

If you have any suggestions, it would be greatly appreciated !

[7amou3]

I'm actually trying to solve the same thing, how can I provide routes in registration or in a central place ex

func myControllerRoutes(mux *http.ServeMux) {
   mux.Handle("/echo", NewEchoHandler)
   mux.Handle("/hello", NewHelloHandler)
   ...
}

any idea how to achieve this?
thanks

[abhinav]

In our code, we have a function with the signature:

func ProvideHandler(pattern string, ctor any) fx.Option 

ctor is any function with the signatures:

func(...) T
func(...) (T, error)

• where T is a value that implements http.Handler
• parameters of the function are dependencies

We use reflection to generate a func(...) (Route, error) function from that and feed it into the value group with fx.Anntoate.

So routing information is then provided at provide time:

var FooModule = fx.Module("foo",
  httpfx.ProvideHandler("/foo", newFooHandler),
)

func newFooHandler(logger *zap.Logger) *fooHandler
// or
func newFooHandler(logger *zap.Logger) http.Handler

func (*fooHandler) ServeHTTP(...)

Thinking out loud: I wonder if there's an easy API Fx could provide for this category of wrappers.
Things that reproduce an original constructor as-is, but do something with the return value.

[7amou3]

Thanks for your reply,
can you please provide a sample repository or point me to an implementation?

[abhinav]

Unfortunately, I cannot link to it. The repository where we do this is proprietary.
Roughly, the implementation should be something like this:

1. Start with this:

   func ProvideHandler(pattern string, ctor any) fx.Option {
       handlerCtor := reflect.ValueOf(ctor)
       ctyp := handlerCtor()
       if ctyp.NumOut() < 1 || ctor.NumOut() > 2 { panic("expected 1 or two return values") }
       hasErr := ctor.NumOut() == 2

   It does basically no validation of invalid inputs, so you should add that here.

2. Using that information, we can generate the type for the Route constructor.
   Argument types are copied over as-is:

   inTypes := make([]reflect.Type, ctyp.NumIn())
   for i := 0; i < ctyp.NumIn(); i++ {
       inTypes[i] = ctyp.In(i)
   }

3. Return type is always (Route, error):

   typeOfError := reflect.TypeOf((*error)(nil)).Elem()
   outTypes := []reflect.Type{
       reflect.TypeOf(Route{}), // given 'type Route struct{ Pattern string; Handler http.Handler }'
       typeOfError,
   }

4. That's enough to build up the function type:

   routeCtorType := reflect.FuncOf(inTypes, outTypes, false /* variardic */)

5. And then implement that function:

   routeCtor := reflect.MakeFunc(routeCtorType, func(args []reflect.Value) []reflect.Value {
       // Call the original function to get the handler and error (if any).
       results := handlerCtor.Call(args)
       handler, _ := results[0].Interface().(http.Handler)
       err := reflect.Zero(typeOfError)
       if hasErr {
           err, _ = results[1]
       }
       route := Route{Pattern: pattern, Handler: handler}
       return []reflect.Value{reflect.ValueOf(route), err}
   })).Interface()

   This is roughly equivalent to:

   routeCtor := func(arg1 Type1, arg2, Type2, ...) (Route, error) {
       handler, err := handlerCtor(arg1, arg2, ...)
       return Route{Pattern: pattern, Handler: handler}, err
   }

6. fx.Provide the resulting function into the value group:

   return fx.Provide(fx.Annotate(routeCtor, fx.ResultTags(`group:"routes"`)))

Caveats:

• This does no validation of its input. You'll want to add that.
• I have not tested if it works.
• It assumes Route is a struct. If Route is an interface, you'll need to adjust the implementation.

[7amou3]

thank you very much,
i will try to implement this

[ekkinox]

@7amou3 you may want to check here: https://github.com/ankorstore/yokai/blob/main/fxhttpserver%2Fregister.go

We now support registration of middlewares, handlers and handlers groups, with optional middlewares. This is made to work with Echo, but imo easy to adapt to net/http.

Hope this helps.