Add docs from gofiber/fiber@2c43a0f

Author: github-actions[bot]

docs/core/extra/faq.md

@@ -177,7 +177,19 @@ For more information, see issue [#750](https://github.com/gofiber/fiber/issues/7
 
 ## How can I handle conversions between Fiber and net/http?
 
-The `adaptor` middleware provides utilities for converting between Fiber and `net/http`. It allows seamless integration of `net/http` handlers, middleware, and requests into Fiber applications, and vice versa.
+Fiber can register common `net/http` handlers directly—just pass an
+`http.Handler`, `http.HandlerFunc`, compatible function, or even a native
+`fasthttp.RequestHandler` to your routing method. For other interoperability scenarios, the `adaptor` middleware provides
+utilities for converting between Fiber and `net/http`. It allows seamless
+integration of `net/http` handlers, middleware, and requests into Fiber
+applications, and vice versa.
+
+:::caution Performance trade-offs
+Converted `net/http` handlers run through a compatibility layer. They won't expose
+`fiber.Ctx` or Fiber-specific helpers, and the extra adaptation work makes them slower
+than native Fiber handlers. Use them when interoperability matters, but prefer Fiber
+handlers for maximum performance.
+:::
 
 For details on how to:
 

docs/core/middleware/adaptor.md

@@ -6,6 +6,21 @@ id: adaptor
 
 The `adaptor` package converts between Fiber and `net/http`, letting you reuse handlers, middleware, and requests across both frameworks.
 
+:::tip
+Fiber can register plain `net/http` handlers directly—just pass an `http.Handler`,
+`http.HandlerFunc`, or `func(http.ResponseWriter, *http.Request)` to any router
+method and it will be adapted automatically. The adaptor helpers remain valuable
+when you need to convert middleware, swap handler directions, or transform
+requests explicitly.
+:::
+
+:::caution Fiber features are unavailable
+Even when you register them directly, adapted `net/http` handlers still run with standard
+library semantics. They don't have access to `fiber.Ctx`, and the compatibility layer comes
+with additional overhead compared to native Fiber handlers. Use them for interop and legacy
+scenarios, but prefer Fiber handlers when performance or Fiber-specific APIs matter.
+:::
+
 ## Features
 
 - Convert `net/http` handlers and middleware to Fiber handlers
@@ -31,7 +46,8 @@ The `adaptor` package converts between Fiber and `net/http`, letting you reuse h
 
 ### 1. Using `net/http` handlers in Fiber
 
-This example shows how to run a standard `net/http` handler within a Fiber app:
+This example shows how to run a standard `net/http` handler within a Fiber app
+without calling the adaptor explicitly:
 
 ```go
 package main
@@ -40,14 +56,13 @@ import (
     "fmt"
     "net/http"
     "github.com/gofiber/fiber/v3"
-    "github.com/gofiber/fiber/v3/middleware/adaptor"
 )
 
 func main() {
     app := fiber.New()
 
-    // Convert an http.Handler to a Fiber handler
-    app.Get("/", adaptor.HTTPHandler(http.HandlerFunc(helloHandler)))
+    // Fiber adapts net/http handlers for you during registration
+    app.Get("/", http.HandlerFunc(helloHandler))
 
     app.Listen(":3000")
 }
@@ -57,6 +72,14 @@ func helloHandler(w http.ResponseWriter, r *http.Request) {
 }
 ```
 
+If you prefer to reuse the converted handler in multiple places, you can still
+obtain it manually via `github.com/gofiber/fiber/v3/middleware/adaptor`:
+
+```go
+converted := adaptor.HTTPHandler(http.HandlerFunc(helloHandler))
+app.Get("/cached", converted)
+```
+
 ### 2. Using `net/http` middleware with Fiber
 
 Middleware written for `net/http` can run inside Fiber:

docs/core/partials/routing/handler.md

@@ -9,30 +9,54 @@ Registers a route bound to a specific [HTTP method](https://developer.mozilla.or
 
 ```go title="Signatures"
 // HTTP methods
-func (app *App) Get(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Head(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Post(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Put(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Delete(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Connect(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Options(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Trace(path string, handler Handler, handlers ...Handler) Router
-func (app *App) Patch(path string, handler Handler, handlers ...Handler) Router
-
-// Add allows you to specify a method as value
-func (app *App) Add(method, path string, handler Handler, handlers ...Handler) Router
+func (app *App) Get(path string, handler any, handlers ...any) Router
+func (app *App) Head(path string, handler any, handlers ...any) Router
+func (app *App) Post(path string, handler any, handlers ...any) Router
+func (app *App) Put(path string, handler any, handlers ...any) Router
+func (app *App) Delete(path string, handler any, handlers ...any) Router
+func (app *App) Connect(path string, handler any, handlers ...any) Router
+func (app *App) Options(path string, handler any, handlers ...any) Router
+func (app *App) Trace(path string, handler any, handlers ...any) Router
+func (app *App) Patch(path string, handler any, handlers ...any) Router
+
+// Add allows you to specify multiple methods at once
+func (app *App) Add(methods []string, path string, handler any, handlers ...any) Router
 
 // All will register the route on all HTTP methods
 // Almost the same as app.Use but not bound to prefixes
-func (app *App) All(path string, handler Handler, handlers ...Handler) Router
+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.
+
+:::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.
+:::
+
 ```go title="Examples"
 // Simple GET handler
 app.Get("/api/list", func(c fiber.Ctx) error {
     return c.SendString("I'm a GET request!")
 })
 
+// Reuse an existing net/http handler without manual adaptation
+httpHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    w.WriteHeader(http.StatusNoContent)
+})
+
+app.Get("/foo", httpHandler)
+
+// Mount a fasthttp.RequestHandler directly
+app.Get("/bar", func(ctx *fasthttp.RequestCtx) {
+    ctx.SetStatusCode(fiber.StatusAccepted)
+})
+
 // Simple POST handler
 app.Post("/api/register", func(c fiber.Ctx) error {
     return c.SendString("I'm a POST request!")

docs/core/whats_new.md

@@ -299,36 +299,13 @@ app.Listen("app.sock", fiber.ListenerConfig{
 
 We have slightly adapted our router interface
 
-### HTTP method registration
+### Handler compatibility
 
-In `v2` one handler was already mandatory when the route has been registered, but this was checked at runtime and was not correctly reflected in the signature, this has now been changed in `v3` to make it more explicit.
-
-```diff
--    Get(path string, handlers ...Handler) Router
-+    Get(path string, handler Handler, middleware ...Handler) Router
--    Head(path string, handlers ...Handler) Router
-+    Head(path string, handler Handler, middleware ...Handler) Router
--    Post(path string, handlers ...Handler) Router
-+    Post(path string, handler Handler, middleware ...Handler) Router
--    Put(path string, handlers ...Handler) Router
-+    Put(path string, handler Handler, middleware ...Handler) Router
--    Delete(path string, handlers ...Handler) Router
-+    Delete(path string, handler Handler, middleware ...Handler) Router
--    Connect(path string, handlers ...Handler) Router
-+    Connect(path string, handler Handler, middleware ...Handler) Router
--    Options(path string, handlers ...Handler) Router
-+    Options(path string, handler Handler, middleware ...Handler) Router
--    Trace(path string, handlers ...Handler) Router
-+    Trace(path string, handler Handler, middleware ...Handler) Router
--    Patch(path string, handlers ...Handler) Router
-+    Patch(path string, handler Handler, middleware ...Handler) Router
--    All(path string, handlers ...Handler) Router
-+    All(path string, handler Handler, middleware ...Handler) Router
-```
+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.
 
 ### Route chaining
 
-This release introduces a dedicated `RouteChain` helper, inspired by [`Express`](https://expressjs.com/en/api.html#app.route), for declaring a stack of handlers on the same path. The original `Route` helper for prefix encapsulation also remains available.
+`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.
 
 ```go
 RouteChain(path string) Register
@@ -394,7 +371,7 @@ To enable the routing changes above we had to slightly adjust the signature of t
 
 ```diff
 -    Add(method, path string, handlers ...Handler) Router
-+    Add(methods []string, path string, handler Handler, middleware ...Handler) Router
++    Add(methods []string, path string, handler any, handlers ...any) Router
 ```
 
 ### Test Config
@@ -1652,6 +1629,30 @@ app.Listen(":3000", fiber.ListenConfig{
 
 ### 🗺 Router
 
+#### Direct `net/http` handlers
+
+Route registration helpers now accept native `net/http` handlers. Pass an
+`http.Handler`, `http.HandlerFunc`, or compatible function directly to methods
+such as `app.Get`, `Group`, or `RouteChain` and Fiber will adapt it at
+registration time. Manual wrapping through the adaptor middleware is no longer
+required for these common cases.
+
+:::note Compatibility considerations
+Adapted handlers stick to `net/http` semantics. They do not interact with `fiber.Ctx`
+and are slower than native Fiber handlers because of the extra conversion layer. Use
+them to ease migrations, but prefer Fiber handlers in performance-critical paths.
+:::
+
+```go
+httpHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    if _, err := w.Write([]byte("served by net/http")); err != nil {
+        panic(err)
+    }
+})
+
+app.Get("/", httpHandler)
+```
+
 #### Middleware Registration
 
 The signatures for [`Add`](#middleware-registration) and [`Route`](#route-chaining) have been changed.