krystal/go-katapult

package katapult

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

// Request represents a HTTP request to the Katapult API, it is essentially
// similar to http.Request, but stripped down to the bare essentials, with some
// Katapult-specific attributes added.
type Request struct {
    // Method is the HTTP method to perform when making the request.
    Method string

    // URL is the request URL to perform against Katapult's API. Generally the
    // only fields you need to set are Path and RawQuery, as it will be merged
    // with the Client's BaseURL value through its ResolveReference() method.
    URL *url.URL

    // NoAuth instructs Client not to send Authorization header containing the
    // APIKey. This is useful for public endpoints which do not require/use
    // authentication.
    NoAuth bool

    // Header holds request-specific HTTP headers. Client.Do() will set a number
    // of essential headers itself which cannot be customized through
    // Request.Headers.
    Header http.Header

    // ContentType allows sending a custom request body of any mimetype. If set
    // Body must be a io.Reader. If not set Body must be a object which can be
    // serialized with json.Marshal(). Content-Type header is only sent when
    // Body is not nil.
    ContentType string

    // Body can be any object which can be marshaled to JSON through
    // json.Marshal() when ContentType is not set. If ContentType is set, Body
    // must be a io.Reader, or nil.
    //
    // No validation is performed between Method and Body, making it possible to
    // send a body with a method that does not allow it.
    Body interface{}
}

type RequestOption = func(r *Request)

// RequestSetHeader sets a header on the outgoing request. This replaces any
// headers that are currently specified with that key.
func RequestSetHeader(key, value string) RequestOption {
    return func(r *Request) {
        r.Header.Set(key, value)
    }
}

func NewRequest(
    method string,
    u *url.URL,
    body interface{},
    opts ...RequestOption,
) *Request {
    r := &Request{
        Method: method,
        URL:    u,
        Body:   body,
        Header: map[string][]string{},
    }

    // Apply options to created Client
    for _, opt := range opts {
        opt(r)
    }

    return r
}

func (r *Request) bodyContent() (string, io.Reader, error) {
    if r.Body == nil {
        return "", nil, nil
    }

    contentType := r.ContentType
    var body io.Reader

    if contentType == "" {
        contentType = "application/json"
        var buf bytes.Buffer
        enc := json.NewEncoder(&buf)
        enc.SetEscapeHTML(false)
        err := enc.Encode(r.Body)
        if err != nil {
            return "", nil, err
        }
        body = &buf
    } else {
        var ok bool
        body, ok = r.Body.(io.Reader)
        if !ok {
            return "", nil, fmt.Errorf(
                "%w: Body must be a io.Reader when ContentType is set",
                ErrRequest,
            )
        }
    }

    return contentType, body, nil
}