echo: add new content type negotiatorecho/v0.10.0

2 files changed, 268 insertions, 0 deletions

diff --git a/echo/controller/content_type_negotiator_v2.go b/echo/controller/content_type_negotiator_v2.go
new file mode 100644
index 0000000..63d7fd3
--- /dev/null
+++ b/echo/controller/content_type_negotiator_v2.go
@@ -0,0 +1,196 @@
+package controller
+
+import (
+        "errors"
+        "net/http"
+
+        "github.com/labstack/echo/v4"
+
+        glecho "code.crute.us/mcrute/golib/echo"
+        glhttp "code.crute.us/mcrute/golib/net/http"
+)
+
+const (
+        ContextMediaTypeParameters = "__golib_echo_negotiator_media_type_params"
+        DefaultContentType         = "*/*"
+)
+
+type ContentTypeHandlerMap map[string]ErrorHandler
+
+type ErrorHandler interface {
+        HandleError(echo.Context, int, error) error
+}
+
+type GetableHandler interface{ HandleGet(echo.Context) error }
+type HeadableHandler interface{ HandleHead(echo.Context) error }
+type PostableHandler interface{ HandlePost(echo.Context) error }
+type PutableHandler interface{ HandlePut(echo.Context) error }
+type PatchableHandler interface{ HandlePatch(echo.Context) error }
+type DeleteableHandler interface{ HandleDelete(echo.Context) error }
+type ConnectableHandler interface{ HandleConnect(echo.Context) error }
+type OptionableHandler interface{ HandleOptions(echo.Context) error }
+type TraceableHandler interface{ HandleTrace(echo.Context) error }
+
+type ContentTypeNegotiatingHandlerV2 struct {
+        handlers      map[string]map[string]echo.HandlerFunc // Content-Type -> HTTP Method -> Handler
+        errorHandlers map[string]ErrorHandler
+        mediaTypes    glhttp.AcceptableTypes
+}
+
+func NewContentTypeNegotiatingHandlerV2() *ContentTypeNegotiatingHandlerV2 {
+        return &ContentTypeNegotiatingHandlerV2{
+                handlers:      map[string]map[string]echo.HandlerFunc{},
+                mediaTypes:    glhttp.AcceptableTypes{},
+                errorHandlers: map[string]ErrorHandler{},
+        }
+}
+
+func buildMethodMap(hnd ErrorHandler) map[string]echo.HandlerFunc {
+        methods := map[string]echo.HandlerFunc{}
+
+        if h, ok := hnd.(GetableHandler); ok {
+                methods[http.MethodGet] = h.HandleGet
+        }
+
+        if h, ok := hnd.(HeadableHandler); ok {
+                methods[http.MethodHead] = h.HandleHead
+        }
+
+        if h, ok := hnd.(PostableHandler); ok {
+                methods[http.MethodPost] = h.HandlePost
+        }
+
+        if h, ok := hnd.(PutableHandler); ok {
+                methods[http.MethodPut] = h.HandlePut
+        }
+
+        if h, ok := hnd.(PatchableHandler); ok {
+                methods[http.MethodPatch] = h.HandlePatch
+        }
+
+        if h, ok := hnd.(DeleteableHandler); ok {
+                methods[http.MethodDelete] = h.HandleDelete
+        }
+
+        if h, ok := hnd.(ConnectableHandler); ok {
+                methods[http.MethodConnect] = h.HandleConnect
+        }
+
+        if h, ok := hnd.(OptionableHandler); ok {
+                methods[http.MethodOptions] = h.HandleOptions
+        }
+
+        if h, ok := hnd.(TraceableHandler); ok {
+                methods[http.MethodTrace] = h.HandleTrace
+        }
+
+        return methods
+}
+
+// RegisterHandler registers a handler for a content type and method. It
+// will return an error if registration fails.
+func (h *ContentTypeNegotiatingHandlerV2) RegisterHandler(ct string, hnd ErrorHandler) error {
+        mt, err := glhttp.ParseMediaType(ct)
+        if err != nil {
+                return err
+        }
+
+        h.mediaTypes = append(h.mediaTypes, mt)
+        h.mediaTypes.Sorted()
+
+        h.handlers[mt.String()] = buildMethodMap(hnd)
+        h.errorHandlers[mt.String()] = hnd
+        return nil
+}
+
+func (h *ContentTypeNegotiatingHandlerV2) Default(hnd ErrorHandler) *ContentTypeNegotiatingHandlerV2 {
+        return h.Handles(DefaultContentType, hnd)
+}
+
+// Handles is a fluent builder that panics on error
+func (h *ContentTypeNegotiatingHandlerV2) Handles(ct string, hnd ErrorHandler) *ContentTypeNegotiatingHandlerV2 {
+        if err := h.RegisterHandler(ct, hnd); err != nil {
+                panic(err)
+        }
+        return h
+}
+
+func (h *ContentTypeNegotiatingHandlerV2) HandlesAll(hnds ContentTypeHandlerMap) *ContentTypeNegotiatingHandlerV2 {
+        for ct, hnd := range hnds {
+                h.Handles(ct, hnd)
+        }
+        return h
+}
+
+func (h *ContentTypeNegotiatingHandlerV2) handleDefaultError(c echo.Context, code int, status string) error {
+        if hnd, ok := h.errorHandlers[DefaultContentType]; ok {
+                return hnd.HandleError(c, code, errors.New(status))
+        }
+
+        return c.JSON(code, map[string]any{
+                "error": map[string]any{
+                        "code":    code,
+                        "message": status,
+                },
+        })
+}
+
+func (h *ContentTypeNegotiatingHandlerV2) Handle(c echo.Context) error {
+        accept, err := glhttp.ParseAccept(c.Request().Header.Values("Accept"))
+        if err != nil {
+                return err
+        }
+
+        match, matcher := h.mediaTypes.FindMatch(accept)
+        if match == nil {
+                code := http.StatusNotAcceptable
+                return h.handleDefaultError(c, code, http.StatusText(code))
+        }
+
+        c.Set(ContextMediaTypeParameters, matcher.Parameters)
+
+        ctHandlers := h.handlers[match.String()]
+        handler, ok := ctHandlers[c.Request().Method]
+        if !ok {
+                code := http.StatusMethodNotAllowed
+                return h.errorHandlers[match.String()].HandleError(c, code, errors.New(http.StatusText(code)))
+        }
+
+        c.Response().Header().Set("Content-Type", match.String())
+
+        return handler(c)
+}
+
+func (h *ContentTypeNegotiatingHandlerV2) Connect(path string, r glecho.URLRouter, mw ...echo.MiddlewareFunc) *ContentTypeNegotiatingHandlerV2 {
+        allMethods := map[string]*int{}
+        for _, v := range h.handlers {
+                for k, _ := range v {
+                        allMethods[k] = nil
+                }
+        }
+
+        for k, _ := range allMethods {
+                switch k {
+                case http.MethodGet:
+                        r.GET(path, h.Handle, mw...)
+                case http.MethodHead:
+                        r.HEAD(path, h.Handle, mw...)
+                case http.MethodPost:
+                        r.POST(path, h.Handle, mw...)
+                case http.MethodPut:
+                        r.PUT(path, h.Handle, mw...)
+                case http.MethodPatch:
+                        r.PATCH(path, h.Handle, mw...)
+                case http.MethodDelete:
+                        r.DELETE(path, h.Handle, mw...)
+                case http.MethodConnect:
+                        r.Add(http.MethodConnect, path, h.Handle, mw...)
+                case http.MethodOptions:
+                        r.OPTIONS(path, h.Handle, mw...)
+                case http.MethodTrace:
+                        r.Add(http.MethodTrace, path, h.Handle, mw...)
+                }
+        }
+
+        return h
+}
diff --git a/echo/controller/content_type_negotiator_v2_test.go b/echo/controller/content_type_negotiator_v2_test.go
new file mode 100644
index 0000000..689003a
--- /dev/null
+++ b/echo/controller/content_type_negotiator_v2_test.go
@@ -0,0 +1,72 @@
+package controller
+
+import (
+        "fmt"
+        "io"
+        "net/http"
+        "net/http/httptest"
+        "testing"
+
+        "github.com/labstack/echo/v4"
+        "github.com/stretchr/testify/assert"
+)
+
+// TODO
+// Not Acceptable Error
+// Bad Request Error
+// Other error
+// Error with default handler
+// Error without default handler
+
+// Check context params
+// No handler for method
+// Check content-type return header
+// Handler runs
+
+type GetOnlyHandler struct{}
+
+func (h *GetOnlyHandler) HandleError(c echo.Context, code int, err error) error {
+        return c.String(code, fmt.Sprintf("%s -- default", err))
+}
+
+func (h *GetOnlyHandler) HandleGet(c echo.Context) error {
+        return c.String(http.StatusOK, "GET OK -- default")
+}
+
+type GetPostHandler struct{ Name string }
+
+func (h *GetPostHandler) HandleError(c echo.Context, code int, err error) error {
+        return c.String(code, fmt.Sprintf("%s %s", h.Name, err))
+}
+
+func (h *GetPostHandler) HandleGet(c echo.Context) error {
+        return c.String(http.StatusOK, fmt.Sprintf("%s GET OK", h.Name))
+}
+
+func (h *GetPostHandler) HandlePost(c echo.Context) error {
+        return c.String(http.StatusOK, fmt.Sprintf("%s POST OK", h.Name))
+}
+
+func TestHandlerSuccess(t *testing.T) {
+        hnd := NewContentTypeNegotiatingHandlerV2().
+                HandlesAll(ContentTypeHandlerMap{
+                        "*/*":        &GetOnlyHandler{},
+                        "text/xml":   &GetPostHandler{"xml"},
+                        "text/*":     &GetPostHandler{"html"},
+                        "text/plain": &GetPostHandler{"plain"},
+                })
+
+        e := echo.New()
+        req := httptest.NewRequest(http.MethodPost, "/", nil)
+        req.Header.Set("Accept", "text/*,*/*;q=0.8")
+        //"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8")
+        rec := httptest.NewRecorder()
+        c := e.NewContext(req, rec)
+
+        assert.NoError(t, hnd.Handle(c))
+
+        res := rec.Result()
+        o, _ := io.ReadAll(res.Body)
+        fmt.Printf("%s\n", o)
+        assert.False(t, true)
+}