Fiber Framework Reference

1. App Setup & Routing

package main

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/logger"
    "github.com/gofiber/fiber/v2/middleware/recover"
)

func main() {
    app := fiber.New(fiber.Config{
        AppName:      "My API v1.0",
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        BodyLimit:    4 * 1024 * 1024, // 4MB
        ErrorHandler: customErrorHandler,
    })

    app.Use(logger.New())
    app.Use(recover.New())

    // Routes
    app.Get("/", func(c *fiber.Ctx) error {
        return c.JSON(fiber.Map{"hello": "world"})
    })

    // Route groups
    api := app.Group("/api/v1")
    api.Get("/articles", listArticles)
    api.Post("/articles", createArticle)
    api.Get("/articles/:id", getArticle)
    api.Put("/articles/:id", updateArticle)
    api.Delete("/articles/:id", deleteArticle)

    app.Listen(":8080")
}

2. ctx Methods

func handler(c *fiber.Ctx) error {
    // Request
    method := c.Method()        // "GET"
    path   := c.Path()          // "/articles/123"
    ip     := c.IP()            // client IP

    // Parameters
    id     := c.Params("id")   // path param
    page   := c.Query("page")  // query param
    page    = c.Query("page", "1")  // with default

    // Headers
    auth   := c.Get("Authorization")
    c.Set("X-Custom", "value")

    // Body binding
    type Req struct {
        Title string `json:"title"`
    }
    var req Req
    if err := c.BodyParser(&req); err != nil {
        return fiber.NewError(fiber.StatusBadRequest, err.Error())
    }

    // Locals (request-scoped values)
    c.Locals("user", currentUser)
    user := c.Locals("user").(*User)

    // Responses
    return c.JSON(fiber.Map{"ok": true})
    return c.SendString("hello")
    return c.SendStatus(fiber.StatusNoContent)
    return c.Redirect("/new-url", fiber.StatusMovedPermanently)
    return c.Download("./file.pdf", "document.pdf")
}

3. Middleware

import (
    "github.com/gofiber/fiber/v2/middleware/cors"
    "github.com/gofiber/fiber/v2/middleware/limiter"
    "github.com/gofiber/fiber/v2/middleware/compress"
    "github.com/gofiber/fiber/v2/middleware/requestid"
)

// CORS
app.Use(cors.New(cors.Config{
    AllowOrigins:     "https://app.example.com,https://admin.example.com",
    AllowMethods:     "GET,POST,PUT,DELETE,PATCH,OPTIONS",
    AllowHeaders:     "Authorization,Content-Type",
    AllowCredentials: true,
    MaxAge:           86400,
}))

// Rate limiting
app.Use(limiter.New(limiter.Config{
    Max:        100,
    Expiration: 1 * time.Minute,
    KeyGenerator: func(c *fiber.Ctx) string {
        return c.IP()
    },
    LimitReached: func(c *fiber.Ctx) error {
        return c.Status(429).JSON(fiber.Map{"error": "rate limit exceeded"})
    },
}))

// Compression + Request ID
app.Use(compress.New())
app.Use(requestid.New())

// Custom middleware
app.Use(func(c *fiber.Ctx) error {
    start := time.Now()
    err := c.Next()
    fmt.Printf("%s %s %d %v\n", c.Method(), c.Path(), c.Response().StatusCode(), time.Since(start))
    return err
})

4. JWT Middleware

import jwtware "github.com/gofiber/contrib/jwt"

// Apply JWT middleware to group
api.Use(jwtware.New(jwtware.Config{
    SigningKey:  jwtware.SigningKey{Key: []byte(os.Getenv("JWT_SECRET"))},
    ContextKey: "user",
    ErrorHandler: func(c *fiber.Ctx, err error) error {
        return c.Status(401).JSON(fiber.Map{"error": "invalid or expired token"})
    },
}))

// Extract claims in handler
func getMe(c *fiber.Ctx) error {
    token := c.Locals("user").(*jwt.Token)
    claims := token.Claims.(jwt.MapClaims)
    userID := claims["sub"].(string)
    return c.JSON(fiber.Map{"id": userID})
}

5. WebSocket

import "github.com/gofiber/contrib/websocket"

app.Use("/ws", func(c *fiber.Ctx) error {
    if websocket.IsWebSocketUpgrade(c) {
        return c.Next()
    }
    return fiber.ErrUpgradeRequired
})

app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) {
    roomID := c.Params("id")
    _ = roomID

    for {
        mt, msg, err := c.ReadMessage()
        if err != nil {
            break // connection closed
        }
        if err = c.WriteMessage(mt, msg); err != nil {
            break
        }
    }
}))

6. Built-in Middleware Reference