Learning Fiber - Breaking Changes and Migration from v2

#Introduction

Fiber v3 brings many improvements, but also changes that break compatibility with v2. Episode 11 summarizes the most important breaking changes and how to migrate existing applications — especially if you've ever used Fiber v2.

The good news: most of the core API stays the same. The changes that exist mostly simplify how routes are written and are consistent with the middleware-side updates. With this list, migration can be done gradually without rewriting everything.

#Major Routing Changes

#Variadic Handlers for Registering Routes

The most visible change: route methods now accept ...any, so you can register many routes in one call:

app.Get("/:id", handler)                       // v2
app.Get("/:id", handler)                       // v3
app.Get("/:id", handler, "user/:id", handler2) // v3: banyak route

In v3, strings can be inserted between handlers to start a new route. Ordinary handler behavior is unchanged, so v2 code still runs. What's new is the ability to register several routes at once.

#The Use and Add Methods

app.Use and app.Add in v3 accept variadic parameters with new rules. Middleware called with a path prefix changes its behavior:

app.Use("/user/:id", middleware) // v3: path parameter didukung

app.Use("/user/:id", middleware) now supports path parameters on the prefix — in v2 only static paths. This lets middleware filter requests based on parameter values in its path, not just a literal prefix.

#Context Changes

#Accessing the Response Body

The way to read the response body changed. The body must be read from the pointer c.Response().Body(), which points to a response object:

body := string(c.Response().Body())
fmt.Println(body)

In v2 c.Response().Body() returned a byte slice; in v3 it returns a pointer to the response object, so it needs dereferencing. This affects middleware that reads responses — for example for body logging or caching.

#Request Body vs c.Body

Fiber v3 more strictly distinguishes the raw request body from the parsing result:

raw := c.Request().Body()   // []byte mentah dari request
parsed := c.Body()          // body setelah diproses

c.Request().Body() returns the raw body; c.Body() returns the body after Fiber processes it. If a handler rewrites the request body, the values of c.Body() and c.Request().Body() can differ.

#Middleware Changes

#The Adaptor and Other Middleware

Some middleware changed along with the new API. The most visible examples are the adaptor and CSRF packages:

app.Use(csrf.New(csrf.Config{
    KeyLookup: "header:X-CSRF-Token",
    ErrorHandler: func(c fiber.Ctx, err error) error {
        return c.Status(fiber.StatusForbidden).JSON(fiber.Map{
            "error": err.Error(),
        })
    },
}))

csrf.Config now uses ErrorHandler func(c, error) — a sign of the error handling pattern change across many middleware. When migrating, check the docs page of each middleware you use: some changed field names or handler signatures.

#Taking Advantage of New Features

#Example: Variadic Routes

One benefit of migrating is the features that didn't exist in v2. For example variadic routes:

app.Get("/a", handlerA, "b", handlerB)

One call registers two routes at once. Other v3-only features — route constraints like :id<int>, domain routing, and route chaining — can simplify code that used to be convoluted. Apply new features after the basic migration is complete, not in the middle of it.

#Migration Strategy

#Gradual Steps

go get github.com/gofiber/fiber/v3@latest

Recommended steps: 1) update the fiber version in go.mod, 2) run go vet and build to find compilation errors, 3) fix response body access that changed to a pointer, 4) adjust the middleware you use — starting with adaptor and CSRF, 5) use new features like variadic handlers gradually, 6) rerun the entire test suite.

#Closing

Key takeaways:

• Variadic ...any on route methods allows many routes in one call.
• app.Use("/user/:id", middleware) supports path parameters in v3.
• c.Response().Body() now returns a pointer and needs dereferencing.
• c.Request().Body() (raw) differs from c.Body() (processed).
• Some middleware, like CSRF, changed their config and error handler signatures.
• Migrate gradually: update the version, fix compilation, adjust middleware, then test.

In the next episode, episode 12, we discuss performance tips and best practices — tied to template rendering with github.com/gofiber/template and how to serve public asset files and folders.