initial commit

Author: dstpierre

README.md

@@ -1,2 +1,2 @@
 # backend-go
-Go client library for StaticBackend
+Go client library for StaticBackend's backend API

account.go

@@ -0,0 +1,34 @@
+package backend
+
+type AccountParams struct {
+	Email    string `json:"email"`
+	Password string `json:"password"`
+}
+
+// Register creates a new user and returns their session token.
+func Register(email, password string) (string, error) {
+	body := AccountParams{
+		Email:    email,
+		Password: password,
+	}
+	var token string
+	if err := Post("", "/register", body, &token); err != nil {
+		return "", err
+	}
+
+	return token, nil
+}
+
+// Login authenticate a user and returns their session token
+func Login(email, password string) (string, error) {
+	body := AccountParams{
+		Email:    email,
+		Password: password,
+	}
+	var token string
+	if err := Post("", "/login", body, &token); err != nil {
+		return "", err
+	}
+
+	return token, nil
+}

account_test.go

@@ -0,0 +1,23 @@
+package backend_test
+
+import (
+	"testing"
+
+	"github.com/staticbackendhq/backend-go"
+)
+
+func TestRegisterAndLogin(t *testing.T) {
+	email, pass := "unit", "unit"
+
+	tok, err := backend.Register(email, pass)
+	if err != nil {
+		t.Error(err)
+	}
+
+	tok2, err := backend.Login(email, pass)
+	if err != nil {
+		t.Error(err)
+	} else if tok != tok2 {
+		t.Errorf("register/login tokens does not match, expected %s got %s", tok, tok2)
+	}
+}

client.go

@@ -0,0 +1,86 @@
+package backend
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"time"
+)
+
+// PublicKey is required for all HTTP requests.
+var (
+	PublicKey string
+	Verbose   bool
+	Region    string
+)
+
+func request(token, method, url, ct string, body io.Reader, v interface{}) error {
+	host := "http://localhost:8099"
+
+	start := time.Now()
+
+	req, err := http.NewRequest(method, fmt.Sprintf("%s%s", host, url), body)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", ct)
+
+	// We provide authentication
+	req.Header.Set("SB-PUBLIC-KEY", PublicKey)
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if Verbose {
+		fmt.Printf("%d\t%s\t%v\t%s bytes\n", res.StatusCode, url, time.Since(start), res.Header.Get("Content-Length"))
+	}
+
+	// Did we got an error
+	if res.StatusCode > 299 {
+		b, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return fmt.Errorf("error reading body: %v", err)
+		}
+
+		return fmt.Errorf("error returned by the backend: %s", string(b))
+	}
+
+	if res.Header.Get("Content-Type") == "application/json" {
+		if err := json.NewDecoder(res.Body).Decode(v); err != nil {
+			return fmt.Errorf("unable to decode the response body: %v", err)
+		}
+
+		return nil
+	}
+
+	b, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return fmt.Errorf("error reading body: %v", err)
+	}
+
+	v = b
+	return nil
+}
+
+// Get sends an HTTP GET request to the backend
+func Get(token, url string, v interface{}) error {
+	return request(token, http.MethodGet, url, "application/json", nil, v)
+}
+
+func Post(token, url string, body interface{}, v interface{}) error {
+	b, err := json.Marshal(body)
+	if err != nil {
+		return fmt.Errorf("error while encoding the body to JSON: %v", err)
+	}
+
+	buf := bytes.NewReader(b)
+	return request(token, "POST", url, "application/json", buf, v)
+}

client_test.go

@@ -0,0 +1,45 @@
+package backend_test
+
+import (
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/staticbackendhq/backend-go"
+)
+
+var token string
+
+func init() {
+	backend.PublicKey = "unit-test"
+
+	// this user is created by default in dev mod as an admin
+	t, err := backend.Login("[email protected]", "test123")
+	if err != nil {
+		log.Fatal("unable to login to the backend: ", err)
+	}
+
+	token = t
+}
+
+type Task struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+	Done bool   `json:"done"`
+}
+
+func TestGetRequest(t *testing.T) {
+	// we add a tmp doc
+	var insertedTask Task
+	if err := backend.Create(token, "pub_test", Task{Name: "test"}, &insertedTask); err != nil {
+		t.Error(err)
+	}
+
+	var s Task
+	u := fmt.Sprintf("/db/pub_test/%s", insertedTask.ID)
+	if err := backend.Get(token, u, &s); err != nil {
+		t.Error(err)
+	} else if insertedTask.ID != s.ID {
+		t.Errorf("expected inserted to be %s got %s", insertedTask.ID, s.ID)
+	}
+}

db.go

@@ -0,0 +1,49 @@
+package backend
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+)
+
+// Create adds a new document to a repository and returns the created document.
+func Create(token, repo string, body interface{}, v interface{}) error {
+	return Post(token, fmt.Sprintf("/db/%s", repo), body, v)
+}
+
+// ListParams are used to page results and sort.
+type ListParams struct {
+	Page       int
+	Size       int
+	Descending bool
+}
+
+// ListResult is used for list document
+type ListResult struct {
+	Page     int         `json:"page"`
+	PageSize int         `json:"size"`
+	Total    int         `json:"total"`
+	Results  interface{} `json:"results"`
+}
+
+// List returns a list of document in a specific repository.
+func List(token, repo string, v interface{}, params *ListParams) (meta ListResult, err error) {
+	meta.Results = v
+
+	qs := url.Values{}
+	if params != nil {
+		qs.Add("page", strconv.Itoa(params.Page))
+		qs.Add("size", strconv.Itoa(params.Size))
+		if params.Descending {
+			qs.Add("desc", "true")
+		}
+	}
+
+	err = Get(token, fmt.Sprintf("/db/%s?%s", repo, qs.Encode()), &meta)
+	return
+}
+
+// GetByID returns a specific document.
+func GetByID(token, repo, id string, v interface{}) error {
+	return Get(token, fmt.Sprintf("/db/%s/%s", repo, id), v)
+}

db_test.go

@@ -0,0 +1,27 @@
+package backend_test
+
+import (
+	"testing"
+
+	"github.com/staticbackendhq/backend-go"
+)
+
+func TestList(t *testing.T) {
+	// we add a tmp doc
+	var insertedTask Task
+	if err := backend.Create(token, "tasks", Task{Name: "test"}, &insertedTask); err != nil {
+		t.Error(err)
+	}
+
+	var results []Task
+	meta, err := backend.List(token, "tasks", &results, nil)
+	if err != nil {
+		t.Error(err)
+	} else if len(results) < 1 {
+		t.Errorf("expected tasks repo to have 1 doc got %d", len(results))
+	} else if meta.Total < 1 {
+		t.Errorf("expected total to be >= 1 goc %d", meta.Total)
+	} else if results[len(results)-1].ID != insertedTask.ID {
+		t.Errorf("expected last task ID to be %s got %s", insertedTask.ID, results[len(results)-1].ID)
+	}
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/staticbackendhq/backend-go
+
+go 1.15

storage.go

@@ -0,0 +1,46 @@
+package backend
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/url"
+)
+
+// StoreFile uploads a new file and returns its public URL using SB CDN.
+func StoreFile(token, filename string, file io.ReadSeeker) (string, error) {
+	// multipart form data
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+
+	fw, err := w.CreateFormFile("file", filename)
+	if err != nil {
+		return "", fmt.Errorf("error creating form field: %v", err)
+	}
+
+	if _, err := io.Copy(fw, file); err != nil {
+		return "", fmt.Errorf("error copying file data to form field: %v", err)
+	}
+
+	w.Close()
+
+	var fileURL string
+	if err := request(token, "POST", "/storage/upload", w.FormDataContentType(), &buf, &fileURL); err != nil {
+		return "", fmt.Errorf("error while uploading file: %v", err)
+	}
+
+	return fileURL, nil
+}
+
+// DownloadFile retrieves the file content as []byte
+func DownloadFile(token, fileURL string) ([]byte, error) {
+	u, err := url.Parse(fileURL)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf []byte
+	err = Get(token, u.Path, &buf)
+	return buf, err
+}

storage_test.go

@@ -0,0 +1,36 @@
+package backend_test
+
+import (
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/staticbackendhq/backend-go"
+)
+
+func TestUploadFile(t *testing.T) {
+	f, err := os.Open("storage_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	u, err := backend.StoreFile(token, "unittest.go", f)
+	if err != nil {
+		t.Error(err)
+	} else if strings.HasPrefix(u, "/_servefile_/") == false {
+		t.Errorf("expected URL to have http as prefix got %s", u)
+	}
+
+	orig, err := ioutil.ReadAll(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	buf, err := backend.DownloadFile(token, "http://localhost:8099"+u)
+	if err != nil {
+		t.Error(err)
+	} else if len(orig) != len(buf) {
+		t.Errorf("uploaded buffer and disk file differ, expected length %d got %d", len(orig), len(buf))
+	}
+}