refactor: remove utils pkg

BREAKING CHANGE: utils package has been removed in favor of specific new
packages (http, crypto, strings)

pkg/http/cookie.go

@@ -0,0 +1,110 @@
+package http
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/gorilla/securecookie"
+)
+
+type CookieHandler struct {
+	securecookie *securecookie.SecureCookie
+	secureOnly   bool
+	sameSite     http.SameSite
+	maxAge       int
+	domain       string
+}
+
+func NewCookieHandler(hashKey, encryptKey []byte, opts ...CookieHandlerOpt) *CookieHandler {
+	c := &CookieHandler{
+		securecookie: securecookie.New(hashKey, encryptKey),
+		secureOnly:   true,
+		sameSite:     http.SameSiteLaxMode,
+	}
+
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c
+}
+
+type CookieHandlerOpt func(*CookieHandler)
+
+func WithUnsecure() CookieHandlerOpt {
+	return func(c *CookieHandler) {
+		c.secureOnly = false
+	}
+}
+
+func WithSameSite(sameSite http.SameSite) CookieHandlerOpt {
+	return func(c *CookieHandler) {
+		c.sameSite = sameSite
+	}
+}
+
+func WithMaxAge(maxAge int) CookieHandlerOpt {
+	return func(c *CookieHandler) {
+		c.maxAge = maxAge
+		c.securecookie.MaxAge(maxAge)
+	}
+}
+
+func WithDomain(domain string) CookieHandlerOpt {
+	return func(c *CookieHandler) {
+		c.domain = domain
+	}
+}
+
+func (c *CookieHandler) CheckCookie(r *http.Request, name string) (string, error) {
+	cookie, err := r.Cookie(name)
+	if err != nil {
+		return "", err
+	}
+	var value string
+	if err := c.securecookie.Decode(name, cookie.Value, &value); err != nil {
+		return "", err
+	}
+	return value, nil
+}
+
+func (c *CookieHandler) CheckQueryCookie(r *http.Request, name string) (string, error) {
+	value, err := c.CheckCookie(r, name)
+	if err != nil {
+		return "", err
+	}
+	if value != r.FormValue(name) {
+		return "", errors.New(name + " does not compare")
+	}
+	return value, nil
+}
+
+func (c *CookieHandler) SetCookie(w http.ResponseWriter, name, value string) error {
+	encoded, err := c.securecookie.Encode(name, value)
+	if err != nil {
+		return err
+	}
+	http.SetCookie(w, &http.Cookie{
+		Name:     name,
+		Value:    encoded,
+		Domain:   c.domain,
+		Path:     "/",
+		MaxAge:   c.maxAge,
+		HttpOnly: true,
+		Secure:   c.secureOnly,
+		SameSite: c.sameSite,
+	})
+	return nil
+}
+
+func (c *CookieHandler) DeleteCookie(w http.ResponseWriter, name string) {
+	http.SetCookie(w, &http.Cookie{
+		Name:     name,
+		Value:    "",
+		Domain:   c.domain,
+		Path:     "/",
+		MaxAge:   -1,
+		HttpOnly: true,
+		Secure:   c.secureOnly,
+		SameSite: c.sameSite,
+	})
+}

pkg/http/http.go

@@ -0,0 +1,107 @@
+package http
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+var (
+	DefaultHTTPClient = &http.Client{
+		Timeout: 30 * time.Second,
+	}
+)
+
+type Decoder interface {
+	Decode(dst interface{}, src map[string][]string) error
+}
+type Encoder interface {
+	Encode(src interface{}, dst map[string][]string) error
+}
+
+type FormAuthorization func(url.Values)
+type RequestAuthorization func(*http.Request)
+
+func AuthorizeBasic(user, password string) RequestAuthorization {
+	return func(req *http.Request) {
+		req.SetBasicAuth(url.QueryEscape(user), url.QueryEscape(password))
+	}
+}
+
+func FormRequest(endpoint string, request interface{}, encoder Encoder, authFn interface{}) (*http.Request, error) {
+	form := url.Values{}
+	if err := encoder.Encode(request, form); err != nil {
+		return nil, err
+	}
+	if fn, ok := authFn.(FormAuthorization); ok {
+		fn(form)
+	}
+	body := strings.NewReader(form.Encode())
+	req, err := http.NewRequest("POST", endpoint, body)
+	if err != nil {
+		return nil, err
+	}
+	if fn, ok := authFn.(RequestAuthorization); ok {
+		fn(req)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	return req, nil
+}
+
+func HttpRequest(client *http.Client, req *http.Request, response interface{}) error {
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("unable to read response body: %v", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("http status not ok: %s %s", resp.Status, body)
+	}
+
+	err = json.Unmarshal(body, response)
+	if err != nil {
+		return fmt.Errorf("failed to unmarshal response: %v %s", err, body)
+	}
+	return nil
+}
+
+func URLEncodeResponse(resp interface{}, encoder Encoder) (string, error) {
+	values := make(map[string][]string)
+	err := encoder.Encode(resp, values)
+	if err != nil {
+		return "", err
+	}
+	v := url.Values(values)
+	return v.Encode(), nil
+}
+
+func StartServer(ctx context.Context, port string) {
+	server := &http.Server{Addr: port}
+	go func() {
+		if err := server.ListenAndServe(); err != http.ErrServerClosed {
+			log.Fatalf("ListenAndServe(): %v", err)
+		}
+	}()
+
+	go func() {
+		<-ctx.Done()
+		ctxShutdown, cancelShutdown := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancelShutdown()
+		err := server.Shutdown(ctxShutdown)
+		if err != nil {
+			log.Fatalf("Shutdown(): %v", err)
+		}
+	}()
+}

pkg/http/marshal.go

@@ -0,0 +1,33 @@
+package http
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+func MarshalJSON(w http.ResponseWriter, i interface{}) {
+	MarshalJSONWithStatus(w, i, http.StatusOK)
+}
+
+func MarshalJSONWithStatus(w http.ResponseWriter, i interface{}, status int) {
+	w.Header().Set("content-type", "application/json")
+	w.WriteHeader(status)
+	err := json.NewEncoder(w).Encode(i)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func ConcatenateJSON(first, second []byte) ([]byte, error) {
+	if !bytes.HasSuffix(first, []byte{'}'}) {
+		return nil, fmt.Errorf("jws: invalid JSON %s", first)
+	}
+	if !bytes.HasPrefix(second, []byte{'{'}) {
+		return nil, fmt.Errorf("jws: invalid JSON %s", second)
+	}
+	first[len(first)-1] = ','
+	first = append(first, second[1:]...)
+	return first, nil
+}

pkg/http/marshal_test.go

@@ -0,0 +1,60 @@
+package http
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestConcatenateJSON(t *testing.T) {
+	type args struct {
+		first  []byte
+		second []byte
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    []byte
+		wantErr bool
+	}{
+		{
+			"invalid first part, error",
+			args{
+				[]byte(`invalid`),
+				[]byte(`{"some": "thing"}`),
+			},
+			nil,
+			true,
+		},
+		{
+			"invalid second part, error",
+			args{
+				[]byte(`{"some": "thing"}`),
+				[]byte(`invalid`),
+			},
+			nil,
+			true,
+		},
+		{
+			"both valid, merged",
+			args{
+				[]byte(`{"some": "thing"}`),
+				[]byte(`{"another": "thing"}`),
+			},
+
+			[]byte(`{"some": "thing","another": "thing"}`),
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ConcatenateJSON(tt.args.first, tt.args.second)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ConcatenateJSON() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !bytes.Equal(got, tt.want) {
+				t.Errorf("ConcatenateJSON() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}