Protobuf to
Go.

// services/payments_service_client.go
package services

import (
	"context"
	"net/http"

	"github.com/example/payments/models"
)

// PaymentsServiceClient is the HTTP client for this service.
type PaymentsServiceClient struct {
	httpClient *http.Client
	baseURL    string
}

// NewPaymentsServiceClient creates a new PaymentsServiceClient instance.
func NewPaymentsServiceClient(baseURL string) *PaymentsServiceClient {
	httpClient := &http.Client{}

	return &PaymentsServiceClient{
		httpClient: httpClient,
		baseURL:    baseURL,
	}
}

// GetPayment Get payment
func (c *PaymentsServiceClient) GetPayment(ctx context.Context, body *models.GetPaymentRequest) (*models.Payment, error) {
	var result models.Payment
	if err := connectUnary(ctx, c.httpClient, c.baseURL, "/payments.v1.PaymentsService/GetPayment", body, &result); err != nil {
		return nil, err
	}
	return &result, nil
}

// services/connect_call.go (shared)
package services

// connectUnary executes a Connect unary RPC. Marshals body, POSTs to path with
// the Connect headers, decodes the error envelope via decodeConnectError, and
// decodes the JSON response into target. Pass a nil target for RPCs that do
// not read the response body.
func connectUnary(ctx context.Context, httpClient *http.Client, baseURL, path string, body, target any) error {
	bodyBytes, err := json.Marshal(body)
	if err != nil {
		return fmt.Errorf("failed to marshal request: %w", err)
	}
	req, err := http.NewRequestWithContext(ctx, "POST", baseURL+path, bytes.NewReader(bodyBytes))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Connect-Protocol-Version", "1")
	resp, err := httpClient.Do(req)
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()
	if err := decodeConnectError(resp); err != nil {
		return err
	}
	if target == nil {
		return nil
	}
	if err := json.NewDecoder(resp.Body).Decode(target); err != nil {
		return fmt.Errorf("failed to decode response: %w", err)
	}
	return nil
}

// services/connect_error.go — the Connect error envelope,
// decoded into a Go error:
//   rpc error: code = not_found, message = payment missing