Add rate limit logic

Author: lcd1232

client.go

@@ -1,6 +1,11 @@
 package temp_mail_go
 
-import "net/http"
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+)
 
 type doer interface {
 	Do(req *http.Request) (*http.Response, error)
@@ -14,6 +19,8 @@ type Client struct {
 	apiKey string
 }
 
+const baseURL = "https://api.temp-mail.io"
+
 // NewClient creates ready to use Client.
 func NewClient(apiKey string, client *http.Client) *Client {
 	if client == nil {
@@ -24,3 +31,38 @@ func NewClient(apiKey string, client *http.Client) *Client {
 		apiKey: apiKey,
 	}
 }
+
+// newRequest creates a new HTTP request.
+func (c *Client) newRequest(ctx context.Context, method, path string, body io.Reader) (*http.Request, error) {
+	req, err := http.NewRequestWithContext(ctx, method, baseURL+path, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("X-API-Key", c.apiKey)
+	return req, nil
+}
+
+// do sends an HTTP request and decodes the response.
+func (c *Client) do(req *http.Request, v interface{}) error {
+	resp, err := c.doer.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		var httpErr HTTPError
+		if err := json.NewDecoder(resp.Body).Decode(&httpErr); err != nil {
+			return err
+		}
+		return &httpErr
+	}
+
+	if v != nil {
+		if err := json.NewDecoder(resp.Body).Decode(v); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

error.go

@@ -0,0 +1,51 @@
+package temp_mail_go
+
+import (
+	"fmt"
+	"io"
+)
+
+// HTTPError is the error response that will be returned by the API.
+type HTTPError struct {
+	ErrorDetails HTTPErrorError `json:"error"`
+	Meta         HTTPErrorMeta  `json:"meta"`
+}
+
+type HTTPErrorError struct {
+	// Type is the type of the error.
+	// Possible values: api_error, request_error.
+	Type string `json:"type"`
+	// Code is the error code.
+	Code string `json:"code"`
+	// Detail is the error message.
+	Detail string `json:"detail"`
+}
+
+type HTTPErrorMeta struct {
+	RequestID string `json:"request_id"`
+}
+
+func (h *HTTPError) Error() string {
+	return fmt.Sprintf("error: %s, code: %s, detail: %s", h.ErrorDetails.Type, h.ErrorDetails.Code, h.ErrorDetails.Detail)
+}
+
+func (h *HTTPError) fullError() string {
+	return fmt.Sprintf("error: %s, code: %s, detail: %s, request_id: %s", h.ErrorDetails.Type, h.ErrorDetails.Code, h.ErrorDetails.Detail, h.Meta.RequestID)
+}
+
+// Format implements fmt.Formatter interface.
+// It adds request ID to the error message when called with %+v verb.
+func (h *HTTPError) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			_, _ = io.WriteString(s, h.fullError())
+			return
+		}
+		fallthrough
+	case 's':
+		_, _ = io.WriteString(s, h.Error())
+	case 'q':
+		_, _ = fmt.Fprintf(s, "%q", h.Error())
+	}
+}

example_test.go

@@ -0,0 +1,16 @@
+package temp_mail_go
+
+import (
+	"context"
+	"fmt"
+)
+
+func ExampleClient_RateLimit() {
+	c := NewClient("YOUR_API_KEY", nil)
+	resp, err := c.RateLimit(context.Background())
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("limit: %d, used: %d, remaining: %d, reset: %d", resp.Limit, resp.Used, resp.Remaining, resp.Reset)
+	// Output: limit: 1000, used: 0, remaining: 1000, reset: 1738367999
+}

rate_limit.go

@@ -0,0 +1,29 @@
+package temp_mail_go
+
+import "context"
+
+type RateLimitResponse struct {
+	// Limit is the maximum number of requests that you can make per period.
+	Limit int64 `json:"limit"`
+	// Used is the number of requests you have made in the current rate limit window.
+	Used int64 `json:"used"`
+	// Remaining is the number of requests remaining in the current rate limit window.
+	Remaining int64 `json:"remaining"`
+	// Reset is the time at which the current rate limit window resets, in UTC epoch seconds.
+	Reset int64 `json:"reset"`
+}
+
+// RateLimit returns the current rate limit for the client.
+func (c *Client) RateLimit(ctx context.Context) (RateLimitResponse, error) {
+	req, err := c.newRequest(ctx, "GET", "/v1/rate_limit", nil)
+	if err != nil {
+		return RateLimitResponse{}, err
+	}
+
+	var resp RateLimitResponse
+	if err := c.do(req, &resp); err != nil {
+		return RateLimitResponse{}, err
+	}
+
+	return resp, nil
+}