example_main.go

package main

import (
	"errors"
	"fmt"
	"net/http"

	"github.com/labstack/echo"
	"github.com/labstack/echo/middleware"
)

type (
	// Server wraps Echo to customize.
	Server struct {
		e *echo.Echo
	}
)

// Error

// MyError1 is sample error.
type MyError1 struct{}

func (e *MyError1) Error() string { return "this is MyError1" }

// MyError2 is sample error.
type MyError2 struct{}

func (e *MyError2) Error() string { return "this is MyError2" }

// MyError3 is sample error.
type MyError3 struct{}

func (e *MyError3) Error() string { return "this is MyError3" }

// MyError4 is sample error.
type MyError4 struct{}

func (e *MyError4) Error() string { return "this is MyError4" }

// Handler
func getFoo(c echo.Context) error {
	foo := c.QueryParam("foo")
	switch foo {
	case "1":
		return &MyError1{}
	case "2":
		return &MyError2{}
	case "3":
		return &MyError3{}
	case "4":
		return fmt.Errorf("this is MyError4_2: %w", fmt.Errorf("this is MyError4: %w", &MyError1{}))
	default:
		return c.JSON(http.StatusOK, foo)
	}
}

// MyErrorHandler wraps DefaultHTTPErrorHandler.
func (svr *Server) MyErrorHandler(err error, c echo.Context) {
	// Retrieve the wrapped original error
	for errors.Unwrap(err) != nil {
		err = errors.Unwrap(err)
	}

	// Switch response
	switch err.(type) {
	case *MyError1:
		err = echo.NewHTTPError(http.StatusNotFound)
	case *MyError2:
		err = echo.NewHTTPError(http.StatusNotFound, err.Error())
	case *MyError3:
		err = echo.NewHTTPError(http.StatusBadRequest)
	case *MyError4:
		err = echo.NewHTTPError(http.StatusNotFound, err.Error())
	}

	// DefaultHTTPErrorHandler
	svr.e.DefaultHTTPErrorHandler(err, c)
}

func main() {
	// Echo instance
	svr := new(Server)
	e := echo.New()
	svr.e = e

	// Middleware
	svr.e.Use(middleware.Logger())
	svr.e.Use(middleware.Recover())

	// HTTPErrorHandler
	svr.e.HTTPErrorHandler = svr.MyErrorHandler

	// Routes
	svr.e.GET("/", getFoo)

	// Start server
	svr.e.Logger.Fatal(e.Start(":1323"))
}