Add docs from gofiber/fiber@40a8c2c

Author: github-actions[bot]

docs/core/api/app.md

@@ -105,7 +105,7 @@ Mounting order is important for `MountPath`. To get mount paths properly, you sh
 You can group routes by creating a `*Group` struct.
 
 ```go title="Signature"
-func (app *App) Group(prefix string, handlers ...Handler) Router
+func (app *App) Group(prefix string, handlers ...any) Router
 ```
 
 ```go title="Example"
@@ -153,18 +153,18 @@ func (app *App) RouteChain(path string) Register
 
 ```go
 type Register interface {
-    All(handler Handler, handlers ...Handler) Register
-    Get(handler Handler, handlers ...Handler) Register
-    Head(handler Handler, handlers ...Handler) Register
-    Post(handler Handler, handlers ...Handler) Register
-    Put(handler Handler, handlers ...Handler) Register
-    Delete(handler Handler, handlers ...Handler) Register
-    Connect(handler Handler, handlers ...Handler) Register
-    Options(handler Handler, handlers ...Handler) Register
-    Trace(handler Handler, handlers ...Handler) Register
-    Patch(handler Handler, handlers ...Handler) Register
-
-    Add(methods []string, handler Handler, handlers ...Handler) Register
+    All(handler any, handlers ...any) Register
+    Get(handler any, handlers ...any) Register
+    Head(handler any, handlers ...any) Register
+    Post(handler any, handlers ...any) Register
+    Put(handler any, handlers ...any) Register
+    Delete(handler any, handlers ...any) Register
+    Connect(handler any, handlers ...any) Register
+    Options(handler any, handlers ...any) Register
+    Trace(handler any, handlers ...any) Register
+    Patch(handler any, handlers ...any) Register
+
+    Add(methods []string, handler any, handlers ...any) Register
 
     RouteChain(path string) Register
 }

docs/core/partials/routing/handler.md

@@ -27,20 +27,57 @@ func (app *App) Add(methods []string, path string, handler any, handlers ...any)
 func (app *App) All(path string, handler any, handlers ...any) Router
 ```
 
-Handlers can be native Fiber handlers (`func(fiber.Ctx) error`), familiar `net/http`
-shapes such as `http.Handler`, `http.HandlerFunc`, or
-`func(http.ResponseWriter, *http.Request)`, and even plain `fasthttp.RequestHandler`
-functions. Fiber automatically adapts supported handlers for you during registration.
+Fiber's adapter converts a variety of handler shapes to native
+`func(fiber.Ctx) error` callbacks. It currently recognizes thirteen cases (the
+numbers below match the comments in `toFiberHandler` inside `adapter.go`). This
+lets you mix Fiber-style handlers with Express-style callbacks and even reuse
+`net/http` or `fasthttp` functions.
+
+### Fiber-native handlers (cases 1–2)
+
+- **Case 1.** `fiber.Handler` — the canonical `func(fiber.Ctx) error` form.
+- **Case 2.** `func(fiber.Ctx)` — Fiber runs the function and treats it as if it
+  returned `nil`.
+
+### Express-style request handlers (cases 3–8)
+
+- **Case 3.** `func(fiber.Req, fiber.Res) error`
+- **Case 4.** `func(fiber.Req, fiber.Res)`
+- **Case 5.** `func(fiber.Req, fiber.Res, func() error) error`
+- **Case 6.** `func(fiber.Req, fiber.Res, func() error)`
+- **Case 7.** `func(fiber.Req, fiber.Res, func()) error`
+- **Case 8.** `func(fiber.Req, fiber.Res, func())`
+
+The adapter injects a `next` callback when your signature accepts one. Fiber
+propagates downstream errors from `c.Next()` back through the wrapper, so
+returning those errors remains optional. If you never call the injected `next`
+function, the handler chain stops, matching Express semantics.
+
+### net/http handlers (cases 9–11)
+
+- **Case 9.** `http.HandlerFunc`
+- **Case 10.** `http.Handler`
+- **Case 11.** `func(http.ResponseWriter, *http.Request)`
 
 :::caution Compatibility overhead
-Adapted `net/http` handlers execute through a compatibility layer. They don't receive
-`fiber.Ctx` or gain access to Fiber-specific APIs, and the conversion adds more
-overhead than running a native `fiber.Handler`. Because they cannot call `c.Next()`, they will also terminate the handler chain. Prefer Fiber handlers when you need the
-lowest latency or Fiber features.
+Fiber adapts these handlers through `fasthttpadaptor`. They do not receive
+`fiber.Ctx`, cannot call `c.Next()`, and therefore always terminate the handler
+chain. The compatibility layer also adds more overhead than running a native
+Fiber handler, so prefer the other forms when possible.
 :::
 
+### fasthttp handlers (cases 12–13)
+
+- **Case 12.** `fasthttp.RequestHandler`
+- **Case 13.** `func(*fasthttp.RequestCtx) error`
+
+fasthttp handlers run with full access to the underlying `fasthttp.RequestCtx`.
+They are expected to manage the response directly. Fiber will propagate any
+error returned by the `func(*fasthttp.RequestCtx) error` variant but otherwise
+does not inspect the context state.
+
 ```go title="Examples"
-// Simple GET handler
+// Simple GET handler (Fiber accepts both func(fiber.Ctx) and func(fiber.Ctx) error)
 app.Get("/api/list", func(c fiber.Ctx) error {
     return c.SendString("I'm a GET request!")
 })
@@ -52,6 +89,19 @@ httpHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
 app.Get("/foo", httpHandler)
 
+// Align with Express-style handlers using fiber.Req and fiber.Res helpers (works
+// for middleware and routes alike)
+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()
+})
+
+app.Get("/express", func(req fiber.Req, res fiber.Res) error {
+    return res.SendString("Hello from Express-style handlers!")
+})
+
 // Mount a fasthttp.RequestHandler directly
 app.Get("/bar", func(ctx *fasthttp.RequestCtx) {
     ctx.SetStatusCode(fiber.StatusAccepted)
@@ -70,13 +120,17 @@ Can be used for middleware packages and prefix catchers. Prefixes now require ei
 ```go title="Signature"
 func (app *App) Use(args ...any) Router
 
-// Different usage variations
-func (app *App) Use(handler Handler, handlers ...Handler) Router
-func (app *App) Use(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Use(paths []string, handler Handler, handlers ...Handler) Router
-func (app *App) Use(path string, app *App) Router
+// Fiber inspects args to support these common usage patterns:
+// - app.Use(handler, handlers ...any)
+// - app.Use(path string, handler, handlers ...any)
+// - app.Use(paths []string, handler, handlers ...any)
+// - app.Use(path string, subApp *App)
 ```
 
+Each handler argument can independently be a Fiber handler (with or without an
+`error` return), an Express-style callback, a `net/http` handler, or any other
+supported shape including fasthttp callbacks that return errors.
+
 ```go title="Examples"
 // Match any request
 app.Use(func(c fiber.Ctx) error {

docs/core/whats_new.md

@@ -303,6 +303,24 @@ We have slightly adapted our router interface
 
 Fiber now ships with a routing adapter (see `adapter.go`) that understands native Fiber handlers alongside `net/http` and `fasthttp` handlers. Route registration helpers accept a required `handler` argument plus optional additional `handlers`, all typed as `any`, and the adapter transparently converts supported handler styles so you can keep using the ecosystem functions you're familiar with.
 
+To align even closer with Express, you can also register handlers that accept the new `fiber.Req` and `fiber.Res` helper interfaces. The adapter understands both two-argument (`func(fiber.Req, fiber.Res)`) and three-argument (`func(fiber.Req, fiber.Res, func() error)`) callbacks, regardless of whether they return an `error`. When you include the optional `next` callback, Fiber wires it to `c.Next()` for you so middleware continues to behave as expected. If your handler returns an `error`, the value returned from the injected `next()` bubbles straight back to the caller. When your handler omits an `error` return, Fiber records the result of `next()` and returns it after your function exits so downstream failures still propagate.
+
+| Case | Handler signature | Notes |
+| ---- | ----------------- | ----- |
+| 1 | `fiber.Handler` | Native Fiber handler. |
+| 2 | `func(fiber.Ctx)` | Fiber handler without an error return. |
+| 3 | `func(fiber.Req, fiber.Res) error` | Express-style request handler with error return. |
+| 4 | `func(fiber.Req, fiber.Res)` | Express-style request handler without error return. |
+| 5 | `func(fiber.Req, fiber.Res, func() error) error` | Express-style middleware with an error-returning `next` callback and handler error return. |
+| 6 | `func(fiber.Req, fiber.Res, func() error)` | Express-style middleware with an error-returning `next` callback. |
+| 7 | `func(fiber.Req, fiber.Res, func()) error` | Express-style middleware with a no-argument `next` callback and handler error return. |
+| 8 | `func(fiber.Req, fiber.Res, func())` | Express-style middleware with a no-argument `next` callback. |
+| 9 | `http.HandlerFunc` | Standard-library handler function adapted through `fasthttpadaptor`. |
+| 10 | `http.Handler` | Standard-library handler implementation; pointer receivers must be non-nil. |
+| 11 | `func(http.ResponseWriter, *http.Request)` | Standard-library function handlers via `fasthttpadaptor`. |
+| 12 | `fasthttp.RequestHandler` | Direct fasthttp handler without error return. |
+| 13 | `func(*fasthttp.RequestCtx) error` | fasthttp handler that returns an error to Fiber. |
+
 ### Route chaining
 
 `RouteChain` is a new helper inspired by [`Express`](https://expressjs.com/en/api.html#app.route) that makes it easy to declare a stack of handlers on the same path, while the existing `Route` helper stays available for prefix encapsulation.