request

Installation

$ go get -u github.com/yeldisbayev/request

Example usage

package main

import (
	"context"
	"io"
	"log"
	"request"
)

type Todo struct {
	ID        int64  `json:"id"`
	UserID    int64  `json:"userID"`
	Title     string `json:"title"`
	Completed bool   `json:"completed"`
}

func main() {
	client := request.NewClient()

	res, err := client.Request().Get(context.Background(), "https://jsonplaceholder.typicode.com/todos/1")
	if err != nil {
		log.Fatalf("Request error: %v", err)
	}

	defer func(body io.ReadCloser) {
		_ = body.Close()
	}(res.Body)

	var todo Todo

	if res.IsSuccess() {
		if err := res.Decoder().Decode(&todo); err != nil {
			log.Fatalf("Decode error: %v", err)
		}
	}

	log.Printf(
		"todo = (id: %d, userId: %d, title: %s, completed: %t)",
		todo.ID,
		todo.UserID,
		todo.Title,
		todo.Completed,
	)

}

Client

Options

There is Options to set up Client

WithTimeout

Sets timeout for all client requests. Timeout implemented without using http.Client's Timeout property, but with context. Client timeout has lesser priority than Request timeout property. If not provided, DefaultTimeout is used.

timeout := time.Second * 5

client := request.NewClient(request.WithTimeout(timeout))

WithIdleConnectionTimeout

Controls amount of time an idle (keep-alive) connection will remain idle before closing itself. If not provided, DefaultIdleConnectionTimeout is used.

idleConnectionTimeout := time.Second * 30

client := request.NewClient(request.WithIdleConnectionTimeout(idleConnectionTimeout))

WithMaxIdleConnections

Controls the maximum number of idle (keep-alive) connections across all hosts. If not provided, DefaultMaxIdleConnections is used.

maxIdleConnections := 20

client := request.NewClient(request.WithMaxIdleConnections(maxIdleConnections))

WithMaxConnectionsPerHost

Optionally limits the total number of connections per host, including connections in the dialing, active, and idle states. On limit violation, dials will block. If not provided, DefaultMaxConnectionsPerHost is used.

maxConnectionsPerHost := 30

client := request.NewClient(request.WithMaxConnectionsPerHost(maxConnectionsPerHost))

WithMaxIdleConnectionsPerHost

Controls the maximum idle (keep-alive) connections to keep per-host. If not provided, DefaultMaxIdleConnectionsPerHost is used.

maxIdleConnectionsPerHost := 30

client := request.NewClient(request.WithMaxIdleConnectionsPerHost(maxIdleConnectionsPerHost))

WithForceAttemptHTTP2

Controls whether HTTP/2 is enabled when a non-zero Dial, DialTLS, or DialContext func or TLSClientConfig is provided. By default, use of any those fields conservatively disables HTTP/2. To use a custom dialer or TLS config and still attempt HTTP/2 upgrades, set this to true. If not provided, DefaultForceAttemptHTTP2 is used.

forceAttemptHTTP2 := true

client := request.NewClient(request.WithForceAttemptHTTP2(forceAttemptHTTP2))

WithInterceptors

Wraps Client with given interceptors

retry := request.Retry()

client := request.NewClient(request.WithInterceptors(retry))

Interceptor

Interceptor wraps http Transport and calls before or after due to client usage. In order to create custom one Interceptor function implementation is needed. There is also built in Retry interceptor and its should be at the end in interceptors chain.

package main

import (
	"context"
	"io"
	"log"
	"net/http"
	"request"
	"time"
)

func FirstInterceptor(rt http.RoundTripper) http.RoundTripper {
	return req.RoundTripper( // Wrap custom interceptor with req.RoundTripper
		func(req *http.Request) (res *http.Response, err error) {
			// Before request started
			log.Println("FirstInterceptor started")

			res, err = rt.RoundTrip(req)
            
			// After request completed
			log.Println("FirstInterceptor finished")

			return res, err

		},
	)
}

func SecondInterceptor(rt http.RoundTripper) http.RoundTripper {
	return req.RoundTripper( // Wrap custom interceptor with req.RoundTripper
		func(req *http.Request) (res *http.Response, err error) {
			// Before request started
			log.Println("SecondInterceptor started")
			startTime := time.Now()

			res, err = rt.RoundTrip(req)

			// After request completed
			log.Println("SecondInterceptor", "Request Duration", time.Since(startTime))
			log.Println("SecondInterceptor finished")

			return res, err

		},
	)
}

type Todo struct {
	ID        int64  `json:"id"`
	UserID    int64  `json:"userID"`
	Title     string `json:"title"`
	Completed bool   `json:"completed"`
}

func main() {
	client := request.NewClient(
		request.WithInterceptors(FirstInterceptor, SecondInterceptor), 
	)

	res, err := client.Request().Get(context.Background(), "https://jsonplaceholder.typicode.com/todos/1")
	if err != nil {
		log.Fatalf("Request error: %v", err)
	}

	defer func(body io.ReadCloser) {
		_ = body.Close()
	}(res.Body)

	var todo Todo

	if res.IsSuccess() {
		if err := res.Decoder().Decode(&todo); err != nil {
			log.Fatalf("Decode error: %v", err)
		}
	}

	log.Println(todo)

}

 FirstInterceptor started
 
 SecondInterceptor started
 
 SecondInterceptor Request Duration 697.908708ms
 
 SecondInterceptor finished
 
 FirstInterceptor finished
 
 {1 1 delectus aut autem false}

License

MIT License

Copyright (c) 2024 Duisen Yeldisbayev

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.