api.go

package hyper

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/Hyper-Solutions/hyper-sdk-go/v4/internal"
	jsoniter "github.com/json-iterator/go"
	"github.com/mailru/easyjson"
	"github.com/mailru/easyjson/buffer"
	"github.com/mailru/easyjson/jwriter"
	"net/http"
)

func sendRequest[V easyjson.Marshaler, T easyjson.Unmarshaler](ctx context.Context, s *Session, url string, input V) (response T, err error) {
	response, _, err = sendRequestStatus[V, T](ctx, s, url, input)
	return response, err
}

// sendRequestStatus is sendRequest that also returns the response's status
// code, for the callers that act on it.
func sendRequestStatus[V easyjson.Marshaler, T easyjson.Unmarshaler](ctx context.Context, s *Session, url string, input V) (response T, status int, err error) {
	if s.ApiKey == "" {
		return response, 0, errors.New("missing api key")
	}

	w := jwriter.Writer{
		Flags:        0,
		Error:        nil,
		Buffer:       buffer.Buffer{},
		NoEscapeHTML: true,
	}

	input.MarshalEasyJSON(&w)

	if w.Error != nil {
		return response, 0, w.Error
	}
	payload := w.Buffer.BuildBytes()

	// Compress request payload if payload is large enough
	useCompression := false
	if len(payload) > 1000 {
		compressedPayload, err := compressPayload(payload, s.Compression)
		if err != nil {
			return response, 0, fmt.Errorf("failed to compress request body with %s: %w", s.Compression, err)
		}
		payload = compressedPayload
		useCompression = true
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(payload))
	if err != nil {
		return response, 0, err
	}

	req.Header.Set("content-type", "application/json")

	// Set request compression header if used
	if useCompression {
		req.Header.Set("content-encoding", string(s.Compression))
	}

	if err := s.setAuthHeaders(req); err != nil {
		return response, 0, err
	}

	resp, err := s.Client.Do(req)
	if err != nil {
		return response, 0, err
	}
	defer resp.Body.Close()

	respBody, release, err := internal.DecompressResponse(resp)
	defer release()
	if err != nil {
		return response, resp.StatusCode, err
	}

	if err := jsoniter.Unmarshal(respBody, &response); err != nil {
		return response, resp.StatusCode, err
	}

	return response, resp.StatusCode, nil
}

// setAuthHeaders sets the api key, the accepted response encoding and, when the
// session has them, the JWT and organization signatures.
func (s *Session) setAuthHeaders(req *http.Request) error {
	req.Header.Set("accept-encoding", string(s.Compression))
	req.Header.Set("x-api-key", s.ApiKey)

	if s.JwtKey != nil {
		signature, err := generateSignature(s.ApiKey, s.JwtKey)
		if err != nil {
			return err
		}
		req.Header.Set("x-signature", signature)
	}

	if s.AppSecret != nil {
		signature, err := generateSignature(s.AppKey, s.AppSecret)
		if err != nil {
			return err
		}
		req.Header.Set("x-app-signature", signature)
		req.Header.Set("x-app-key", s.AppKey)
	}

	return nil
}

// compressPayload compresses the payload using the specified compression algorithm
func compressPayload(payload []byte, compression CompressionType) ([]byte, error) {
	switch compression {
	case CompressionZstd:
		return internal.CompressZstd(payload)
	case CompressionGzip:
		return internal.CompressGzip(payload)
	default:
		return nil, fmt.Errorf("unsupported compression type: %s", compression)
	}
}