docs/whats_new.md (1)

491-496: Polish phrasing of new Ctx helpers (and align with code semantics).

Minor grammar/style tweaks and clarify IsMiddleware intent. Also addresses the linter hint.

- - **Matched**: Detects when the current request path matched a registered route.
- - **IsMiddleware**: Indicates if the current handler was registered as middleware.
- - **HasBody**: Quickly checks whether the request includes a body.
- - **IsWebSocket**: Reports if the request attempts a WebSocket upgrade.
- - **IsPreflight**: Identifies CORS preflight requests before handlers run.
+ - **Matched**: Returns true when the current request path was matched by the router.
+ - **IsMiddleware**: Returns true if the current handler comes from a middleware route (registered via `app.Use`).
+ - **HasBody**: Returns true if the request includes a body.
+ - **IsWebSocket**: Returns true if the request attempts a WebSocket upgrade.
+ - **IsPreflight**: Returns true for CORS preflight requests.

ctx.go (4)

309-313: IsMiddleware(): clarify semantics vs route-level middleware.

This reports true only for routes registered via App.Use (c.route.use). Route-level middleware attached to a non-use route will return false, which is fine if that’s the intended contract. Consider reflecting that nuance in the function comment (and docs) to avoid confusion.

Apply the same docstring refinement suggested in ctx_interface_gen.go.

---

314-321: HasBody(): acceptable heuristic.

Content-Length > 0 OR non-empty body covers common cases. If you want to avoid touching the body buffer when CL is unknown (chunked), you could first check Transfer-Encoding, but this is optional.

---

322-330: IsWebSocket(): solid header checks; minor micro-optimization optional.

Logic matches the typical handshake. Optional: avoid an allocation from ToLowerBytes by scanning for 'u'/'U' and comparing case-insensitively, but readability likely wins here.

---

331-335: IsPreflight(): consider requiring Origin header to avoid false positives.

Per CORS, preflights are OPTIONS requests with both Origin and Access-Control-Request-Method. Tightening the check reduces accidental matches from generic OPTIONS requests.

-func (c *DefaultCtx) IsPreflight() bool {
-	return c.Method() == MethodOptions && len(c.fasthttp.Request.Header.Peek(HeaderAccessControlRequestMethod)) > 0
-}
+func (c *DefaultCtx) IsPreflight() bool {
+	if c.Method() != MethodOptions {
+		return false
+	}
+	hdr := &c.fasthttp.Request.Header
+	if len(hdr.Peek(HeaderAccessControlRequestMethod)) == 0 {
+		return false
+	}
+	// Guard on Origin to align with CORS preflight semantics
+	return len(hdr.Peek(HeaderOrigin)) > 0
+}

ctx_test.go (5)

4931-4955: Matched(): add an after-Next assertion to exercise both matched and 404 paths

Exercise Matched() from middleware after c.Next() to confirm true on matched routes and false on 404s.

   app.Get("/two", func(c Ctx) error {
     return c.SendStatus(StatusOK)
   })

+  // Assert Matched() after the downstream chain has executed
+  app.Use(func(c Ctx) error {
+    err := c.Next()
+    if c.Response().StatusCode() == StatusNotFound {
+      require.False(t, c.Matched(), "Matched() should be false on 404")
+    } else {
+      require.True(t, c.Matched(), "Matched() should be true when a route matched")
+    }
+    return err
+  })
+
   app.Use(func(c Ctx) error {
     require.False(t, c.Matched())
     return c.Status(StatusNotFound).SendString("not found")
   })

---

4957-4973: Nit: assert error handler body

Also assert the body content to fully specify behavior.

   resp, err := app.Test(httptest.NewRequest(MethodGet, "/", nil))
   require.NoError(t, err)
   require.Equal(t, StatusNotFound, resp.StatusCode)
+  b, _ := io.ReadAll(resp.Body)
+  require.Equal(t, "Not Found", string(b))

---

5017-5037: HasBody: add Content-Length: 0 case

Guard against regressions where zero length is treated as present.

   require.True(t, ctxWithHeader.HasBody())

+  ctxZero := app.AcquireCtx(&fasthttp.RequestCtx{})
+  require.NotNil(t, ctxZero)
+  t.Cleanup(func() { app.ReleaseCtx(ctxZero) })
+  ctxZero.Request().Header.SetContentLength(0)
+  require.False(t, ctxZero.HasBody())
+
   ctxWithoutBody := app.AcquireCtx(&fasthttp.RequestCtx{})

---

5039-5054: IsWebSocket: add case-insensitivity and multi-token Connection

Increase robustness of the check.

   require.True(t, ws.IsWebSocket())

+  ws2 := app.AcquireCtx(&fasthttp.RequestCtx{})
+  require.NotNil(t, ws2)
+  t.Cleanup(func() { app.ReleaseCtx(ws2) })
+  ws2.Request().Header.Set(HeaderConnection, "keep-alive, Upgrade")
+  ws2.Request().Header.Set(HeaderUpgrade, "WebSocket")
+  require.True(t, ws2.IsWebSocket())
+
   non := app.AcquireCtx(&fasthttp.RequestCtx{})

---

5056-5074: IsPreflight: add non-OPTIONS guard

Preflight must be OPTIONS even if ACRM is present.

   require.True(t, pre.IsPreflight())

+  notOpt := &fasthttp.RequestCtx{}
+  notOpt.Request.Header.SetMethod(MethodGet)
+  notOpt.Request.Header.Set(HeaderAccessControlRequestMethod, MethodGet)
+  pre2 := app.AcquireCtx(notOpt)
+  require.NotNil(t, pre2)
+  t.Cleanup(func() { app.ReleaseCtx(pre2) })
+  require.False(t, pre2.IsPreflight())
+
   optCtx := &fasthttp.RequestCtx{}

docs/api/ctx.md (4)

387-403: Clarify when to use Matched() vs Route()

Explicitly call out safe usage timing relative to Next().

 ### Matched

-Returns `true` if the current request path was matched by the router.
+Returns `true` if the current request path was matched by the router.
+Note: Unlike c.Route(), Matched() can be called in middleware before c.Next().

---

419-435: HasBody: document zero-length behavior

Tiny clarification improves predictability.

 ### HasBody

-Returns `true` if the incoming request contains a body or a `Content-Length` header greater than zero.
+Returns `true` if the incoming request contains a body or a `Content-Length` header greater than zero. Returns `false` when `Content-Length` is `0`.

---

444-451: IsWebSocket example: avoid calling Next() from a terminal handler

Use a simple OK to keep the example minimal and accurate.

 app.Get("/", func(c fiber.Ctx) error {
   if c.IsWebSocket() {
     // handle websocket
   }
-  return c.Next()
+  return c.Status(fiber.StatusOK).SendString("OK")
 })

---

453-469: IsPreflight: emphasize both conditions

Minor wording tweak for clarity.

-Returns `true` if the request is a CORS preflight (`OPTIONS` + `Access-Control-Request-Method`).
+Returns `true` only if the request is a CORS preflight (`OPTIONS` method and an `Access-Control-Request-Method` header).

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: gaby
PR: gofiber/fiber#3193
File: middleware/adaptor/adaptor.go:111-111
Timestamp: 2024-11-10T23:44:13.704Z
Learning: In the `middleware/adaptor/adaptor.go` file of the Fiber framework, when updating context handling, replacing `c.Context()` with `c.RequestCtx()` is appropriate to access the `fasthttp.RequestCtx`.

Learnt from: gaby
PR: gofiber/fiber#3193
File: middleware/cache/cache_test.go:897-897
Timestamp: 2024-11-08T04:10:42.990Z
Learning: In the Fiber framework, `Context()` is being renamed to `RequestCtx()`, and `UserContext()` to `Context()` to improve clarity and align with Go's context conventions.

ctx.go (1)

321-327: Simplify HasBody() to a single return.

Minor readability win; same behavior.

Apply this diff:

 func (c *DefaultCtx) HasBody() bool {
-	if c.fasthttp.Request.Header.ContentLength() > 0 {
-		return true
-	}
-	return len(c.fasthttp.Request.Body()) > 0
+	return c.fasthttp.Request.Header.ContentLength() > 0 ||
+		len(c.fasthttp.Request.Body()) > 0
 }

ctx.go (1)

345-355: IsPreflight(): logic is correct; optional micro-tweak.

Consider hoisting the header pointer here as well (matches IsWebSocket style) for tiny clarity/consistency.

Apply this diff:

 func (c *DefaultCtx) IsPreflight() bool {
 	if c.Method() != MethodOptions {
 		return false
 	}
-	hdr := &c.fasthttp.Request.Header
+	hdr := &c.fasthttp.Request.Header
 	if len(hdr.Peek(HeaderAccessControlRequestMethod)) == 0 {
 		return false
 	}
 	return len(hdr.Peek(HeaderOrigin)) > 0
 }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: gaby
PR: gofiber/fiber#3193
File: middleware/adaptor/adaptor.go:111-111
Timestamp: 2024-11-10T23:44:13.704Z
Learning: In the `middleware/adaptor/adaptor.go` file of the Fiber framework, when updating context handling, replacing `c.Context()` with `c.RequestCtx()` is appropriate to access the `fasthttp.RequestCtx`.