🔥 feat: Add StreamResponseBody support for the Client

Author: Abhirup-99

client/client.go

@@ -435,6 +435,20 @@ func (c *Client) DisableDebug() *Client {
 	return c
 }
 
+// StreamResponseBody returns the current StreamResponseBody setting.
+func (c *Client) StreamResponseBody() bool {
+	return c.fasthttp.StreamResponseBody
+}
+
+// SetStreamResponseBody enables or disables response body streaming.
+// When enabled, the response body can be read as a stream using BodyStream()
+// instead of being fully loaded into memory. This is useful for large responses
+// or server-sent events.
+func (c *Client) SetStreamResponseBody(enable bool) *Client {
+	c.fasthttp.StreamResponseBody = enable
+	return c
+}
+
 // SetCookieJar sets the cookie jar for the client.
 func (c *Client) SetCookieJar(cookieJar *CookieJar) *Client {
 	c.cookieJar = cookieJar

client/client_test.go

@@ -1733,3 +1733,120 @@ func Benchmark_Client_Request_Parallel(b *testing.B) {
 		require.NoError(b, err)
 	})
 }
+
+func Test_Client_StreamResponseBody(t *testing.T) {
+	t.Parallel()
+	client := New()
+	require.False(t, client.StreamResponseBody())
+	client.SetStreamResponseBody(true)
+	require.True(t, client.StreamResponseBody())
+	client.SetStreamResponseBody(false)
+	require.False(t, client.StreamResponseBody())
+}
+
+func Test_Client_StreamResponseBody_ServerSentEvents(t *testing.T) {
+	t.Parallel()
+
+	app, addr := startTestServerWithPort(t, func(app *fiber.App) {
+		app.Get("/sse", func(c fiber.Ctx) error {
+			c.Set("Content-Type", "text/event-stream")
+			c.Set("Cache-Control", "no-cache")
+			c.Set("Connection", "keep-alive")
+
+			messages := []string{
+				"data: message 1\n\n",
+				"data: message 2\n\n",
+				"data: message 3\n\n",
+			}
+
+			for _, msg := range messages {
+				if _, err := c.WriteString(msg); err != nil {
+					return err
+				}
+			}
+
+			return nil
+		})
+	})
+	defer func() { require.NoError(t, app.Shutdown()) }()
+
+	client := New().SetStreamResponseBody(true)
+	resp, err := client.Get("http://" + addr + "/sse")
+	require.NoError(t, err)
+	defer resp.Close()
+
+	bodyStream := resp.BodyStream()
+	require.NotNil(t, bodyStream)
+
+	buffer := make([]byte, 1024)
+	n, err := bodyStream.Read(buffer)
+	require.NoError(t, err)
+	require.Positive(t, n)
+
+	content := string(buffer[:n])
+	require.Contains(t, content, "data: message 1")
+}
+
+func Test_Client_StreamResponseBody_LargeResponse(t *testing.T) {
+	t.Parallel()
+
+	largeData := make([]byte, 1024*1024)
+	for i := range largeData {
+		largeData[i] = byte(i % 256)
+	}
+
+	app, addr := startTestServerWithPort(t, func(app *fiber.App) {
+		app.Get("/large", func(c fiber.Ctx) error {
+			return c.Send(largeData)
+		})
+	})
+	defer func() { require.NoError(t, app.Shutdown()) }()
+	client := New().SetStreamResponseBody(true)
+	resp, err := client.Get("http://" + addr + "/large")
+	require.NoError(t, err)
+	defer resp.Close()
+	bodyStream := resp.BodyStream()
+	require.NotNil(t, bodyStream)
+	streamedData, err := io.ReadAll(bodyStream)
+	require.NoError(t, err)
+	require.Equal(t, largeData, streamedData)
+	client2 := New()
+	resp2, err := client2.Get("http://" + addr + "/large")
+	require.NoError(t, err)
+	defer resp2.Close()
+	body := resp2.Body()
+	require.Equal(t, largeData, body)
+}
+
+func Test_Client_StreamResponseBody_Disabled_Default(t *testing.T) {
+	t.Parallel()
+
+	app, addr := startTestServerWithPort(t, func(app *fiber.App) {
+		app.Get("/test", func(c fiber.Ctx) error {
+			return c.SendString("Hello, World!")
+		})
+	})
+	defer func() { require.NoError(t, app.Shutdown()) }()
+
+	client := New()
+	resp, err := client.Get("http://" + addr + "/test")
+	require.NoError(t, err)
+	defer resp.Close()
+
+	body := resp.Body()
+	require.Equal(t, "Hello, World!", string(body))
+
+	bodyStream := resp.BodyStream()
+	require.NotNil(t, bodyStream)
+}
+
+func Test_Client_StreamResponseBody_ChainableMethods(t *testing.T) {
+	t.Parallel()
+
+	client := New().
+		SetStreamResponseBody(true).
+		SetTimeout(time.Second * 5).
+		SetStreamResponseBody(false)
+
+	require.False(t, client.StreamResponseBody())
+}

client/request.go

@@ -44,30 +44,24 @@ var ErrClientNil = errors.New("client cannot be nil")
 
 // Request contains all data related to an HTTP request.
 type Request struct {
-	ctx context.Context //nolint:containedctx // Context is needed to be stored in the request.
-
-	body    any
-	header  *Header
-	params  *QueryParam
-	cookies *Cookie
-	path    *PathParam
-
-	client *Client
-
-	formData *FormData
-
-	RawRequest *fasthttp.Request
-	url        string
-	method     string
-	userAgent  string
-	boundary   string
-	referer    string
-	files      []*File
-
+	body         any
+	ctx          context.Context //nolint:containedctx // Context is needed to be stored in the request.
+	client       *Client
+	RawRequest   *fasthttp.Request
+	formData     *FormData
+	path         *PathParam
+	cookies      *Cookie
+	header       *Header
+	params       *QueryParam
+	referer      string
+	boundary     string
+	userAgent    string
+	method       string
+	url          string
+	files        []*File
 	timeout      time.Duration
 	maxRedirects int
-
-	bodyType bodyType
+	bodyType     bodyType
 }
 
 // Method returns the HTTP method set in the Request.

client/response.go

@@ -89,6 +89,22 @@ func (r *Response) Body() []byte {
 	return r.RawResponse.Body()
 }
 
+// BodyStream returns the response body as a stream reader.
+// Note: When using BodyStream(), the response body is not copied to memory,
+// so calling Body() afterwards may return an empty slice.
+func (r *Response) BodyStream() io.Reader {
+	if stream := r.RawResponse.BodyStream(); stream != nil {
+		return stream
+	}
+	// If streaming is not enabled, return a bytes.Reader from the regular body
+	return bytes.NewReader(r.RawResponse.Body())
+}
+
+// IsStreaming returns true if the response body is being streamed.
+func (r *Response) IsStreaming() bool {
+	return r.RawResponse.BodyStream() != nil
+}
+
 // String returns the response body as a trimmed string.
 func (r *Response) String() string {
 	return utils.Trim(string(r.Body()), ' ')
@@ -143,14 +159,17 @@ func (r *Response) Save(v any) error {
 		return nil
 
 	case io.Writer:
-		if _, err := io.Copy(p, bytes.NewReader(r.Body())); err != nil {
-			return fmt.Errorf("failed to write response body to io.Writer: %w", err)
+		var err error
+		if r.IsStreaming() {
+			_, err = io.CopyBuffer(p, r.BodyStream(), nil)
+		} else {
+			_, err = io.Copy(p, bytes.NewReader(r.Body()))
 		}
-		defer func() {
-			if pc, ok := p.(io.WriteCloser); ok {
-				_ = pc.Close() //nolint:errcheck // not needed
-			}
-		}()
+
+		if err != nil {
+			return fmt.Errorf("failed to write response body to writer: %w", err)
+		}
+
 		return nil
 
 	default: