ghttp

func BindResponseBody ¶

func BindResponseBody(resp *http.Response, target any) error

BindResponseBody binds the body of an HTTP response to the given 'target' struct, automatically decoding the body based on the Content-Type header of the response.

This function checks the Content-Type header and decodes the response body into the corresponding Go type. It assumes that the 'target' parameter is a pointer to the structure that should be populated with the response data.

Example usage:

var userResponse User
err := BindResponseBody(response, &userResponse)
if err != nil {
    log.Fatal("Failed to bind response body:", err)
}
// The 'userResponse' struct will now be populated with the decoded response data.

func CodecForRequest ¶

func CodecForRequest(r *http.Request, name ...string) (encoding.Codec, bool)

CodecForRequest get encoding.Codec via http.Request

func CodecForResponse ¶

func CodecForResponse(r *http.Response, name ...string) (encoding.Codec, bool)

CodecForResponse get encoding.Codec via http.Response

func CodecForString ¶

func CodecForString(contentType string) encoding.Codec

CodecForString get encoding.Codec via string

func EncodeRequestBody ¶

func EncodeRequestBody(req *http.Request, body any) error

EncodeRequestBody encodes the provided body content based on the Content-Type of the given HTTP request, and sets the encoded body in the request.

The function will automatically detect the Content-Type header of the request and encode the body accordingly (e.g., JSON, XML, etc.). It then uses SetRequestBody to set the encoded body in the request.

Example usage:

// Example structure to be encoded into the request body
type MyRequest struct {
    Name  string `json:"name"`
    Value int    `json:"value"`
}

req, err := http.NewRequest("POST", "https://example.com/api", nil)
if err != nil {
    log.Fatal("Failed to create request:", err)
}

body := MyRequest{Name: "example", Value: 42}
err = EncodeRequestBody(req, body)
if err != nil {
    log.Fatal("Failed to encode request body:", err)
}

// Now the request body is set to the JSON-encoded version of MyRequest
fmt.Println("Request prepared with body:", req.Body)

func ForceHttps ¶

func ForceHttps(endpoint string) string

ForceHttps ensures that the provided endpoint is using the HTTPS protocol. It checks if the URL already contains a scheme (like "http://"), removes it, and then prepends "https://" to the endpoint to ensure the URL uses HTTPS.

Example usage:

url := "http://example.com"
secureUrl := ForceHttps(url)
fmt.Println(secureUrl) // Output: "https://example.com"

func IsTimeout ¶

func IsTimeout(err error) bool

func ProxyURL ¶

func ProxyURL(address string) func(*http.Request) (*url.URL, error)

ProxyURL returns a function that sets a proxy URL for the given HTTP request.

This function accepts an address as input and ensures that the address is properly formatted as a valid URL. If the address is a relative address (e.g., ":7890" or "/proxy"), it is converted to a full HTTP address (e.g., "http://127.0.0.1:7890"). If the address does not include a scheme (e.g., "http://"), the function prepends "http://" to the address. The returned function can be used to configure HTTP requests to route through the specified proxy.

func RegisterCodec ¶

func RegisterCodec(contentType string, codec encoding.Codec)

func RegisterCodecName ¶

func RegisterCodecName(contentType string, name string)

func SetQuery ¶

func SetQuery(req *http.Request, q any) error

SetQuery encodes the provided query parameters into a URL query string and appends them to the given HTTP request's URL. This function uses the `github.com/nexuer/ghttp/query` package to encode the query parameters. The query parameters are serialized into the URL query string format and appended to the existing URL of the HTTP request. If the request already contains a query string, the new parameters will be appended to it. If no query parameters are provided, no changes are made to the request.

Example usage:

req, err := http.NewRequest("GET", "https://example.com/api", nil)
if err != nil {
    log.Fatal("Failed to create request:", err)
}

// Define query parameters as a struct
queryParams := struct {
    Name  string `query:"name"`
    Value int    `query:"value"`
}{
    Name:  "example",
    Value: 42,
}

err = SetQuery(req, queryParams)
if err != nil {
    log.Fatal("Failed to set query parameters:", err)
}

// The request URL will now include the query parameters encoded as `?name=example&value=42`

func SetRequestBody ¶

func SetRequestBody(req *http.Request, body io.Reader) error

SetRequestBody modifies the body of the given HTTP request.

This function allows you to set or replace the body of the HTTP request with the provided 'body' parameter. The body is expected to be an io.Reader, which means it can be any type that implements the io.Reader interface, such as a byte buffer or a file stream.

Example usage:

req, err := http.NewRequest("POST", "https://example.com", nil)
if err != nil {
    log.Fatal("Failed to create request:", err)
}

body := strings.NewReader("some request data")
err = SetRequestBody(req, body)
if err != nil {
    log.Fatal("Failed to set request body:", err)
}
// Now the request body is set to "some request data"

func StatusForErr ¶

func StatusForErr(err error) (int, bool)