handler.go

package lambada

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/aws/aws-lambda-go/lambda"
)

// LambadaHandler is a Lambada lambda handler function which can be used with lambda.Start.
type LambadaHandler func(ctx context.Context, req Request) (Response, error)

// NewHandler returns a Lambda function handler which can be used with lambda.Start.
// The returned lambda handler wraps incoming requets into http.Request, calls the provided http.Handler and converts
// the response into an API Gateway response.
func NewHandler(h http.Handler, options ...Option) LambadaHandler {
	opts := newOptions(options...)

	return func(ctx context.Context, req Request) (Response, error) {
		defer func() {
			if r := recover(); r != nil {
				opts.logger.LogPanic(ctx, &req, r)
				// Forward panic
				panic(r)
			}
		}()

		if req.Version == "2.0" {
			req.version = 2
		} else {
			req.version = 1
		}

		opts.logger.LogRequest(ctx, &req)

		w := newResponseWriter(opts.outputMode, opts.defaultBinary)

		// Find out which version it is
		var httpRequest *http.Request
		var err error
		if req.version == 2 {
			httpRequest, err = makeV2Request(ctx, &req)
		} else {
			httpRequest, err = makeV1Request(ctx, &req)
		}
		if err != nil {
			opts.logger.LogError(ctx, &req, err)
			return Response{}, err
		}

		// Let the handler process the request
		h.ServeHTTP(w, httpRequest)
		w.finalize()

		res := Response{
			StatusCode:        w.statusCode,
			Headers:           toSingleValueHeaders(w.lockedHeader),
			MultiValueHeaders: w.lockedHeader,
			Body:              bytesToBody(w.body.Bytes(), w.binary),
			IsBase64Encoded:   w.binary,
		}
		opts.logger.LogResponse(ctx, &req, &res)
		return res, nil
	}
}

// Serve starts the Lambda handler using the http.Handler to serve incoming requests.
// Serve calls lambda.Start(NewHandler(h)) under the hood.
func Serve(h http.Handler) {
	ServeWithOptions(h)
}

// ServeWithOptions starts the lambda handler using the http.Handler and options to serve incoming requests.
// ServeWithOptions calls lambda.Start(NewHandler(h, options...)) under the hood.
func ServeWithOptions(h http.Handler, options ...Option) {
	lambda.Start(NewHandler(h, options...))
}

func marshalJSON(v any) string {
	data, err := json.Marshal(v)
	if err != nil {
		return fmt.Sprintf("<failed to marshal json: %v>", err)
	}
	return string(data)
}