Switchable request and response added using JSON Serialization / Deserialization interfaces for passive switching.

Author: Arran Ubels

core/switchablerequest.go

@@ -0,0 +1,72 @@
+package core
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/aws/aws-lambda-go/events"
+)
+
+type SwitchableAPIGatewayRequest struct {
+	v interface{} // v is Always nil, or a pointer of APIGatewayProxyRequest or APIGatewayV2HTTPRequest
+}
+
+// NewSwitchableAPIGatewayRequestV1 creates a new SwitchableAPIGatewayRequest from APIGatewayProxyRequest
+func NewSwitchableAPIGatewayRequestV1(v *events.APIGatewayProxyRequest) *SwitchableAPIGatewayRequest {
+	return &SwitchableAPIGatewayRequest{
+		v: v,
+	}
+}
+// NewSwitchableAPIGatewayRequestV2 creates a new SwitchableAPIGatewayRequest from APIGatewayV2HTTPRequest
+func NewSwitchableAPIGatewayRequestV2(v *events.APIGatewayV2HTTPRequest) *SwitchableAPIGatewayRequest {
+	return &SwitchableAPIGatewayRequest{
+		v: v,
+	}
+}
+
+// MarshalJSON is a pass through serialization
+func (s *SwitchableAPIGatewayRequest) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.v)
+}
+
+// UnmarshalJSON is a switching serialization based on the presence of fields in the
+// source JSON, multiValueQueryStringParameters for APIGatewayProxyRequest and rawQueryString for
+// APIGatewayV2HTTPRequest.
+func (s *SwitchableAPIGatewayRequest) UnmarshalJSON(b []byte) error {
+	delta := map[string]json.RawMessage{}
+	if err := json.Unmarshal(b, &delta); err != nil {
+		return err
+	}
+	_, v1test := delta["multiValueQueryStringParameters"]
+	_, v2test := delta["rawQueryString"]
+	s.v = nil
+	if v1test && !v2test {
+		s.v = &events.APIGatewayProxyRequest{}
+	} else if !v1test && v2test {
+		s.v = &events.APIGatewayV2HTTPRequest{}
+	} else {
+		return errors.New("unable to determine request version")
+	}
+	return json.Unmarshal(b, s.v)
+}
+
+// Version1 returns the contained events.APIGatewayProxyRequest or nil
+func (s *SwitchableAPIGatewayRequest) Version1() *events.APIGatewayProxyRequest {
+	switch v := s.v.(type) {
+	case *events.APIGatewayProxyRequest:
+		return v
+	case events.APIGatewayProxyRequest:
+		return &v
+	}
+	return nil
+}
+
+// Version2 returns the contained events.APIGatewayV2HTTPRequest or nil
+func (s *SwitchableAPIGatewayRequest) Version2() *events.APIGatewayV2HTTPRequest {
+	switch v := s.v.(type) {
+	case *events.APIGatewayV2HTTPRequest:
+		return v
+	case events.APIGatewayV2HTTPRequest:
+		return &v
+	}
+	return nil
+}

core/switchablerequest_test.go

@@ -0,0 +1,74 @@
+package core
+
+import (
+	"encoding/json"
+	"github.com/aws/aws-lambda-go/events"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("SwitchableAPIGatewayRequest", func() {
+	Context("Serialization", func() {
+		It("v1 serialized okay", func() {
+			e := NewSwitchableAPIGatewayRequestV1(&events.APIGatewayProxyRequest{
+				MultiValueQueryStringParameters: map[string][]string{},
+			})
+			b, err := json.Marshal(e)
+			Expect(err).To(BeNil())
+			m := map[string]interface{}{}
+			err = json.Unmarshal(b, &m)
+			Expect(err).To(BeNil())
+			Expect(m["multiValueQueryStringParameters"]).To(Equal(map[string]interface {}{}))
+			Expect(m["body"]).To(Equal(""))
+		})
+		It("v2 serialized okay", func() {
+			e := NewSwitchableAPIGatewayRequestV2(&events.APIGatewayV2HTTPRequest{})
+			b, err := json.Marshal(e)
+			Expect(err).To(BeNil())
+			m := map[string]interface{}{}
+			err = json.Unmarshal(b, &m)
+			Expect(err).To(BeNil())
+			Expect(m["rawQueryString"]).To(Equal(""))
+			Expect(m["isBase64Encoded"]).To(Equal(false))
+		})
+	})
+	Context("Deserialization", func() {
+		It("v1 deserialized okay", func() {
+			input := &events.APIGatewayProxyRequest{
+				Body:       "234",
+				MultiValueQueryStringParameters: map[string][]string{
+					"Test": []string{ "Value1", "Value2", },
+				},
+			}
+			b, _ := json.Marshal(input)
+			s := SwitchableAPIGatewayRequest{}
+			err := s.UnmarshalJSON(b)
+			Expect(err).To(BeNil())
+			Expect(s.Version2()).To(BeNil())
+			Expect(s.Version1()).To(BeEquivalentTo(input))
+		})
+		It("v2 deserialized okay", func() {
+			input := &events.APIGatewayV2HTTPRequest{
+				IsBase64Encoded:       true,
+				RawQueryString: "a=b&c=d",
+			}
+			b, _ := json.Marshal(input)
+			s := SwitchableAPIGatewayRequest{}
+			err := s.UnmarshalJSON(b)
+			Expect(err).To(BeNil())
+			Expect(s.Version1()).To(BeNil())
+			Expect(s.Version2()).To(BeEquivalentTo(input))
+		})
+	})})
+
+func getProxyRequestV2(path string, method string) events.APIGatewayV2HTTPRequest {
+	return events.APIGatewayV2HTTPRequest{
+		RequestContext: events.APIGatewayV2HTTPRequestContext{
+			HTTP: events.APIGatewayV2HTTPRequestContextHTTPDescription{
+				Path:   path,
+				Method: method,
+			},
+		},
+		RawPath: path,
+	}
+}

core/switchableresponse.go

@@ -0,0 +1,77 @@
+package core
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/aws/aws-lambda-go/events"
+)
+
+// SwitchableAPIGatewayResponse is a container for an APIGatewayProxyResponse or an APIGatewayV2HTTPResponse object which
+// handles serialization and deserialization and switching between the entities based on the presence of fields in the
+// source JSON, multiValueQueryStringParameters for APIGatewayProxyResponse and rawQueryString for
+// APIGatewayV2HTTPResponse. It also provides some simple switching functions (wrapped type switching.)
+type SwitchableAPIGatewayResponse struct {
+	v interface{}
+}
+
+// NewSwitchableAPIGatewayResponseV1 creates a new SwitchableAPIGatewayResponse from APIGatewayProxyResponse
+func NewSwitchableAPIGatewayResponseV1(v *events.APIGatewayProxyResponse) *SwitchableAPIGatewayResponse {
+	return &SwitchableAPIGatewayResponse{
+		v: v,
+	}
+}
+
+// NewSwitchableAPIGatewayResponseV2 creates a new SwitchableAPIGatewayResponse from APIGatewayV2HTTPResponse
+func NewSwitchableAPIGatewayResponseV2(v *events.APIGatewayV2HTTPResponse) *SwitchableAPIGatewayResponse {
+	return &SwitchableAPIGatewayResponse{
+		v: v,
+	}
+}
+
+// MarshalJSON is a pass through serialization
+func (s *SwitchableAPIGatewayResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.v)
+}
+
+// UnmarshalJSON is a switching serialization based on the presence of fields in the
+// source JSON, statusCode to verify that it's either APIGatewayProxyResponse or APIGatewayV2HTTPResponse and then
+// rawQueryString for to determine if it is APIGatewayV2HTTPResponse or not.
+func (s *SwitchableAPIGatewayResponse) UnmarshalJSON(b []byte) error {
+	delta := map[string]json.RawMessage{}
+	if err := json.Unmarshal(b, &delta); err != nil {
+		return err
+	}
+	_, test := delta["statusCode"]
+	_, v2test := delta["cookies"]
+	s.v = nil
+	if test && !v2test {
+		s.v = &events.APIGatewayProxyResponse{}
+	} else if test && v2test {
+		s.v = &events.APIGatewayV2HTTPResponse{}
+	} else {
+		return errors.New("unable to determine response version")
+	}
+	return json.Unmarshal(b, s.v)
+}
+
+// Version1 returns the contained events.APIGatewayProxyResponse or nil
+func (s *SwitchableAPIGatewayResponse) Version1() *events.APIGatewayProxyResponse {
+	switch v := s.v.(type) {
+	case *events.APIGatewayProxyResponse:
+		return v
+	case events.APIGatewayProxyResponse:
+		return &v
+	}
+	return nil
+}
+
+// Version2 returns the contained events.APIGatewayV2HTTPResponse or nil
+func (s *SwitchableAPIGatewayResponse) Version2() *events.APIGatewayV2HTTPResponse {
+	switch v := s.v.(type) {
+	case *events.APIGatewayV2HTTPResponse:
+		return v
+	case events.APIGatewayV2HTTPResponse:
+		return &v
+	}
+	return nil
+}

core/switchableresponse_test.go

@@ -0,0 +1,61 @@
+package core
+
+import (
+	"encoding/json"
+	"github.com/aws/aws-lambda-go/events"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("SwitchableAPIGatewayResponse", func() {
+	Context("Serialization", func() {
+		It("v1 serialized okay", func() {
+			e := NewSwitchableAPIGatewayResponseV1(&events.APIGatewayProxyResponse{})
+			b, err := json.Marshal(e)
+			Expect(err).To(BeNil())
+			m := map[string]interface{}{}
+			err = json.Unmarshal(b, &m)
+			Expect(err).To(BeNil())
+			Expect(m["statusCode"]).To(Equal(0.0))
+			Expect(m["body"]).To(Equal(""))
+		})
+		It("v2 serialized okay", func() {
+			e := NewSwitchableAPIGatewayResponseV2(&events.APIGatewayV2HTTPResponse{})
+			b, err := json.Marshal(e)
+			Expect(err).To(BeNil())
+			m := map[string]interface{}{}
+			err = json.Unmarshal(b, &m)
+			Expect(err).To(BeNil())
+			Expect(m["statusCode"]).To(Equal(0.0))
+			Expect(m["body"]).To(Equal(""))
+		})
+	})
+	Context("Deserialization", func() {
+		It("v1 deserialized okay", func() {
+			input := &events.APIGatewayProxyResponse{
+				StatusCode: 123,
+				Body:       "234",
+			}
+			b, _ := json.Marshal(input)
+			s := SwitchableAPIGatewayResponse{}
+			err := s.UnmarshalJSON(b)
+			Expect(err).To(BeNil())
+			Expect(s.Version2()).To(BeNil())
+			Expect(s.Version1()).To(BeEquivalentTo(input))
+		})
+		It("v2 deserialized okay", func() {
+			input := &events.APIGatewayV2HTTPResponse{
+				StatusCode: 123,
+				Body:       "234",
+				Cookies:    []string{"4", "5"},
+			}
+			b, _ := json.Marshal(input)
+			s := SwitchableAPIGatewayResponse{}
+			err := s.UnmarshalJSON(b)
+			Expect(err).To(BeNil())
+			Expect(s.Version1()).To(BeNil())
+			Expect(s.Version2()).To(BeEquivalentTo(input))
+		})
+	})
+})
+

gorillamux/adapter.go

@@ -2,15 +2,16 @@ package gorillamux
 
 import (
 	"context"
+	"errors"
 	"net/http"
 
-	"github.com/aws/aws-lambda-go/events"
 	"github.com/awslabs/aws-lambda-go-api-proxy/core"
 	"github.com/gorilla/mux"
 )
 
 type GorillaMuxAdapter struct {
-	core.RequestAccessor
+	RequestAccessor core.RequestAccessor
+	RequestAccessorV2 core.RequestAccessorV2
 	router *mux.Router
 }
 
@@ -20,34 +21,68 @@ func New(router *mux.Router) *GorillaMuxAdapter {
 	}
 }
 
-// Proxy receives an API Gateway proxy event, transforms it into an http.Request
+// Proxy receives an API Gateway proxy event or API Gateway V2 event, transforms it into an http.Request
 // object, and sends it to the mux.Router for routing.
 // It returns a proxy response object generated from the http.ResponseWriter.
-func (h *GorillaMuxAdapter) Proxy(event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
-	req, err := h.ProxyEventToHTTPRequest(event)
-	return h.proxyInternal(req, err)
+func (h *GorillaMuxAdapter) Proxy(event core.SwitchableAPIGatewayRequest) (*core.SwitchableAPIGatewayResponse, error) {
+	if event.Version1() != nil {
+		req, err := h.RequestAccessor.ProxyEventToHTTPRequest(*event.Version1())
+		return h.proxyInternal(req, err)
+	} else if event.Version2() != nil {
+		req, err := h.RequestAccessorV2.ProxyEventToHTTPRequest(*event.Version2())
+		return h.proxyInternalV2(req, err)
+	} else {
+		return &core.SwitchableAPIGatewayResponse{}, core.NewLoggedError("Could not convert proxy event to request: %v", errors.New("Unable to determine version "))
+	}
 }
 
-// ProxyWithContext receives context and an API Gateway proxy event,
+// ProxyWithContext receives context and an API Gateway proxy event or API Gateway V2 event,
 // transforms them into an http.Request object, and sends it to the mux.Router for routing.
 // It returns a proxy response object generated from the http.ResponseWriter.
-func (h *GorillaMuxAdapter) ProxyWithContext(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
-	req, err := h.EventToRequestWithContext(ctx, event)
-	return h.proxyInternal(req, err)
+func (h *GorillaMuxAdapter) ProxyWithContext(ctx context.Context, event core.SwitchableAPIGatewayRequest) (*core.SwitchableAPIGatewayResponse, error) {
+	if event.Version1() != nil {
+		req, err := h.RequestAccessor.EventToRequestWithContext(ctx, *event.Version1())
+		return h.proxyInternal(req, err)
+	} else if event.Version2() != nil {
+		req, err := h.RequestAccessorV2.EventToRequestWithContext(ctx, *event.Version2())
+		return h.proxyInternalV2(req, err)
+	} else {
+		return &core.SwitchableAPIGatewayResponse{}, core.NewLoggedError("Could not convert proxy event to request: %v", errors.New("Unable to determine version "))
+	}
 }
 
-func (h *GorillaMuxAdapter) proxyInternal(req *http.Request, err error) (events.APIGatewayProxyResponse, error) {
+func (h *GorillaMuxAdapter) proxyInternal(req *http.Request, err error) (*core.SwitchableAPIGatewayResponse, error) {
 	if err != nil {
-		return core.GatewayTimeout(), core.NewLoggedError("Could not convert proxy event to request: %v", err)
+		timeout := core.GatewayTimeout()
+		return core.NewSwitchableAPIGatewayResponseV1(&timeout), core.NewLoggedError("Could not convert proxy event to request: %v", err)
 	}
 
 	w := core.NewProxyResponseWriter()
 	h.router.ServeHTTP(http.ResponseWriter(w), req)
 
 	resp, err := w.GetProxyResponse()
 	if err != nil {
-		return core.GatewayTimeout(), core.NewLoggedError("Error while generating proxy response: %v", err)
+		timeout := core.GatewayTimeout()
+		return core.NewSwitchableAPIGatewayResponseV1(&timeout), core.NewLoggedError("Error while generating proxy response: %v", err)
+	}
+
+	return core.NewSwitchableAPIGatewayResponseV1(&resp), nil
+}
+
+func (h *GorillaMuxAdapter) proxyInternalV2(req *http.Request, err error) (*core.SwitchableAPIGatewayResponse, error) {
+	if err != nil {
+		timeout := core.GatewayTimeoutV2()
+		return core.NewSwitchableAPIGatewayResponseV2(&timeout), core.NewLoggedError("Could not convert proxy event to request: %v", err)
+	}
+
+	w := core.NewProxyResponseWriterV2()
+	h.router.ServeHTTP(http.ResponseWriter(w), req)
+
+	resp, err := w.GetProxyResponse()
+	if err != nil {
+		timeout := core.GatewayTimeoutV2()
+		return core.NewSwitchableAPIGatewayResponseV2(&timeout), core.NewLoggedError("Error while generating proxy response: %v", err)
 	}
 
-	return resp, nil
+	return core.NewSwitchableAPIGatewayResponseV2(&resp), nil
 }