First Commit

internal/api/client.go

@@ -0,0 +1,125 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"git.aiterp.net/rpdata/logbot3/internal/config"
+	jwt "github.com/dgrijalva/jwt-go"
+)
+
+type queryData struct {
+	Query     string                 `json:"query"`
+	Variables map[string]interface{} `json:"variables"`
+}
+
+type queryResponse struct {
+	Errors QueryErrorList  `json:"errors"`
+	Data   json.RawMessage `json:"data"`
+}
+
+// A Client is a client for the rpdata API
+type Client struct {
+	http      *http.Client
+	endpoint  string
+	username  string
+	keyID     string
+	keySecret string
+}
+
+func (client *Client) sign(permissions []string) (token string, err error) {
+	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"kid":         "bar",
+		"user":        client.username,
+		"permissions": permissions,
+		"exp":         time.Now().Add(time.Second * 30).Unix(),
+	})
+	jwtToken.Header["kid"] = client.keyID
+
+	return jwtToken.SignedString([]byte(client.keySecret))
+}
+
+// Query sends a query or mutation to the server. The returned value is the data element.
+func (client *Client) Query(ctx context.Context, query string, variables map[string]interface{}, permissions []string) (data json.RawMessage, err error) {
+	// Get token
+	token, err := client.sign(permissions)
+	if err != nil {
+		return
+	}
+
+	// Make body
+	qdata := queryData{
+		Query:     query,
+		Variables: variables,
+	}
+	buffer := bytes.NewBuffer(make([]byte, 0, 256))
+	err = json.NewEncoder(buffer).Encode(&qdata)
+	if err != nil {
+		return
+	}
+
+	// Make request
+	req, err := http.NewRequest("POST", client.endpoint, buffer)
+	if err != nil {
+		return
+	}
+	req = req.WithContext(ctx)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	// Run request
+	res, err := client.http.Do(req)
+	if err != nil {
+		return
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode >= 500 {
+		stuff, _ := ioutil.ReadAll(res.Body)
+		fmt.Println(string(stuff))
+		return nil, errors.New("Internal srever error")
+	}
+
+	// Parse response
+	resData := queryResponse{}
+	err = json.NewDecoder(res.Body).Decode(&resData)
+	if err != nil {
+		return
+	}
+
+	if len(resData.Errors) > 0 {
+		err = resData.Errors
+		return
+	}
+
+	return resData.Data, nil
+}
+
+// New makes a new client.
+func New(endpoint, username, keyID, keySecret string) *Client {
+	return &Client{
+		http:      &http.Client{Timeout: 60 * time.Second},
+		endpoint:  endpoint,
+		username:  username,
+		keyID:     keyID,
+		keySecret: keySecret,
+	}
+}
+
+// Global gets the global client, from the config file.
+func Global() *Client {
+	conf := config.Get()
+	return &Client{
+		http:      &http.Client{Timeout: 60 * time.Second},
+		endpoint:  conf.API.Endpoint,
+		username:  conf.API.Username,
+		keyID:     conf.API.Key.ID,
+		keySecret: conf.API.Key.Secret,
+	}
+}

internal/api/error.go

@@ -0,0 +1,35 @@
+package api
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A QueryError is a GraphQL error.
+type QueryError struct {
+	Message string   `json:"message"`
+	Path    []string `json:"path"`
+}
+
+func (err QueryError) Error() string {
+	return fmt.Sprintf("GraphQL: %s: %s", strings.Join(err.Path, "."), err.Message)
+}
+
+func (err QueryError) String() string {
+	return err.Error()
+}
+
+// QueryErrorList is a list of query errors
+type QueryErrorList []QueryError
+
+func (errs QueryErrorList) Error() string {
+	if len(errs) == 1 {
+		return errs[0].Error()
+	}
+
+	return fmt.Sprintf("%s (+%d others)", errs[0].Error(), len(errs)-1)
+}
+
+func (errs QueryErrorList) String() string {
+	return errs.Error()
+}