NewHandler should return input if it is of type Handler

[rittneje]

Is your feature request related to a problem? Please describe.
Just had an issue where we accidentally did something like this:

h := lambda.NewHandler(...)
lambda.Start(h)

instead of this:

h := lambda.NewHandler(...)
lambda.StartHandler(h)

This is caused by the fact that Start takes interface{}, so the compiler is unable to detect the error.

Describe the solution you'd like
NewHandler should check if the input implements Handler and if so return the input unchanged, possibly logging some kind of warning.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

[swoldemi]

Hello @rittneje! Lambda functions can have any of the following function signatures:

func ()
func () error
func (TIn), error
func () (TOut, error)
func (context.Context) error
func (context.Context, TIn) error
func (context.Context) (TOut, error)
func (context.Context, TIn) (TOut, error)

Where TIn and TOut are some input and output type that can be received and returned by your Lambda function.

Because of this, Start accepts an interface. You should instead create your Lambda function, then pass your function to lambda.Start. lambda.NewFunction is used internally to structure/unmarshal the interface: https://github.com/aws/aws-lambda-go/blob/master/lambda/entry.go#L50-L62.

What did you have in mind for having NewHandler check that input implements Handler?

For reference: https://docs.aws.amazon.com/lambda/latest/dg/golang-handler.html

[rittneje]

We needed to wrap the handler to inject middleware. For this reason, we needed to call lambda.NewHandler ourselves, wrap it, and then pass the resulting lambda.Handler to lambda.StartHandler. However, we accidentally passed it to lambda.Start, and the compiler was unable to detect the issue because lambda.Start can accept any input as far as the type system is concerned.

lambda.Start is currently implemented like this:

func Start(handler interface{}) {
    wrappedHandler := NewHandler(handler)
    StartHandler(wrappedHandler)
}

To prevent the issue that just occurred to us, either Start or NewHandler should be modified like so:

func Start(handler interface{}) {
    var wrappedHandler Handler
    if h, ok := handler.(Handler); ok {
        wrappedHandler = h
    } else {
        wrappedHandler = NewHandler(handler)
    }
    StartHandler(wrappedHandler)
}

or

func NewHandler(handlerFunc interface{}) Handler {
    if h, ok := handlerFunc.(Handler); ok {
        return h
    }
    ...
}

[danielwhite]

I believe this has been addressed by #444 as of v1.32.0.

[rittneje]

@danielwhite From reading through the code that appears to be true. However, the documentation for lambda.Start needs to be updated to mention that you can also pass an instance of lambda.Handler now instead of a function.