feat: fiber.Context implement context.Context (#3382)

* Ctx implements context.Context

* fix up some linting issues

* added some tests

* no message

* fiber.Ctx implements context.Context

* no message

* implement compile-time check

* update formatting

* update compile-time checks

---------

Co-authored-by: Juan Calderon-Perez <[email protected]>

Author: pjebs

ctx.go

@@ -39,12 +39,14 @@ const (
 	maxDetectionPaths = 3
 )
 
+var (
+	_ io.Writer       = (*DefaultCtx)(nil) // Compile-time check
+	_ context.Context = (*DefaultCtx)(nil) // Compile-time check
+)
+
 // The contextKey type is unexported to prevent collisions with context keys defined in
 // other packages.
-type contextKey int
-
-// userContextKey define the key name for storing context.Context in *fasthttp.RequestCtx
-const userContextKey contextKey = 0 // __local_user_context__
+type contextKey int //nolint:unused // need for future (nolintlint)
 
 // DefaultCtx is the default implementation of the Ctx interface
 // generation tool `go install github.com/vburenin/ifacemaker@975a95966976eeb2d4365a7fb236e274c54da64c`
@@ -391,23 +393,6 @@ func (c *DefaultCtx) RequestCtx() *fasthttp.RequestCtx {
 	return c.fasthttp
 }
 
-// Context returns a context implementation that was set by
-// user earlier or returns a non-nil, empty context,if it was not set earlier.
-func (c *DefaultCtx) Context() context.Context {
-	ctx, ok := c.fasthttp.UserValue(userContextKey).(context.Context)
-	if !ok {
-		ctx = context.Background()
-		c.SetContext(ctx)
-	}
-
-	return ctx
-}
-
-// SetContext sets a context implementation by user.
-func (c *DefaultCtx) SetContext(ctx context.Context) {
-	c.fasthttp.SetUserValue(userContextKey, ctx)
-}
-
 // Cookie sets a cookie by passing a cookie struct.
 func (c *DefaultCtx) Cookie(cookie *Cookie) {
 	fcookie := fasthttp.AcquireCookie()
@@ -444,6 +429,28 @@ func (c *DefaultCtx) Cookie(cookie *Cookie) {
 	fasthttp.ReleaseCookie(fcookie)
 }
 
+// Deadline returns the time when work done on behalf of this context
+// should be canceled. Deadline returns ok==false when no deadline is
+// set. Successive calls to Deadline return the same results.
+//
+// Due to current limitations in how fasthttp works, Deadline operates as a nop.
+// See: https://github.com/valyala/fasthttp/issues/965#issuecomment-777268945
+func (*DefaultCtx) Deadline() (time.Time, bool) {
+	return time.Time{}, false
+}
+
+// Done returns a channel that's closed when work done on behalf of this
+// context should be canceled. Done may return nil if this context can
+// never be canceled. Successive calls to Done return the same value.
+// The close of the Done channel may happen asynchronously,
+// after the cancel function returns.
+//
+// Due to current limitations in how fasthttp works, Done operates as a nop.
+// See: https://github.com/valyala/fasthttp/issues/965#issuecomment-777268945
+func (*DefaultCtx) Done() <-chan struct{} {
+	return nil
+}
+
 // Cookies are used for getting a cookie value by key.
 // Defaults to the empty string "" if the cookie doesn't exist.
 // If a default value is given, it will return that value if the cookie doesn't exist.
@@ -468,6 +475,18 @@ func (c *DefaultCtx) Download(file string, filename ...string) error {
 	return c.SendFile(file)
 }
 
+// If Done is not yet closed, Err returns nil.
+// If Done is closed, Err returns a non-nil error explaining why:
+// context.DeadlineExceeded if the context's deadline passed,
+// or context.Canceled if the context was canceled for some other reason.
+// After Err returns a non-nil error, successive calls to Err return the same error.
+//
+// Due to current limitations in how fasthttp works, Err operates as a nop.
+// See: https://github.com/valyala/fasthttp/issues/965#issuecomment-777268945
+func (*DefaultCtx) Err() error {
+	return nil
+}
+
 // Request return the *fasthttp.Request object
 // This allows you to use all fasthttp request methods
 // https://godoc.org/github.com/valyala/fasthttp#Request
@@ -1816,6 +1835,12 @@ func (c *DefaultCtx) Vary(fields ...string) {
 	c.Append(HeaderVary, fields...)
 }
 
+// Value makes it possible to retrieve values (Locals) under keys scoped to the request
+// and therefore available to all following routes that match the request.
+func (c *DefaultCtx) Value(key any) any {
+	return c.fasthttp.UserValue(key)
+}
+
 // Write appends p into response body.
 func (c *DefaultCtx) Write(p []byte) (int, error) {
 	c.fasthttp.Response.AppendBody(p)

ctx_interface_gen.go

@@ -9,7 +9,6 @@ import (
 	"bytes"
 	"compress/gzip"
 	"compress/zlib"
-	"context"
 	"crypto/tls"
 	"embed"
 	"encoding/hex"
@@ -881,76 +880,6 @@ func Test_Ctx_RequestCtx(t *testing.T) {
 	require.Equal(t, "*fasthttp.RequestCtx", fmt.Sprintf("%T", c.RequestCtx()))
 }
 
-// go test -run Test_Ctx_Context
-func Test_Ctx_Context(t *testing.T) {
-	t.Parallel()
-	app := New()
-	c := app.AcquireCtx(&fasthttp.RequestCtx{})
-
-	t.Run("Nil_Context", func(t *testing.T) {
-		t.Parallel()
-		ctx := c.Context()
-		require.Equal(t, ctx, context.Background())
-	})
-	t.Run("ValueContext", func(t *testing.T) {
-		t.Parallel()
-		testKey := struct{}{}
-		testValue := "Test Value"
-		ctx := context.WithValue(context.Background(), testKey, testValue) //nolint:staticcheck // not needed for tests
-		require.Equal(t, testValue, ctx.Value(testKey))
-	})
-}
-
-// go test -run Test_Ctx_SetContext
-func Test_Ctx_SetContext(t *testing.T) {
-	t.Parallel()
-	app := New()
-	c := app.AcquireCtx(&fasthttp.RequestCtx{})
-
-	testKey := struct{}{}
-	testValue := "Test Value"
-	ctx := context.WithValue(context.Background(), testKey, testValue) //nolint:staticcheck // not needed for tests
-	c.SetContext(ctx)
-	require.Equal(t, testValue, c.Context().Value(testKey))
-}
-
-// go test -run Test_Ctx_Context_Multiple_Requests
-func Test_Ctx_Context_Multiple_Requests(t *testing.T) {
-	t.Parallel()
-	testKey := struct{}{}
-	testValue := "foobar-value"
-
-	app := New()
-	app.Get("/", func(c Ctx) error {
-		ctx := c.Context()
-
-		if ctx.Value(testKey) != nil {
-			return c.SendStatus(StatusInternalServerError)
-		}
-
-		input := utils.CopyString(Query(c, "input", "NO_VALUE"))
-		ctx = context.WithValue(ctx, testKey, fmt.Sprintf("%s_%s", testValue, input)) //nolint:staticcheck // not needed for tests
-		c.SetContext(ctx)
-
-		return c.Status(StatusOK).SendString(fmt.Sprintf("resp_%s_returned", input))
-	})
-
-	// Consecutive Requests
-	for i := 1; i <= 10; i++ {
-		t.Run(fmt.Sprintf("request_%d", i), func(t *testing.T) {
-			t.Parallel()
-			resp, err := app.Test(httptest.NewRequest(MethodGet, fmt.Sprintf("/?input=%d", i), nil))
-
-			require.NoError(t, err, "Unexpected error from response")
-			require.Equal(t, StatusOK, resp.StatusCode, "context.Context returned from c.Context() is reused")
-
-			b, err := io.ReadAll(resp.Body)
-			require.NoError(t, err, "Unexpected error from reading response body")
-			require.Equal(t, fmt.Sprintf("resp_%d_returned", i), string(b), "response text incorrect")
-		})
-	}
-}
-
 // go test -run Test_Ctx_Cookie
 func Test_Ctx_Cookie(t *testing.T) {
 	t.Parallel()
@@ -2257,6 +2186,73 @@ func Test_Ctx_Locals(t *testing.T) {
 	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
 }
 
+// go test -run Test_Ctx_Deadline
+func Test_Ctx_Deadline(t *testing.T) {
+	t.Parallel()
+	app := New()
+	app.Use(func(c Ctx) error {
+		return c.Next()
+	})
+	app.Get("/test", func(c Ctx) error {
+		deadline, ok := c.Deadline()
+		require.Equal(t, time.Time{}, deadline)
+		require.False(t, ok)
+		return nil
+	})
+	resp, err := app.Test(httptest.NewRequest(MethodGet, "/test", nil))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
+}
+
+// go test -run Test_Ctx_Done
+func Test_Ctx_Done(t *testing.T) {
+	t.Parallel()
+	app := New()
+	app.Use(func(c Ctx) error {
+		return c.Next()
+	})
+	app.Get("/test", func(c Ctx) error {
+		require.Equal(t, (<-chan struct{})(nil), c.Done())
+		return nil
+	})
+	resp, err := app.Test(httptest.NewRequest(MethodGet, "/test", nil))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
+}
+
+// go test -run Test_Ctx_Err
+func Test_Ctx_Err(t *testing.T) {
+	t.Parallel()
+	app := New()
+	app.Use(func(c Ctx) error {
+		return c.Next()
+	})
+	app.Get("/test", func(c Ctx) error {
+		require.NoError(t, c.Err())
+		return nil
+	})
+	resp, err := app.Test(httptest.NewRequest(MethodGet, "/test", nil))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
+}
+
+// go test -run Test_Ctx_Value
+func Test_Ctx_Value(t *testing.T) {
+	t.Parallel()
+	app := New()
+	app.Use(func(c Ctx) error {
+		c.Locals("john", "doe")
+		return c.Next()
+	})
+	app.Get("/test", func(c Ctx) error {
+		require.Equal(t, "doe", c.Value("john"))
+		return nil
+	})
+	resp, err := app.Test(httptest.NewRequest(MethodGet, "/test", nil))
+	require.NoError(t, err, "app.Test(req)")
+	require.Equal(t, StatusOK, resp.StatusCode, "Status code")
+}
+
 // go test -run Test_Ctx_Locals_Generic
 func Test_Ctx_Locals_Generic(t *testing.T) {
 	t.Parallel()

ctx_test.go

@@ -41,20 +41,36 @@ app.Post("/", func(c fiber.Ctx) error {
 })
 ```
 
-### Context
+## Context
 
-`Context` returns a context implementation that was set by the user earlier or returns a non-nil, empty context if it was not set earlier.
+`Context` implements `context.Context`. However due to [current limitations in how fasthttp](https://github.com/valyala/fasthttp/issues/965#issuecomment-777268945) works, `Deadline()`, `Done()` and `Err()` operate as a nop.
 
 ```go title="Signature"
-func (c fiber.Ctx) Context() context.Context
+func (c fiber.Ctx) Deadline() (deadline time.Time, ok bool)
+func (c fiber.Ctx) Done() <-chan struct{}
+func (c fiber.Ctx) Err() error
+func (c fiber.Ctx) Value(key any) any
 ```
 
 ```go title="Example"
-app.Get("/", func(c fiber.Ctx) error {
-  ctx := c.Context()
-  // ctx is context implementation set by user
 
+func doSomething(ctx context.Context) {
   // ...
+}
+
+app.Get("/", func(c fiber.Ctx) error {
+  doSomething(c)
+})
+```
+
+### Value
+
+Value can be used to retrieve [**`Locals`**](./#locals).
+
+```go title="Example"
+app.Get("/", func(c fiber.Ctx) error {
+  c.Locals(userKey, "admin")
+  user := c.Value(userKey) // returns "admin"
 })
 ```
 

docs/api/ctx.md

@@ -394,10 +394,14 @@ testConfig := fiber.TestConfig{
 ### New Features
 
 - Cookie now allows Partitioned cookies for [CHIPS](https://developers.google.com/privacy-sandbox/3pcd/chips) support. CHIPS (Cookies Having Independent Partitioned State) is a feature that improves privacy by allowing cookies to be partitioned by top-level site, mitigating cross-site tracking.
+- Context now implements [context.Context](https://pkg.go.dev/context#Context).
 
 ### New Methods
 
 - **AutoFormat**: Similar to Express.js, automatically formats the response based on the request's `Accept` header.
+- **Deadline**: For implementing `context.Context`.
+- **Done**: For implementing `context.Context`.
+- **Err**: For implementing `context.Context`.
 - **Host**: Similar to Express.js, returns the host name of the request.
 - **Port**: Similar to Express.js, returns the port number of the request.
 - **IsProxyTrusted**: Checks the trustworthiness of the remote IP.
@@ -407,6 +411,7 @@ testConfig := fiber.TestConfig{
 - **SendStreamWriter**: Sends a stream using a writer function.
 - **SendString**: Similar to Express.js, sends a string as the response.
 - **String**: Similar to Express.js, converts a value to a string.
+- **Value**: For implementing `context.Context`. Returns request-scoped value from Locals.
 - **ViewBind**: Binds data to a view, replacing the old `Bind` method.
 - **CBOR**: Introducing [CBOR](https://cbor.io/) binary encoding format for both request & response body. CBOR is a binary data serialization format which is both compact and efficient, making it ideal for use in web applications.
 - **Drop**: Terminates the client connection silently without sending any HTTP headers or response body. This can be used for scenarios where you want to block certain requests without notifying the client, such as mitigating DDoS attacks or protecting sensitive endpoints from unauthorized access.