Fiber — API Surface#

fiber.New(config ...Config) *App
fiber.NewWithCustomCtx(newCtxFunc func(app *App) CustomCtx, config ...Config) *App

app.Use(args ...any) Router           // prefix-matched middleware; variadic to accept path + handlers or handlers only
app.Get(path string, handler any, handlers ...any) Router
app.Head(path string, handler any, handlers ...any) Router
app.Post(path string, handler any, handlers ...any) Router
app.Put(path string, handler any, handlers ...any) Router
app.Delete(path string, handler any, handlers ...any) Router
app.Connect(path string, handler any, handlers ...any) Router
app.Options(path string, handler any, handlers ...any) Router
app.Trace(path string, handler any, handlers ...any) Router
app.Patch(path string, handler any, handlers ...any) Router
app.Add(methods []string, path string, handler any, handlers ...any) Router
app.All(path string, handler any, handlers ...any) Router

app.Group(prefix string, handlers ...any) Router          // create a sub-router with a path prefix
app.Domain(host string) Router                            // create a sub-router scoped to a virtual host
app.Route(prefix string, fn func(router Router), ...) Router  // scoped block with a callback
app.RouteChain(path string) Register                      // fluent chain: .Get(h).Post(h).Delete(h)

app.RouteChain("/users").
    Get(listUsers).
    Post(createUser).
    RouteChain("/:id").
    Get(getUser).
    Put(updateUser).
    Delete(deleteUser)

app.Name(name string) Router                  // name the last registered route
app.GetRoute(name string) Route               // retrieve a route by name
app.GetRoutes(filterUseOption ...bool) []Route // list all routes
app.RemoveRoute(path string, methods ...string)
app.RemoveRouteByName(name string, methods ...string)
app.RemoveRouteFunc(matchFunc func(r *Route) bool, methods ...string)
app.RebuildTree() *App                        // hot-reload routes at runtime

app.RegisterCustomBinder(b CustomBinder)          // add a custom request decoder (e.g., protobuf)
app.RegisterCustomConstraint(c CustomConstraint)  // add a custom route parameter constraint
app.SetTLSHandler(h *TLSHandler)                  // attach TLS SNI handler
app.ReloadViews() error                            // reload template engine

app.Listen(addr string, config ...ListenConfig) error
app.Listener(ln net.Listener, config ...ListenConfig) error
app.Shutdown() error
app.ShutdownWithTimeout(d time.Duration) error
app.ShutdownWithContext(ctx context.Context) error
app.Server() *fasthttp.Server                      // direct access to underlying fasthttp server
app.Handler() fasthttp.RequestHandler              // underlying request handler (for embedding/testing)
app.Hooks() *Hooks                                 // lifecycle event subscriptions
app.State() *State                                 // app-wide key-value store
app.Stack() [][]*Route                             // registered routes
app.HandlersCount() uint32
app.Config() Config

app.Test(req *http.Request, config ...TestConfig) (*http.Response, error)

// Every middleware exposes exactly this signature:
func New(config ...Config) fiber.Handler

app.Use(middleware.New(middleware.Config{...}))    // global
app.Use("/api", middleware.New())                  // path-scoped
app.Get("/path", middleware1, middleware2, handler) // per-route inline

type Storage interface {
    Get(key string) ([]byte, error)
    Set(key string, val []byte, exp time.Duration) error
    Delete(key string) error
    Reset() error
    Close() error
}

// net/http → Fiber (embed existing handlers)
adaptor.HTTPHandler(h http.Handler) fiber.Handler
adaptor.HTTPHandlerFunc(h http.HandlerFunc) fiber.Handler
adaptor.HTTPMiddleware(mw func(http.Handler) http.Handler) fiber.Handler
adaptor.HTTPHandlerWithContext(h http.Handler) fiber.Handler  // with LocalContext

// Fiber → net/http (expose Fiber app as standard handler)
adaptor.FiberHandler(h fiber.Handler) http.Handler
adaptor.FiberHandlerFunc(h fiber.Handler) http.HandlerFunc
adaptor.FiberApp(app *fiber.App) http.HandlerFunc

// Utilities
adaptor.ConvertRequest(c fiber.Ctx, forServer bool) (*http.Request, error)
adaptor.LocalContextFromHTTPRequest(r *http.Request) (context.Context, bool)

c := client.New()            // fresh client
c.SetBaseURL("https://api.example.com")
c.SetJSONMarshal(sonic.Marshal)  // swap JSON codec
c.AddRequestHook(...)
c.AddResponseHook(...)
c.SetRetryConfig(&RetryConfig{MaxRetries: 3, RetryIf: ...})

resp, err := c.R().
    SetHeader("Authorization", "Bearer "+token).
    SetJSON(payload).          // or SetXML / SetCBOR / SetForm / SetRawBody
    Post("https://api.example.com/users")

c.Get(url, cfg ...Config) (*Response, error)
c.Post(url, cfg ...Config) (*Response, error)
c.Put(url, cfg ...Config) (*Response, error)
c.Patch(url, cfg ...Config) (*Response, error)
c.Delete(url, cfg ...Config) (*Response, error)
c.Head(url, cfg ...Config) (*Response, error)
c.Options(url, cfg ...Config) (*Response, error)

resp.Body() []byte
resp.JSON(v any) error
resp.XML(v any) error
resp.CBOR(v any) error
resp.Status() string
resp.StatusCode() int
resp.Header(key string) string
resp.Cookies() []*fasthttp.Cookie
resp.Close()

extractors.FromAuthHeader("Bearer")         // Authorization: Bearer <token>
extractors.FromCookie("session_token")
extractors.FromParam("api_key")             // URL parameter
extractors.FromForm("token")
extractors.FromHeader("X-API-Key")
extractors.FromQuery("api_key")
extractors.FromCustom("name", func(c fiber.Ctx) (string, error) { ... })
extractors.Chain(e1, e2, e3)               // try in order, return first success

type Logger interface      { Trace/Debug/Info/Warn/Error/Fatal/Panic (msg, keysAndValues...) }
type FormatLogger interface { Tracef/Debugf/.../Panicf }
type WithLogger interface   { WithContext(ctx) CommonLogger }
type CommonLogger interface  // composes Logger + FormatLogger
type AllLogger[T any] interface  // composes everything + SetLevel + SetOutput

eb := retry.NewExponentialBackoff(retry.Config{
    InitialInterval: 500 * time.Millisecond,
    MaxInterval:     2 * time.Second,
    MaxElapsedTime:  10 * time.Second,
    Multiplier:      2.0,
})
err := eb.Retry(func() error {
    return callExternalService()
})