Add middleware: cacheall.

cacheall.go

@@ -0,0 +1,44 @@
+package espresso
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/googollee/go-espresso/codec"
+)
+
+func cacheAllError(ctx Context) error {
+	wr := &responseWriter{
+		ResponseWriter: ctx.ResponseWriter(),
+	}
+	code := http.StatusInternalServerError
+	defer func() {
+		perr := recover()
+
+		if wr.hasWritten || (ctx.Error() == nil && perr == nil) {
+			return
+		}
+
+		if httpCoder, ok := ctx.Error().(HTTPError); ok {
+			code = httpCoder.HTTPCode()
+		}
+		wr.WriteHeader(code)
+
+		if perr == nil {
+			perr = ctx.Error()
+		}
+
+		codec := codec.Module.Value(ctx)
+		if codec == nil {
+			fmt.Fprintf(wr, "%v", perr)
+			return
+		}
+
+		_ = codec.EncodeResponse(ctx, perr)
+	}()
+
+	ctx = ctx.WithResponseWriter(wr)
+	ctx.Next()
+
+	return nil
+}

router.go

@@ -64,28 +64,13 @@ func (g *router) register(ctx *buildtimeContext, fn HandleFunc) {
 
 	pattern := ctx.endpoint.Method + " " + path
 	g.mux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
-		wr := &responseWriter{
-			ResponseWriter: w,
-		}
-
 		ctx := &runtimeContext{
 			ctx:      r.Context(),
 			endpoint: &endpoint,
 			request:  r,
-			response: wr,
+			response: w,
 		}
 
 		ctx.Next()
-
-		if wr.hasWritten || ctx.err != nil {
-			return
-		}
-
-		code := http.StatusInternalServerError
-		if httpCoder, ok := ctx.err.(HTTPError); ok {
-			code = httpCoder.HTTPCode()
-		}
-		w.WriteHeader(code)
-		fmt.Fprint(w, ctx.err.Error())
 	})
 }

runtime.go

@@ -94,7 +94,11 @@ func (c *runtimeContext) ResponseWriter() http.ResponseWriter {
 }
 
 func (c *runtimeContext) Next() {
-	c.endpoint.ChainFuncs[c.chainIndex](c)
+	index := c.chainIndex
+	c.chainIndex++
+	if err := c.endpoint.ChainFuncs[index](c); err != nil {
+		c.err = err
+	}
 }
 
 func (c *runtimeContext) Error() error {

server.go

@@ -23,6 +23,7 @@ func New() *Espresso {
 	}
 
 	ret.AddModule(codec.Module.ProvideWithFunc(codec.Default))
+	ret.Use(cacheAllError)
 
 	return ret
 }