rest

func BuildQuery ¶

func BuildQuery(params map[string]string) string

BuildQuery takes a map of key-value pairs and constructs a URL-encoded query string. Keys and values are automatically escaped. Example: map{"q": "golang", "page": "1"} → "page=1&q=golang"

func DecodePathSegment ¶

func DecodePathSegment(segment string) (string, error)

DecodePathSegment unescapes a previously encoded path segment string. It reverses the effect of EncodePathSegment.

func DownloadBytes ¶

func DownloadBytes(w http.ResponseWriter, r *http.Request, filename, contentType string, data []byte)

DownloadBytes sends a byte slice as a downloadable file. - Keeps UTF-8 filenames, sanitizes only unsafe chars via SanitiseFilename - Sniffs Content-Type if not provided - Streams with range support using http.ServeContent - Exposes Content-Disposition header for JS to read (if needed)

Parameters:

• w: http.ResponseWriter to write the response to.
• r: Pointer to the http.Request that initiated the download.
• filename: The desired filename for the downloaded file.
• contentType: The MIME type of the file. If empty, it will be auto-detected.
• data: The byte slice containing the file data to be sent.

func EncodePathSegment ¶

func EncodePathSegment(segment string) string

EncodePathSegment safely escapes a path segment so it can be used in a URL without affecting its structure. For example, "a/b" becomes "a%2Fb".

func GetClientIP ¶

func GetClientIP(r *http.Request) string

GetClientIP extracts the real client IP address from the HTTP request. It checks X-Forwarded-For and X-Real-IP headers before falling back to RemoteAddr.

func GetIPVersion ¶

func GetIPVersion(ipStr string) int

GetIPVersion determines the IP version of the given address string. Returns 4 for IPv4, 6 for IPv6, and 0 if the IP is invalid or unrecognized.

func IsHttpRequest ¶

func IsHttpRequest(r *http.Request) bool

Determines and returns the flag if the current workflow is a HTTP request or not. This method is not full proof but will give you right results in all usual workflows.

func IsPrivateIP ¶

func IsPrivateIP(ipStr string) bool

IsPrivateIP checks if the given IP address belongs to a private or reserved IP range. It supports both IPv4 (e.g., 10.0.0.0/8, 192.168.0.0/16) and IPv6 (e.g., fc00::/7) blocks.

Returns true if the IP is private, false otherwise. Returns false for invalid or unparseable IPs.

func IsValidIP ¶

func IsValidIP(ipStr string) bool

IsValidIP checks whether the provided string is a valid IP address. It returns true for valid IPv4 or IPv6 addresses, and false otherwise.

func IsValidURL ¶

func IsValidURL(raw string) bool

IsValidURL checks whether a string is a valid absolute URL, containing a scheme (e.g., http) and a host.

func MakeHTTPRequest ¶

func MakeHTTPRequest(ctx context.Context, client HttpClient, request RequestEntity) (responseObject map[string]interface{}, err error)

MakeHTTPRequest sends an HTTP request to a remote URL using the provided configuration and returns the parsed JSON response as a map. Before performing the real network call, it optionally attempts to return a stubbed response if a StubID is specified and stubbing is enabled.

The function supports GET requests with query parameters, arbitrary HTTP headers, request bodies, and graceful handling of various response scenarios.

Parameters:

• client: An HttpClient interface (generally *http.Client) used to execute the request.
• request: A RequestEntity defining the URL, HTTP method, headers, optional query parameters, request body, and an optional StubID.

Behavior:

1. If request.StubID is non-empty, MakeHTTPRequest calls CallStub with the given ID. If stubbing is enabled and a matching stub is found, it immediately returns the stubbed response without making a real network call.
2. If no stub response is returned (either because stubs are disabled, the StubID doesn't match any stub, or StubID is empty), MakeHTTPRequest proceeds to make a real HTTP call via client.Do(...) using the provided URL, method, headers, and body.
3. On success, it attempts to parse the response body as JSON into a map[string]interface{}. The response is considered successful if it returns HTTP 200 (OK) or 201 (Created).
4. If the response status code is not 200 or 201, MakeHTTPRequest returns an error with the response's status text.
5. If parsing the JSON fails, it returns a JSON unmarshal error.
6. If the HTTP call returns an error or a nil response, that error is returned.

Typical Usage:

request := RequestEntity{
    Url:    "https://api.example.com/data",
    Method: http.MethodGet,
    QueryParams: map[string][]string{
        "filter": {"active"},
    },
    Headers: map[string]string{
        "Authorization": "Bearer token_here",
    },
    StubID: "stub-1234", // Optional: if set and stubs match, will return stubbed response
}

result, err := MakeHTTPRequest(ctx, httpClient, request)
if err != nil {
    log.Fatalf("Error making HTTP request: %v", err)
}
fmt.Printf("Received response: %v\n", result)

In testing or development:

• Set StubID and configure stubs via AddStub/CallStub to return predictable responses.
• Disable stubs or omit StubID to get real remote responses.

MakeHTTPRequest returns:

• (map[string]interface{}, error): On success, the parsed JSON response and no error; otherwise, an empty map and an error describing what went wrong.

func MaskIP ¶

func MaskIP(ipStr string) string

MaskIP returns a partially masked (anonymized) version of the IP address. For IPv4, the last two octets are replaced with asterisks (e.g., 192.168.*.*). For IPv6, all but the first two segments are masked (e.g., abcd:1234::*). If the IP is invalid, it returns an empty string.

This is useful for logging or displaying user IPs without revealing the full address.

func NormalizeIP ¶

func NormalizeIP(ip string) string

NormalizeIP trims spaces and normalizes the IP address string. It parses the input string and returns its canonical form. If the input is invalid, it returns an empty string.

Useful for cleaning up IP inputs before processing or logging.

func NormalizeURL ¶

func NormalizeURL(raw string) (string, error)

NormalizeURL parses and returns a normalized version of the input URL, stripping any fragment (anchor) part like "#section".

func ParseQuery ¶

func ParseQuery(query string) (map[string]string, error)

ParseQuery parses a URL-encoded query string into a map of key-value pairs. If a key has multiple values, only the first one is retained.

func ReadJsonPayload ¶

func ReadJsonPayload(r *http.Request) (map[string]interface{}, error)

ReadJsonPayload reads and parses the JSON-encoded body of an http.Request into a map. This function is used to extract data from requests with JSON payloads.

Parameters:

• r: Pointer to the http.Request that contains the JSON body to be read.

Returns:

• A map of string to interface{} that holds the JSON data.
• An error if the body cannot be read or the JSON data is malformed.

func ValidateAndFetchGetParams ¶

func ValidateAndFetchGetParams(r *http.Request, keys map[string]reflect.Kind) (map[string]interface{}, error)

ValidateAndFetchGetParams extracts and validates GET parameters from the request based on the provided keys map. It ensures that each key exists and converts it to the specified data type in the map.

Parameters:

• r: Pointer to the http.Request from which GET parameters are to be extracted.
• keys: Map specifying each key and its expected data type using reflect.Kind.

Returns:

• A map containing the validated parameter values.
• An error if a parameter is missing or cannot be converted to the expected type.

func ValidateAndFetchPostParams ¶

func ValidateAndFetchPostParams(r *http.Request, keys map[string]reflect.Kind) (map[string]interface{}, error)

ValidateAndFetchPostParams extracts and validates POST parameters from the request based on the provided keys map. Similar to ValidateAndFetchGetParams, it parses form data and ensures each key is present and correctly typed.

Parameters:

• r: Pointer to the http.Request from which POST parameters are to be extracted.
• keys: Map specifying each key and its expected data type using reflect.Kind.

Returns:

• A map containing the validated parameter values.
• An error if form data cannot be parsed, a parameter is missing, or conversion fails.