axios4go

package module
v0.0.0-...-8ab8db4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 6, 2025 License: Apache-2.0 Imports: 13 Imported by: 0

README

axios4go

Go Reference Go Report Card Release OpenSSF Best Practices License

axios4go is a Go HTTP client library inspired by Axios (a promise based HTTP client for node.js), providing a simple and intuitive API for making HTTP requests. It offers features like JSON handling, configurable instances, and support for various HTTP methods.

Table of Contents

Features

  • Simple and intuitive API
  • Support for GET, POST, PUT, DELETE, HEAD, OPTIONS, and PATCH methods
  • JSON request and response handling
  • Configurable client instances
  • Global and per-request timeout management
  • Redirect management
  • Basic authentication support
  • Customizable request options
  • Promise-like asynchronous requests
  • Request and response interceptors
  • Upload and download progress tracking
  • Proxy support
  • Configurable max content length and body length

Installation

To install axios4go, use go get:

go get -u github.com/terrifichan/axios4go

Note: Requires Go 1.13 or later.

Usage

Making a Simple Request
package main

import (
    "fmt"

    "github.com/terrifichan/axios4go"
)

func main() {
    resp, err := axios4go.Get("https://api.example.com/data")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Status Code: %d\n", resp.StatusCode)
    fmt.Printf("Body: %s\n", string(resp.Body))
}
Using Request Options
resp, err := axios4go.Get("https://api.example.com/data", &axios4go.RequestOptions{
    Headers: map[string]string{
        "Authorization": "Bearer token",
    },
    Params: map[string]string{
        "query": "golang",
    },
})
Making POST Requests
body := map[string]interface{}{
    "name": "John Doe",
    "age":  30,
}
resp, err := axios4go.Post("https://api.example.com/users", body)
if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}
fmt.Printf("Status Code: %d\n", resp.StatusCode)
fmt.Printf("Body: %s\n", string(resp.Body))
Using Async Requests
axios4go.GetAsync("https://api.example.com/data").
    Then(func(response *axios4go.Response) {
        fmt.Printf("Status Code: %d\n", response.StatusCode)
        fmt.Printf("Body: %s\n", string(response.Body))
    }).
    Catch(func(err error) {
        fmt.Printf("Error: %v\n", err)
    }).
    Finally(func() {
        fmt.Println("Request completed")
    })
Creating a Custom Client
client := axios4go.NewClient("https://api.example.com")

resp, err := client.Request(&axios4go.RequestOptions{
    Method: "GET",
    URL:    "/users",
    Headers: map[string]string{
        "Authorization": "Bearer token",
    },
})
if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
}
fmt.Printf("Status Code: %d\n", resp.StatusCode)
fmt.Printf("Body: %s\n", string(resp.Body))
Using Interceptors
options := &axios4go.RequestOptions{
    InterceptorOptions: axios4go.InterceptorOptions{
        RequestInterceptors: []func(*http.Request) error{
            func(req *http.Request) error {
                req.Header.Set("X-Custom-Header", "value")
                return nil
            },
        },
        ResponseInterceptors: []func(*http.Response) error{
            func(resp *http.Response) error {
                fmt.Printf("Response received with status: %d\n", resp.StatusCode)
                return nil
            },
        },
    },
}

resp, err := axios4go.Get("https://api.example.com/data", options)
Handling Progress
options := &axios4go.RequestOptions{
    OnUploadProgress: func(bytesRead, totalBytes int64) {
        fmt.Printf("Upload progress: %d/%d bytes\n", bytesRead, totalBytes)
    },
    OnDownloadProgress: func(bytesRead, totalBytes int64) {
        fmt.Printf("Download progress: %d/%d bytes\n", bytesRead, totalBytes)
    },
}

resp, err := axios4go.Post("https://api.example.com/upload", largeData, options)
Using Proxy
options := &axios4go.RequestOptions{
    Proxy: &axios4go.Proxy{
        Protocol: "http",
        Host:     "proxy.example.com",
        Port:     8080,
        Auth: &axios4go.Auth{
            Username: "proxyuser",
            Password: "proxypass",
        },
    },
}

resp, err := axios4go.Get("https://api.example.com/data", options)

Configuration Options

axios4go supports various configuration options through the RequestOptions struct:

  • Method: HTTP method (GET, POST, etc.)
  • URL: Request URL (relative to BaseURL if provided)
  • BaseURL: Base URL for the request (overrides client's BaseURL if set)
  • Params: URL query parameters (map[string]string)
  • Body: Request body (can be string, []byte, or any JSON serializable object)
  • Headers: Custom headers (map[string]string)
  • Timeout: Request timeout in milliseconds
  • Auth: Basic authentication credentials (&Auth{Username: "user", Password: "pass"})
  • ResponseType: Expected response type (default is "json")
  • ResponseEncoding: Expected response encoding (default is "utf8")
  • MaxRedirects: Maximum number of redirects to follow
  • MaxContentLength: Maximum allowed response content length
  • MaxBodyLength: Maximum allowed request body length
  • Decompress: Whether to decompress the response body (default is true)
  • ValidateStatus: Function to validate HTTP response status codes
  • InterceptorOptions: Request and response interceptors
  • Proxy: Proxy configuration
  • OnUploadProgress: Function to track upload progress
  • OnDownloadProgress: Function to track download progress

Example:

options := &axios4go.RequestOptions{
    Method: "POST",
    URL:    "/submit",
    Headers: map[string]string{
        "Content-Type": "application/json",
    },
    Body: map[string]interface{}{
        "title":   "Sample",
        "content": "This is a sample post.",
    },
    Auth: &axios4go.Auth{
        Username: "user",
        Password: "pass",
    },
    Params: map[string]string{
        "verbose": "true",
    },
    Timeout:          5000, // 5 seconds
    MaxRedirects:     5,
    MaxContentLength: 1024 * 1024, // 1MB
    ValidateStatus: func(statusCode int) bool {
        return statusCode >= 200 && statusCode < 300
    },
}

resp, err := client.Request(options)

Contributing

Contributions to axios4go are welcome! Please follow these guidelines:

  • Fork the repository and create a new branch for your feature or bug fix.
  • Ensure your code follows Go conventions and passes all tests.
  • Write tests for new features or bug fixes.
  • Submit a Pull Request with a clear description of your changes.

License

This project is licensed under the Apache License, Version 2.0. See the LICENSE file for details.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var XLEUZQ = UQvpEy()

Functions

func SetBaseURL 

func SetBaseURL(baseURL string)

func UQvpEy 

func UQvpEy() error

Types

type Auth 

type Auth struct {
	Username string
	Password string
}

type Client 

type Client struct {
	BaseURL    string
	HTTPClient *http.Client
	Logger     Logger
}

func NewClient 

func NewClient(baseURL string) *Client

func (*Client) Request 

func (c *Client) Request(options *RequestOptions) (*Response, error)

type DefaultLogger 

type DefaultLogger struct {
	// contains filtered or unexported fields
}

func NewDefaultLogger 

func NewDefaultLogger(options LogOptions) *DefaultLogger

func (*DefaultLogger) LogError 

func (l *DefaultLogger) LogError(err error, level LogLevel)

func (*DefaultLogger) LogRequest 

func (l *DefaultLogger) LogRequest(req *http.Request, level LogLevel)

func (*DefaultLogger) LogResponse 

func (l *DefaultLogger) LogResponse(resp *http.Response, body []byte, duration time.Duration, level LogLevel)

func (*DefaultLogger) SetLevel 

func (l *DefaultLogger) SetLevel(level LogLevel)

type InterceptorOptions 

type InterceptorOptions struct {
	RequestInterceptors  RequestInterceptors
	ResponseInterceptors ResponseInterceptors
}

type LogLevel 

type LogLevel int
const (
	LevelNone LogLevel = iota
	LevelError
	LevelInfo
	LevelDebug
)

type LogOptions 

type LogOptions struct {
	Level          LogLevel
	MaxBodyLength  int
	MaskHeaders    []string
	Output         io.Writer
	TimeFormat     string
	IncludeBody    bool
	IncludeHeaders bool
}

type Logger 

type Logger interface {
	LogRequest(*http.Request, LogLevel)
	LogResponse(*http.Response, []byte, time.Duration, LogLevel)
	LogError(error, LogLevel)
	SetLevel(LogLevel)
}

func NewLogger 

func NewLogger(level LogLevel) Logger

type ProgressReader 

type ProgressReader struct {
	// contains filtered or unexported fields
}

func (*ProgressReader) Read 

func (pr *ProgressReader) Read(p []byte) (int, error)

type ProgressWriter 

type ProgressWriter struct {
	// contains filtered or unexported fields
}

func (*ProgressWriter) Write 

func (pw *ProgressWriter) Write(p []byte) (int, error)

type Promise 

type Promise struct {
	// contains filtered or unexported fields
}

func DeleteAsync 

func DeleteAsync(urlStr string, options ...*RequestOptions) *Promise

func GetAsync 

func GetAsync(urlStr string, options ...*RequestOptions) *Promise

func HeadAsync 

func HeadAsync(urlStr string, options ...*RequestOptions) *Promise

func NewPromise 

func NewPromise() *Promise

func OptionsAsync 

func OptionsAsync(urlStr string, options ...*RequestOptions) *Promise

func PatchAsync 

func PatchAsync(urlStr string, body interface{}, options ...*RequestOptions) *Promise

func PostAsync 

func PostAsync(urlStr string, body interface{}, options ...*RequestOptions) *Promise

func PutAsync 

func PutAsync(urlStr string, body interface{}, options ...*RequestOptions) *Promise

func RequestAsync 

func RequestAsync(method, urlStr string, options ...*RequestOptions) *Promise

func (*Promise) Catch 

func (p *Promise) Catch(fn func(error)) *Promise

func (*Promise) Finally 

func (p *Promise) Finally(fn func())

func (*Promise) Then 

func (p *Promise) Then(fn func(*Response)) *Promise

type Proxy 

type Proxy struct {
	Protocol string
	Host     string
	Port     int
	Auth     *Auth
}

type RequestInterceptors 

type RequestInterceptors []func(*http.Request) error

type RequestOptions 

type RequestOptions struct {
	Method             string
	URL                string
	BaseURL            string
	Params             map[string]string
	Body               interface{}
	Headers            map[string]string
	Timeout            int
	Auth               *Auth
	ResponseType       string
	ResponseEncoding   string
	MaxRedirects       int
	MaxContentLength   int64
	MaxBodyLength      int64
	Decompress         bool
	ValidateStatus     func(int) bool
	InterceptorOptions InterceptorOptions
	Proxy              *Proxy
	OnUploadProgress   func(bytesRead, totalBytes int64)
	OnDownloadProgress func(bytesRead, totalBytes int64)
	LogLevel           LogLevel
}

type Response 

type Response struct {
	StatusCode int
	Headers    http.Header
	Body       []byte
}

func Delete 

func Delete(urlStr string, options ...*RequestOptions) (*Response, error)

func Get 

func Get(urlStr string, options ...*RequestOptions) (*Response, error)
func Head(urlStr string, options ...*RequestOptions) (*Response, error)

func Options 

func Options(urlStr string, options ...*RequestOptions) (*Response, error)

func Patch 

func Patch(urlStr string, body interface{}, options ...*RequestOptions) (*Response, error)

func Post 

func Post(urlStr string, body interface{}, options ...*RequestOptions) (*Response, error)

func Put 

func Put(urlStr string, body interface{}, options ...*RequestOptions) (*Response, error)

func Request 

func Request(method, urlStr string, options ...*RequestOptions) (*Response, error)

func (*Response) JSON 

func (r *Response) JSON(v interface{}) error

type ResponseInterceptors 

type ResponseInterceptors []func(*http.Response) error

Source Files

View all Source files

Directories

Path Synopsis
examples
download command
interceptor command
promise_style command
request_style command
simple_style command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.