Initial commit

pkg/message/msg.go

@@ -0,0 +1,26 @@
+package message
+
+import (
+	"encoding/json"
+)
+
+type Request struct {
+	Method  string
+	Streams []string
+}
+
+func PackOutgoingResponse(err error, message interface{}) ([]byte, error) {
+	res := make(map[string]interface{}, 1)
+	if err != nil {
+		res["error"] = err.Error()
+	} else {
+		res["success"] = message
+	}
+	return json.Marshal(res)
+}
+
+func PackOutgoingEvent(channel string, data interface{}) ([]byte, error) {
+	resp := make(map[string]interface{}, 1)
+	resp[channel] = data
+	return json.Marshal(resp)
+}

pkg/message/msg_test.go

@@ -0,0 +1,48 @@
+package message
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestMsg_Response(t *testing.T) {
+	t.Run("no error", func(t *testing.T) {
+		res, err := PackOutgoingResponse(nil, "ok")
+		fmt.Println(string(res))
+
+		if err != nil {
+			t.Fatal("Should not return error")
+		}
+
+		if string(res) != `{"success":"ok"}` {
+			t.Fatal("Response invalid")
+		}
+	})
+
+	t.Run("Some error", func(t *testing.T) {
+		res, err := PackOutgoingResponse(errors.New("Some Error"), "ok")
+		fmt.Println(string(res))
+
+		if err != nil {
+			t.Fatal("Should not return error")
+		}
+
+		if string(res) != `{"error":"Some Error"}` {
+			t.Fatal("Response invalid")
+		}
+	})
+}
+
+func TestMsg_Event(t *testing.T) {
+	res, err := PackOutgoingEvent("someMethod", "Hello")
+	fmt.Println(string(res))
+
+	if err != nil {
+		t.Fatal("Should not return error")
+	}
+
+	if string(res) != `{"someMethod":"Hello"}` {
+		t.Fatal("Event invalid")
+	}
+}

pkg/message/parser.go

@@ -0,0 +1,59 @@
+package message
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+func ParseRequest(msg []byte) (Request, error) {
+	request, err := Parse(msg)
+	if err != nil {
+		return request, err
+	}
+
+	return request, nil
+}
+
+func Parse(msg []byte) (Request, error) {
+	var v map[string]interface{}
+	var parsed Request
+
+	if err := json.Unmarshal(msg, &v); err != nil {
+		return parsed, fmt.Errorf("Could not parse message: %w", err)
+	}
+
+	switch v["event"] {
+	case "subscribe":
+		parsed.Method = "subscribe"
+		streams, ok := v["streams"]
+		if !ok {
+			return parsed, fmt.Errorf("No streams provided")
+		}
+		switch reflect.TypeOf(streams).Kind() {
+		case reflect.Slice:
+			streams := reflect.ValueOf(v["streams"])
+			for i := 0; i < streams.Len(); i++ {
+				parsed.Streams = append(parsed.Streams, streams.Index(i).Interface().(string))
+			}
+		}
+	case "unsubscribe":
+		parsed.Method = "unsubscribe"
+		streams, ok := v["streams"]
+		if !ok {
+			return parsed, fmt.Errorf("No streams provided")
+		}
+		switch reflect.TypeOf(streams).Kind() {
+		case reflect.Slice:
+			streams := reflect.ValueOf(v["streams"])
+			for i := 0; i < streams.Len(); i++ {
+				parsed.Streams = append(parsed.Streams, streams.Index(i).Interface().(string))
+			}
+		}
+	default:
+		return parsed, errors.New("Could not parse Type: Invalid event")
+	}
+
+	return parsed, nil
+}