chore: refactor net/rest to use Ferret HTTP client abstraction (#31)

* chore: refactor `net/rest` to use Ferret HTTP client abstraction, add tests for network context handling, and improve request encoding

* chore: update `go.sum` for `golang.org/x` dependencies

Author: ziflex

modules/db/postgres/go.sum

@@ -64,8 +64,11 @@ github.com/wI2L/jettison v0.7.4/go.mod h1:O+F+T7X7ZN6kTsd167Qk4aZMC8jNrH48SMedNm
 golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM=
 golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80=
 golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

modules/net/rest/core/client.go

@@ -2,25 +2,22 @@ package core
 
 import (
 	"context"
-	"net/http"
 
 	commonresource "github.com/MontFerret/contrib/pkg/common/resource"
 	"github.com/MontFerret/ferret/v2/pkg/runtime"
 )
 
 // Client is an opaque HTTP API client exposed to Ferret.
 type Client struct {
-	httpClient *http.Client
-	config     Config
-	id         uint64
+	config Config
+	id     uint64
 }
 
 // NewClient creates a configured HTTP API client handle.
 func NewClient(config Config) *Client {
 	return &Client{
-		config:     config,
-		httpClient: http.DefaultClient,
-		id:         newResourceID(),
+		config: config,
+		id:     newResourceID(),
 	}
 }
 

modules/net/rest/core/client_test.go

@@ -12,6 +12,8 @@ import (
 	"testing"
 	"time"
 
+	ferretnet "github.com/MontFerret/ferret/v2/pkg/net"
+	ferrethttp "github.com/MontFerret/ferret/v2/pkg/net/http"
 	"github.com/MontFerret/ferret/v2/pkg/runtime"
 )
 
@@ -43,7 +45,7 @@ func TestClientQueryJSONList(t *testing.T) {
 	}))
 	defer server.Close()
 
-	ctx := context.Background()
+	ctx := networkContext()
 	cfg := DefaultConfig()
 	cfg.BaseURL = server.URL
 	cfg.Headers.Set("Authorization", "Bearer token")
@@ -107,7 +109,7 @@ func TestClientInfersPostAndReturnsFullResponse(t *testing.T) {
 	}))
 	defer server.Close()
 
-	ctx := context.Background()
+	ctx := networkContext()
 	cfg := DefaultConfig()
 	cfg.BaseURL = server.URL
 	client := NewClient(cfg)
@@ -152,7 +154,7 @@ func TestClientErrorModes(t *testing.T) {
 	}))
 	defer server.Close()
 
-	ctx := context.Background()
+	ctx := networkContext()
 	cfg := DefaultConfig()
 	cfg.BaseURL = server.URL
 
@@ -195,7 +197,7 @@ func TestClientResponseEncodings(t *testing.T) {
 	}))
 	defer server.Close()
 
-	ctx := context.Background()
+	ctx := networkContext()
 	cfg := DefaultConfig()
 	cfg.BaseURL = server.URL
 	cfg.ResponseEncoding = EncodingText
@@ -253,7 +255,7 @@ func TestClientFormRequestEncoding(t *testing.T) {
 	}))
 	defer server.Close()
 
-	ctx := context.Background()
+	ctx := networkContext()
 	cfg := DefaultConfig()
 	cfg.BaseURL = server.URL
 	client := NewClient(cfg)
@@ -297,15 +299,16 @@ func TestClientAcceptsHTTPDialect(t *testing.T) {
 	cfg.BaseURL = server.URL
 	client := NewClient(cfg)
 
-	out, err := client.Query(context.Background(), runtime.Query{
+	ctx := networkContext()
+	out, err := client.Query(ctx, runtime.Query{
 		Kind:       runtime.NewString("http"),
 		Expression: runtime.NewString("/users"),
 	})
 	if err != nil {
 		t.Fatalf("unexpected query error: %v", err)
 	}
 
-	length, err := out.Length(context.Background())
+	length, err := out.Length(ctx)
 	if err != nil {
 		t.Fatalf("unexpected length error: %v", err)
 	}
@@ -332,7 +335,7 @@ func TestClientRequestTimeout(t *testing.T) {
 	cfg.Timeout = int64(10 * time.Millisecond)
 	client := NewClient(cfg)
 
-	_, err := client.QueryOne(context.Background(), runtime.Query{Expression: runtime.NewString("/slow")})
+	_, err := client.QueryOne(networkContext(), runtime.Query{Expression: runtime.NewString("/slow")})
 	if err == nil {
 		t.Fatal("expected timeout error")
 	}
@@ -370,6 +373,94 @@ func TestClientRejectsUnsupportedDialect(t *testing.T) {
 	}
 }
 
+func TestClientUsesFerretHTTPClientFromContext(t *testing.T) {
+	t.Parallel()
+
+	httpClient := &recordingHTTPClient{
+		response: &ferrethttp.Response{
+			StatusCode: http.StatusOK,
+			Status:     "200 OK",
+			Headers: ferrethttp.Headers{
+				"X-Result": []string{"ok"},
+			},
+			Body: []byte(`{"ok":true}`),
+		},
+	}
+	ctx := ferretnet.WithNetwork(
+		context.Background(),
+		ferretnet.New(ferretnet.WithHTTPClient(httpClient)),
+	)
+
+	cfg := DefaultConfig()
+	cfg.BaseURL = "https://api.example.test/v1/"
+	cfg.Headers.Set("Authorization", "Bearer token")
+	client := NewClient(cfg)
+
+	out, err := client.QueryOne(ctx, runtime.Query{
+		Expression: runtime.NewString("/users"),
+		Params: object(t, map[string]runtime.Value{
+			"method": runtime.NewString("POST"),
+			"query": object(t, map[string]runtime.Value{
+				"active": runtime.True,
+			}),
+			"headers": object(t, map[string]runtime.Value{
+				"X-Request-ID": runtime.NewString("req-1"),
+			}),
+			"body": object(t, map[string]runtime.Value{
+				"name": runtime.NewString("Ada"),
+			}),
+		}),
+		Options: object(t, map[string]runtime.Value{
+			"response": runtime.NewString("full"),
+		}),
+	})
+	if err != nil {
+		t.Fatalf("unexpected query error: %v", err)
+	}
+	if got := field(t, out, "status"); got != runtime.NewInt(http.StatusOK) {
+		t.Fatalf("expected status 200, got %s", got.String())
+	}
+
+	req := httpClient.request()
+	if req == nil {
+		t.Fatal("expected HTTP client to be called")
+	}
+	if req.Method != http.MethodPost {
+		t.Fatalf("expected POST, got %s", req.Method)
+	}
+	if req.URL != "https://api.example.test/users?active=true" {
+		t.Fatalf("unexpected URL: %s", req.URL)
+	}
+	if got := req.Headers["Authorization"]; len(got) != 1 || got[0] != "Bearer token" {
+		t.Fatalf("unexpected authorization header: %v", got)
+	}
+	if got := req.Headers["X-Request-Id"]; len(got) != 1 || got[0] != "req-1" {
+		t.Fatalf("unexpected request id header: %v", got)
+	}
+	if got := req.Headers["Content-Type"]; len(got) != 1 || got[0] != "application/json" {
+		t.Fatalf("unexpected content type: %v", got)
+	}
+	if string(req.Body) != `{"name":"Ada"}` {
+		t.Fatalf("unexpected body: %s", req.Body)
+	}
+}
+
+func TestClientRequiresNetworkContext(t *testing.T) {
+	t.Parallel()
+
+	cfg := DefaultConfig()
+	cfg.BaseURL = "https://api.example.test"
+	client := NewClient(cfg)
+
+	_, err := client.QueryOne(context.Background(), runtime.Query{Expression: runtime.NewString("/users")})
+	if err == nil {
+		t.Fatal("expected missing network error")
+	}
+	if !strings.Contains(err.Error(), "network not found in context") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
 func object(t *testing.T, props map[string]runtime.Value) *runtime.Object {
 	t.Helper()
 
@@ -413,3 +504,7 @@ func readBody(t *testing.T, r *http.Request) string {
 
 	return string(data)
 }
+
+func networkContext() context.Context {
+	return ferretnet.WithNetwork(context.Background(), ferretnet.New())
+}

modules/net/rest/core/codec.go

@@ -5,14 +5,12 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net/url"
-	"strings"
 
 	"github.com/MontFerret/ferret/v2/pkg/runtime"
 )
 
-func encodeRequestBody(ctx context.Context, value runtime.Value, encoding Encoding) (io.Reader, string, error) {
+func encodeRequestBody(ctx context.Context, value runtime.Value, encoding Encoding) ([]byte, string, error) {
 	if runtime.TypeNone.Is(value) {
 		return nil, "", nil
 	}
@@ -29,22 +27,22 @@ func encodeRequestBody(ctx context.Context, value runtime.Value, encoding Encodi
 			return nil, "", err
 		}
 
-		return bytes.NewReader(data), "application/json", nil
+		return data, "application/json", nil
 	case EncodingText:
-		return strings.NewReader(value.String()), "text/plain; charset=utf-8", nil
+		return []byte(value.String()), "text/plain; charset=utf-8", nil
 	case EncodingBytes:
 		if binary, ok := value.(runtime.Binary); ok {
-			return bytes.NewReader(binary), "application/octet-stream", nil
+			return []byte(binary), "application/octet-stream", nil
 		}
 
-		return strings.NewReader(value.String()), "application/octet-stream", nil
+		return []byte(value.String()), "application/octet-stream", nil
 	case EncodingForm:
 		values := make(url.Values)
 		if err := appendURLValues(ctx, values, "HTTP request body", value); err != nil {
 			return nil, "", err
 		}
 
-		return strings.NewReader(values.Encode()), "application/x-www-form-urlencoded", nil
+		return []byte(values.Encode()), "application/x-www-form-urlencoded", nil
 	default:
 		return nil, "", fmt.Errorf("unsupported request encoding %q", encoding)
 	}

modules/net/rest/core/execute.go

@@ -2,9 +2,9 @@ package core
 
 import (
 	"context"
-	"io"
-	"net/http"
 
+	ferretnet "github.com/MontFerret/ferret/v2/pkg/net"
+	ferrethttp "github.com/MontFerret/ferret/v2/pkg/net/http"
 	"github.com/MontFerret/ferret/v2/pkg/runtime"
 )
 
@@ -33,6 +33,11 @@ func executeQuery(ctx context.Context, client *Client, q runtime.Query) (runtime
 		return runtime.None, false, OperationError("QUERY", err)
 	}
 
+	httpClient, err := ferretnet.HTTPClientFrom(ctx)
+	if err != nil {
+		return runtime.None, false, OperationError("QUERY", err)
+	}
+
 	requestCtx := ctx
 	cancel := func() {}
 
@@ -42,28 +47,22 @@ func executeQuery(ctx context.Context, client *Client, q runtime.Query) (runtime
 
 	defer cancel()
 
-	req, err := http.NewRequestWithContext(requestCtx, requestData.Method, requestURL, body)
-	if err != nil {
-		return runtime.None, false, OperationError("QUERY", err)
-	}
-
-	req.Header = mergeHeaders(client.config.Headers, requestData.Headers)
-	if contentType != "" && !hasHeader(req.Header, "Content-Type") {
-		req.Header.Set("Content-Type", contentType)
-	}
-
-	resp, err := client.httpClient.Do(req)
-	if err != nil {
-		return runtime.None, false, OperationError("QUERY", err)
+	headers := mergeHeaders(client.config.Headers, requestData.Headers)
+	if contentType != "" && !hasHeader(headers, "Content-Type") {
+		headers.Set("Content-Type", contentType)
 	}
-	defer resp.Body.Close()
 
-	responseBody, err := io.ReadAll(resp.Body)
+	resp, err := httpClient.Do(requestCtx, &ferrethttp.Request{
+		Method:  requestData.Method,
+		URL:     requestURL,
+		Headers: ferrethttp.Headers(headers),
+		Body:    body,
+	})
 	if err != nil {
 		return runtime.None, false, OperationError("QUERY", err)
 	}
 
-	value, flatten, err := decodeHTTPResponse(ctx, resp, responseBody, options)
+	value, flatten, err := decodeHTTPResponse(ctx, requestURL, resp, options)
 	if err != nil {
 		return runtime.None, false, OperationError("QUERY", err)
 	}

modules/net/rest/core/recording_http_client_test.go

@@ -0,0 +1,51 @@
+package core
+
+import (
+	"context"
+	"sync"
+
+	ferrethttp "github.com/MontFerret/ferret/v2/pkg/net/http"
+)
+
+type recordingHTTPClient struct {
+	err         error
+	lastRequest *ferrethttp.Request
+	response    *ferrethttp.Response
+	mu          sync.Mutex
+}
+
+func (c *recordingHTTPClient) Do(_ context.Context, req *ferrethttp.Request) (*ferrethttp.Response, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.lastRequest = c.cloneRequest(req)
+	if c.err != nil {
+		return nil, c.err
+	}
+
+	return c.response, nil
+}
+
+func (c *recordingHTTPClient) request() *ferrethttp.Request {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	return c.cloneRequest(c.lastRequest)
+}
+
+func (c *recordingHTTPClient) cloneRequest(req *ferrethttp.Request) *ferrethttp.Request {
+	if req == nil {
+		return nil
+	}
+
+	clone := *req
+	if req.Headers != nil {
+		clone.Headers = make(ferrethttp.Headers, len(req.Headers))
+		for key, values := range req.Headers {
+			clone.Headers[key] = append([]string(nil), values...)
+		}
+	}
+	clone.Body = append([]byte(nil), req.Body...)
+
+	return &clone
+}