ctx.go (2)

1563-1566: Clarify documentation about Link header handling.

The documentation states "Only Link headers already written to the response will be transmitted as Early Hints" but the implementation actually adds the provided hints as Link headers first (line 1575), then calls EarlyHints(). This seems inconsistent.

Consider updating the documentation to accurately reflect the implementation:

-// SendEarlyHints allows the server to hint to the browser what resources a page would need
-// so the browser can preload them while waiting for the server's full response. Only Link
-// headers already written to the response will be transmitted as Early Hints.
+// SendEarlyHints allows the server to hint to the browser what resources a page would need
+// so the browser can preload them while waiting for the server's full response. The provided
+// hints are added as Link headers to the response before transmitting the Early Hints.

---

1573-1578: Consider adding input validation for better robustness.

The method doesn't validate the input hints slice or individual hint formats. While the underlying fasthttp library may handle some edge cases, adding basic validation would improve robustness and provide clearer error messages.

Consider adding input validation:

 func (c *DefaultCtx) SendEarlyHints(hints []string) error {
+	if len(hints) == 0 {
+		return nil // No hints to send
+	}
 	for _, h := range hints {
+		if h == "" {
+			continue // Skip empty hints
+		}
 		c.fasthttp.Response.Header.Add("Link", h)
 	}
 	return c.fasthttp.EarlyHints()
 }

Alternatively, you could validate Link header format according to RFC 8288 if stricter validation is desired.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

ctx_test.go:3113

• Consider adding additional test cases with multiple early hints to ensure that all Link headers are correctly processed, including scenarios with duplicates or a mixture of different hint strings.

err := c.SendEarlyHints([]string{"<https://cdn.com>; rel=preload; as=script"})

ctx_test.go (1)

3114-3114: ⚠️ Potential issue

Fix error handling for SendEarlyHints call.

The error return value from c.SendEarlyHints(hints) is not being checked, which violates Go best practices and triggers static analysis warnings.

Apply this fix:

-		c.SendEarlyHints(hints)
+		err := c.SendEarlyHints(hints)
+		if err != nil {
+			return err
+		}

ctx_test.go (1)

3122-3123: Remove debug print statements.

These debug print statements should be removed from the test as they add noise to test output.

-	fmt.Println(resp.StatusCode)
-	fmt.Println(resp.Header)
-

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

app_test.go (1)

1762-1781: Good test coverage for the Early Hints feature.

The test effectively validates the integration between SendEarlyHints and the modified Test method. It properly:

• Tests the happy path scenario with Link headers
• Verifies that early hints are preserved in the final response
• Confirms the final response status and body are correct
• Uses appropriate assertions with proper error handling

The test follows established patterns in the file and provides good coverage for the basic functionality.

Consider adding additional test cases to enhance coverage:

func Test_App_Test_EarlyHints_Multiple(t *testing.T) {
    t.Parallel()
    
    app := New()
    app.Get("/multiple", func(c Ctx) error {
        c.SendEarlyHints([]string{"<https://cdn.com>; rel=preload; as=script"})
        c.SendEarlyHints([]string{"<https://fonts.com>; rel=preload; as=font"})
        return c.Status(StatusOK).SendString("done")
    })
    
    req := httptest.NewRequest(MethodGet, "/multiple", nil)
    resp, err := app.Test(req)
    
    require.NoError(t, err)
    require.Equal(t, StatusOK, resp.StatusCode)
    // Verify multiple Link headers are combined
    require.Len(t, resp.Header["Link"], 2)
}

func Test_App_Test_EarlyHints_Error_After_Hints(t *testing.T) {
    t.Parallel()
    
    app := New()
    app.Get("/error", func(c Ctx) error {
        c.SendEarlyHints([]string{"<https://cdn.com>; rel=preload; as=script"})
        return c.Status(StatusBadRequest).SendString("error")
    })
    
    req := httptest.NewRequest(MethodGet, "/error", nil)
    resp, err := app.Test(req)
    
    require.NoError(t, err)
    require.Equal(t, StatusBadRequest, resp.StatusCode)
    // Verify early hints are still present even with error response
    require.NotEmpty(t, resp.Header["Link"])
}

These additional tests would provide more comprehensive coverage of edge cases and multiple early hints scenarios.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: ReneWerner87
PR: gofiber/fiber#0
File: :0-0
Timestamp: 2024-12-01T10:28:36.011Z
Learning: Feature request #3224 has been created to add support for square bracket notation and comma-separated values in multipart form data in Fiber, while maintaining binary data transfer capabilities. This would bring parity with the existing form-urlencoded functionality.

Learnt from: ReneWerner87
PR: gofiber/fiber#3161
File: app.go:923-932
Timestamp: 2024-11-15T07:56:21.623Z
Learning: In the Fiber framework, breaking changes are acceptable when moving from version 2 to version 3, including modifications to method signatures such as in the `Test` method in `app.go`.

Learnt from: efectn
PR: gofiber/fiber#3162
File: app_test.go:893-895
Timestamp: 2024-11-29T12:37:27.581Z
Learning: In the `Test_App_ShutdownWithContext` function in `app_test.go`, the `clientDone` channel is used to synchronize the client's request completion before proceeding, eliminating the need for additional `time.Sleep` calls.

Learnt from: sixcolors
PR: gofiber/fiber#3016
File: middleware/csrf/csrf_test.go:188-193
Timestamp: 2024-10-08T19:06:06.583Z
Learning: In the Fiber framework tests, using `ctx.Response.Header.Cookie` may not be suitable for parsing cookies from the response header, as it requires a `*Cookie` and fills it rather than returning a string value; thus, manual parsing of the `Set-Cookie` header may be necessary.

Learnt from: sixcolors
PR: gofiber/fiber#3016
File: middleware/csrf/csrf_test.go:188-193
Timestamp: 2024-09-25T15:57:10.221Z
Learning: In the Fiber framework tests, using `ctx.Response.Header.Cookie` may not be suitable for parsing cookies from the response header, as it requires a `*Cookie` and fills it rather than returning a string value; thus, manual parsing of the `Set-Cookie` header may be necessary.

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: ReneWerner87
PR: gofiber/fiber#3161
File: app.go:923-932
Timestamp: 2024-11-15T07:56:21.623Z
Learning: In the Fiber framework, breaking changes are acceptable when moving from version 2 to version 3, including modifications to method signatures such as in the `Test` method in `app.go`.

Learnt from: efectn
PR: gofiber/fiber#3162
File: app_test.go:893-895
Timestamp: 2024-11-29T12:37:27.581Z
Learning: In the `Test_App_ShutdownWithContext` function in `app_test.go`, the `clientDone` channel is used to synchronize the client's request completion before proceeding, eliminating the need for additional `time.Sleep` calls.

Learnt from: ReneWerner87
PR: gofiber/fiber#3161
File: app.go:923-932
Timestamp: 2024-11-15T07:56:21.623Z
Learning: In the Fiber framework, breaking changes are acceptable when moving from version 2 to version 3, including modifications to method signatures such as in the `Test` method in `app.go`.

Learnt from: efectn
PR: gofiber/fiber#3162
File: app_test.go:893-895
Timestamp: 2024-11-29T12:37:27.581Z
Learning: In the `Test_App_ShutdownWithContext` function in `app_test.go`, the `clientDone` channel is used to synchronize the client's request completion before proceeding, eliminating the need for additional `time.Sleep` calls.

Learnt from: sixcolors
PR: gofiber/fiber#3016
File: middleware/session/middleware_test.go:400-407
Timestamp: 2024-09-25T17:09:03.756Z
Learning: In the `Test_Session_Next` function in `middleware/session/middleware_test.go`, the variable `doNext` is properly synchronized with the `muNext` mutex for both read and write access.

Learnt from: sixcolors
PR: gofiber/fiber#3051
File: middleware/session/session.go:215-216
Timestamp: 2024-10-08T19:06:06.583Z
Learning: Parallel tests for `Session.Save` already exist in the `middleware/session/session_test.go` file, specifically in the `Test_Session_Save` and `Test_Session_Save_Expiration` functions.

Learnt from: sixcolors
PR: gofiber/fiber#3051
File: middleware/session/session.go:215-216
Timestamp: 2024-06-30T00:38:06.580Z
Learning: Parallel tests for `Session.Save` already exist in the `middleware/session/session_test.go` file, specifically in the `Test_Session_Save` and `Test_Session_Save_Expiration` functions.

res.go (2)

695-699: Prefer using Res/RequestCtx accessors + HeaderLink constant; short-circuit empty hints.

Improves encapsulation, consistency with surrounding code, and avoids emitting a bare 103 without Link values.

 func (r *DefaultRes) SendEarlyHints(hints []string) error {
-	for _, h := range hints {
-		r.c.fasthttp.Response.Header.Add("Link", h)
-	}
-	return r.c.fasthttp.EarlyHints()
+	if len(hints) == 0 {
+		return nil
+	}
+	for _, h := range hints {
+		r.Response().Header.Add(HeaderLink, h)
+	}
+	return r.RequestCtx().EarlyHints()
 }

---

688-691: Doc nit: clarify protocol wording.

“HTTP/2+” is vague. Suggest “HTTP/2 or HTTP/3” and explicitly note that some HTTP/1.1 non-browser clients may ignore interim responses.

-// This is a HTTP/2+ feature but all browsers will either understand it or safely ignore it.
+// Early Hints are primarily effective with HTTP/2 or HTTP/3. Modern browsers understand them,
+// while older clients will safely ignore interim 1xx responses.

ctx_test.go (2)

3869-3878: Close response body and use Header.Values for robustness.

Avoids resource leaks and tolerates header coalescing behavior.

 req := httptest.NewRequest(MethodGet, "/earlyhints", nil)
 resp, err := app.Test(req)
 
 require.NoError(t, err, "app.Test(req)")
+defer func() { require.NoError(t, resp.Body.Close()) }()
 require.Equal(t, StatusBadRequest, resp.StatusCode, "Status code")
-require.Equal(t, hints, resp.Header["Link"], "Link header")
+require.Equal(t, hints, resp.Header.Values(HeaderLink), "Link header")
 body, err := io.ReadAll(resp.Body)
 require.NoError(t, err)
 require.Equal(t, "fail", string(body))

---

3856-3879: Add coverage: multiple hints and empty hints.

Consider two quick additions:

• A subtest that sends two Link hints and asserts both values are present (order-preserving).
• A subtest that calls SendEarlyHints([]string{}) and asserts the final response succeeds and contains no Link header.

I can draft these if you want them in this file or in app_test.go to validate end-to-end behavior with the updated App.Test.

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: efectn
PR: gofiber/fiber#3162
File: app_test.go:893-895
Timestamp: 2024-11-29T12:37:27.581Z
Learning: In the `Test_App_ShutdownWithContext` function in `app_test.go`, the `clientDone` channel is used to synchronize the client's request completion before proceeding, eliminating the need for additional `time.Sleep` calls.

ctx_interface_gen.go (2)

368-378: Doc/API mismatch and clarity pass for SendEarlyHints

The docs say “Only Link headers already written to the response will be transmitted as Early Hints”, but the API accepts hints []string. Per the PR context, the implementation appends these hints as Link headers before sending 103. Let's align the comment to the actual behavior, tighten the HTTP version note, and fix a small grammar nit (“an HTTP/2+”):

-	// SendEarlyHints allows the server to hint to the browser what resources a page would need
-	// so the browser can preload them while waiting for the server's full response. Only Link
-	// headers already written to the response will be transmitted as Early Hints.
-	//
-	// This is a HTTP/2+ feature but all browsers will either understand it or safely ignore it.
-	//
-	// NOTE: Older HTTP/1.1 non-browser clients may face compatibility issues.
-	//
-	// See: https://developer.chrome.com/docs/web-platform/early-hints and
-	// https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Link#syntax
+	// SendEarlyHints sends an HTTP 103 Early Hints informational response.
+	// The provided hints are appended as Link headers and sent immediately,
+	// allowing clients to preload resources while the final response is prepared.
+	// Only Link headers are sent as Early Hints; all other headers are ignored.
+	//
+	// Recommended: call before writing final response headers/body.
+	// Most effective over HTTP/2 or HTTP/3; some HTTP/1.1 clients and intermediaries
+	// may ignore or drop 103 responses.
+	//
+	// See: RFC 8297 (Early Hints),
+	// https://developer.chrome.com/docs/web-platform/early-hints,
+	// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
 	SendEarlyHints(hints []string) error

---

378-378: Consider a variadic signature for ergonomics and allocation-free call sites

Links(link ...string) already uses varargs; mirroring that here would improve ergonomics and avoid slice allocations at call sites.

-SendEarlyHints(hints []string) error
+SendEarlyHints(hints ...string) error

Note: This is an interface change and will cascade to implementations and tests; only consider if you’re comfortable adjusting the rest of the PR accordingly.

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.

res_interface_gen.go (2)

112-122: API alignment question: name/signature vs Express writeEarlyHints

Express uses res.writeEarlyHints(headers[, cb]). We’re exposing SendEarlyHints([]string). If Express alignment and API longevity are goals, consider whether we want a map-like input (supporting multiple headers and non-Link fields for future-proofing) or keep Fiber’s narrowly-scoped Link-only API. If keeping Link-only, the docs should explicitly state expected value format (e.g., </style.css>; rel=preload; as=style) and dedup behavior.

Would you like me to draft an alternative API proposal (backwards-compatible) that can accept either []string (Link values) or a map[string][]string, while keeping the implementation constrained to sending only Link in the 103?

---

112-122: Update Early Hints documentation in source and regenerate
Please update the comment on DefaultRes.SendEarlyHints in res.go as shown below, then run make generate to propagate it to res_interface_gen.go:

@@ -691,12 +691,23 @@
-// SendEarlyHints allows the server to hint to the browser what resources a page would need
-// so the browser can preload them while waiting for the server's full response. Only Link
-// headers already written to the response will be transmitted as Early Hints.
-//
-// This is a HTTP/2+ feature but all browsers will either understand it or safely ignore it.
-//
-// NOTE: Older HTTP/1.1 non-browser clients may face compatibility issues.
-//
-// See: https://developer.chrome.com/docs/web-platform/early-hints and
-// https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Link#syntax
+// SendEarlyHints emits a 103 Early Hints response (RFC 8297).
+// The provided hints are appended as Link headers and sent in the 103 response.
+// Only Link headers are included in Early Hints; other headers are typically ignored by clients.
+//
+// Call early, before writing the final response body. If hints is empty, this is a no-op.
+// Returns an error if the underlying server fails to write the 103 response.
+//
+// Note: RFC 8297 applies to both HTTP/1.1 and HTTP/2+. In practice, browsers act on Early
+// Hints primarily over HTTP/2/HTTP/3. When using Fiber/fasthttp (HTTP/1.1), deploy behind
+// a proxy that forwards 103 to clients for best results.
+//
+// See: https://datatracker.ietf.org/doc/html/rfc8297 and
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link#syntax

• File: res.go, around line 691
• Run make generate to update res_interface_gen.go

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.