🔥 feat: Add support for Express.js style req/res handlers (#3809)

Author: gaby

.github/README.md

@@ -158,6 +158,33 @@ func main() {
 
 When you need to convert entire applications or re-use `net/http` middleware chains, rely on the [adaptor middleware](https://docs.gofiber.io/next/middleware/adaptor/). It converts handlers and middlewares in both directions and even lets you mount a Fiber app in a `net/http` server.
 
+### Express-style handlers
+
+Fiber also adapts Express-style callbacks that operate on the lightweight `fiber.Req` and `fiber.Res` helper interfaces. This lets you port middleware and route handlers from Express-inspired codebases while keeping Fiber's router features:
+
+```go
+// Request/response handlers (2-argument)
+app.Get("/", func(req fiber.Req, res fiber.Res) error {
+    return res.SendString("Hello from Express-style handlers!")
+})
+
+// Middleware with an error-returning next callback (3-argument)
+app.Use(func(req fiber.Req, res fiber.Res, next func() error) error {
+    if req.IP() == "192.168.1.254" {
+        return res.SendStatus(fiber.StatusForbidden)
+    }
+    return next()
+})
+
+// Middleware with a no-arg next callback (3-argument)
+app.Use(func(req fiber.Req, res fiber.Res, next func()) {
+    if req.Get("X-Skip") == "true" {
+        return // stop the chain without calling next
+    }
+    next()
+})
+```
+
 > **Note:** Adapted `net/http` handlers continue to operate with the standard-library semantics. They don't get access to `fiber.Ctx` features and incur the overhead of the compatibility layer, so native `fiber.Handler` callbacks still provide the best performance.
 
 ## 👀 Examples

adapter.go

@@ -15,18 +15,116 @@ func toFiberHandler(handler any) (Handler, bool) {
 		return nil, false
 	}
 
+	switch handler.(type) {
+	case Handler, func(Ctx): // (1)-(2) Fiber handlers
+		return adaptFiberHandler(handler)
+	case func(Req, Res) error, func(Req, Res), func(Req, Res, func() error) error, func(Req, Res, func() error), func(Req, Res, func()) error, func(Req, Res, func()): // (3)-(8) Express-style request handlers
+		return adaptExpressHandler(handler)
+	case http.HandlerFunc, http.Handler, func(http.ResponseWriter, *http.Request): // (9)-(11) net/http handlers
+		return adaptHTTPHandler(handler)
+	case fasthttp.RequestHandler, func(*fasthttp.RequestCtx) error: // (12)-(13) fasthttp handlers
+		return adaptFastHTTPHandler(handler)
+	default: // (14) unsupported handler type
+		return nil, false
+	}
+}
+
+func adaptFiberHandler(handler any) (Handler, bool) {
 	switch h := handler.(type) {
-	case Handler:
+	case Handler: // (1) direct Fiber handler
 		if h == nil {
 			return nil, false
 		}
 		return h, true
-	case http.HandlerFunc:
+	case func(Ctx): // (2) Fiber handler without error return
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			h(c)
+			return nil
+		}, true
+	default:
+		return nil, false
+	}
+}
+
+func adaptExpressHandler(handler any) (Handler, bool) {
+	switch h := handler.(type) {
+	case func(Req, Res) error: // (3) Express-style handler with error return
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			return h(c.Req(), c.Res())
+		}, true
+	case func(Req, Res): // (4) Express-style handler without error return
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			h(c.Req(), c.Res())
+			return nil
+		}, true
+	case func(Req, Res, func() error) error: // (5) Express-style handler with error-returning next callback and error return
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			return h(c.Req(), c.Res(), func() error {
+				return c.Next()
+			})
+		}, true
+	case func(Req, Res, func() error): // (6) Express-style handler with error-returning next callback
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			var nextErr error
+			h(c.Req(), c.Res(), func() error {
+				nextErr = c.Next()
+				return nextErr
+			})
+			return nextErr
+		}, true
+	case func(Req, Res, func()) error: // (7) Express-style handler with no-arg next callback and error return
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			var nextErr error
+			err := h(c.Req(), c.Res(), func() {
+				nextErr = c.Next()
+			})
+			if err != nil {
+				return err
+			}
+			return nextErr
+		}, true
+	case func(Req, Res, func()): // (8) Express-style handler with no-arg next callback
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			var nextErr error
+			h(c.Req(), c.Res(), func() {
+				nextErr = c.Next()
+			})
+			return nextErr
+		}, true
+	default:
+		return nil, false
+	}
+}
+
+func adaptHTTPHandler(handler any) (Handler, bool) {
+	switch h := handler.(type) {
+	case http.HandlerFunc: // (9) net/http HandlerFunc
 		if h == nil {
 			return nil, false
 		}
 		return wrapHTTPHandler(h), true
-	case http.Handler:
+	case http.Handler: // (10) net/http Handler implementation
 		if h == nil {
 			return nil, false
 		}
@@ -35,19 +133,33 @@ func toFiberHandler(handler any) (Handler, bool) {
 			return nil, false
 		}
 		return wrapHTTPHandler(h), true
-	case func(http.ResponseWriter, *http.Request):
+	case func(http.ResponseWriter, *http.Request): // (11) net/http function handler
 		if h == nil {
 			return nil, false
 		}
 		return wrapHTTPHandler(http.HandlerFunc(h)), true
-	case fasthttp.RequestHandler:
+	default:
+		return nil, false
+	}
+}
+
+func adaptFastHTTPHandler(handler any) (Handler, bool) {
+	switch h := handler.(type) {
+	case fasthttp.RequestHandler: // (12) fasthttp handler
 		if h == nil {
 			return nil, false
 		}
 		return func(c Ctx) error {
 			h(c.RequestCtx())
 			return nil
 		}, true
+	case func(*fasthttp.RequestCtx) error: // (13) fasthttp handler with error return
+		if h == nil {
+			return nil, false
+		}
+		return func(c Ctx) error {
+			return h(c.RequestCtx())
+		}, true
 	default:
 		return nil, false
 	}