dicedb#500: Added JSON.RESP Command (dicedb#751)

Author: psrvere

integration_tests/commands/async/jsonresp_test.go

@@ -0,0 +1,62 @@
+package async
+
+import (
+	"testing"
+
+	testifyAssert "github.com/stretchr/testify/assert"
+	"gotest.tools/v3/assert"
+)
+
+func TestJSONRESP(t *testing.T) {
+	conn := getLocalConnection()
+	defer conn.Close()
+	FireCommand(conn, "DEL key")
+
+	arrayAtRoot := `["dice",10,10.5,true,null]`
+	object := `{"b":["dice",10,10.5,true,null]}`
+
+	testCases := []struct {
+		name        string
+		commands    []string
+		expected    []interface{}
+		assert_type []string
+		jsonResp    []bool
+		nestedArray bool
+		path        string
+	}{
+		{
+			name:        "print array with mixed types",
+			commands:    []string{"json.set key $ " + arrayAtRoot, "json.resp key $"},
+			expected:    []interface{}{"OK", []interface{}{"[", "dice", int64(10), "10.5", "true", "(nil)"}},
+			assert_type: []string{"equal", "equal"},
+		},
+		{
+			name:        "print nested array with mixed types",
+			commands:    []string{"json.set key $ " + object, "json.resp key $.b"},
+			expected:    []interface{}{"OK", []interface{}{[]interface{}{"[", "dice", int64(10), "10.5", "true", "(nil)"}}},
+			assert_type: []string{"equal", "equal"},
+		},
+		{
+			name:        "print object at root path",
+			commands:    []string{"json.set key $ " + object, "json.resp key"},
+			expected:    []interface{}{"OK", []interface{}{"{", "b", []interface{}{"[", "dice", int64(10), "10.5", "true", "(nil)"}}},
+			assert_type: []string{"equal", "equal"},
+		},
+	}
+
+	for _, tcase := range testCases {
+		t.Run(tcase.name, func(t *testing.T) {
+			for i := 0; i < len(tcase.commands); i++ {
+				cmd := tcase.commands[i]
+				out := tcase.expected[i]
+				result := FireCommand(conn, cmd)
+
+				if tcase.assert_type[i] == "equal" {
+					testifyAssert.Equal(t, out, result)
+				} else if tcase.assert_type[i] == "deep_equal" {
+					assert.Assert(t, arraysArePermutations(out.([]interface{}), result.([]interface{})))
+				}
+			}
+		})
+	}
+}

internal/clientio/resp.go

@@ -152,17 +152,37 @@ func encodeString(v string) []byte {
 	return []byte(fmt.Sprintf("$%d\r\n%s\r\n", len(v), v))
 }
 
+// encodeBool encodes bool as simple strings
+func encodeBool(v bool) []byte {
+	return []byte(fmt.Sprintf("+%t\r\n", v))
+}
+
 func Encode(value interface{}, isSimple bool) []byte {
 	switch v := value.(type) {
 	case string:
-		if isSimple {
+		// encode as simple strings
+		if isSimple || v == "[" || v == "{" {
 			return []byte(fmt.Sprintf("+%s\r\n", v))
 		}
+		// encode as bulk strings
 		return encodeString(v)
 	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
 		return []byte(fmt.Sprintf(":%d\r\n", v))
 	case float32, float64:
-		return []byte(fmt.Sprintf(":%v\r\n", v))
+		// In case the element being encoded was obtained after parsing a JSON value,
+		// it is possible for integers to have been encoded as floats
+		// (since encoding/json unmarshals numeric values as floats).
+		// Therefore, we need to check if value is an integer
+		intValue, isInteger := utils.IsFloatToIntPossible(v.(float64))
+		if isInteger {
+			return []byte(fmt.Sprintf(":%d\r\n", intValue))
+		}
+
+		// if it is a float, encode like a string
+		str := strconv.FormatFloat(v.(float64), 'f', -1, 64)
+		return encodeString(str)
+	case bool:
+		return encodeBool(v)
 	case []string:
 		var b []byte
 		buf := bytes.NewBuffer(b)

internal/clientio/resp_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/dicedb/dice/internal/clientio"
 	"github.com/dicedb/dice/internal/server/utils"
+	testifyAssert "github.com/stretchr/testify/assert"
 )
 
 func TestSimpleStringDecode(t *testing.T) {
@@ -175,3 +176,45 @@ func TestArrayInt(t *testing.T) {
 		}
 	}
 }
+
+func TestBoolean(t *testing.T) {
+	tests := []struct {
+		input  bool
+		output []byte
+	}{
+		{
+			input:  true,
+			output: []byte("+true\r\n"),
+		},
+		{
+			input:  false,
+			output: []byte("+false\r\n"),
+		},
+	}
+
+	for _, v := range tests {
+		ev := clientio.Encode(v.input, false)
+		testifyAssert.Equal(t, ev, v.output)
+	}
+}
+
+func TestInteger(t *testing.T) {
+	tests := []struct {
+		input  int
+		output []byte
+	}{
+		{
+			input:  10,
+			output: []byte(":10\r\n"),
+		},
+		{
+			input:  -19,
+			output: []byte(":-19\r\n"),
+		},
+	}
+
+	for _, v := range tests {
+		ev := clientio.Encode(v.input, false)
+		testifyAssert.Equal(t, ev, v.output)
+	}
+}

internal/eval/commands.go

@@ -288,16 +288,23 @@ var (
 		Arity:    -5,
 		KeySpecs: KeySpecs{BeginIndex: 1},
 	}
+	jsonrespCmdMeta = DiceCmdMeta{
+		Name: "JSON.RESP",
+		Info: `JSON.RESP key [path]
+		Return the JSON in key in Redis serialization protocol specification form`,
+		Eval:     evalJSONRESP,
+		Arity:    -2,
+		KeySpecs: KeySpecs{BeginIndex: 1},
+	}
 	jsonarrtrimCmdMeta = DiceCmdMeta{
 		Name: "JSON.ARRTRIM",
 		Info: `JSON.ARRTRIM key path start stop
 		Trim an array so that it contains only the specified inclusive range of elements
 		Returns an array of integer replies for each path.
 		Returns error response if the key doesn't exist or key is expired.
 		Error reply: If the number of arguments is incorrect.`,
-		Eval:     evalJSONARRTRIM,
-		Arity:    -5,
-		KeySpecs: KeySpecs{BeginIndex: 1},
+		Eval:  evalJSONARRTRIM,
+		Arity: -5,
 	}
 	ttlCmdMeta = DiceCmdMeta{
 		Name: "TTL",
@@ -996,6 +1003,7 @@ func init() {
 	DiceCmds["JSON.ARRPOP"] = jsonarrpopCmdMeta
 	DiceCmds["JSON.INGEST"] = jsoningestCmdMeta
 	DiceCmds["JSON.ARRINSERT"] = jsonarrinsertCmdMeta
+	DiceCmds["JSON.RESP"] = jsonrespCmdMeta
 	DiceCmds["JSON.ARRTRIM"] = jsonarrtrimCmdMeta
 	DiceCmds["TTL"] = ttlCmdMeta
 	DiceCmds["DEL"] = delCmdMeta

internal/eval/eval.go

@@ -4336,6 +4336,83 @@ func selectRandomFields(hashMap HashMap, count int, withValues bool) []byte {
 	return clientio.Encode(results, false)
 }
 
+func evalJSONRESP(args []string, store *dstore.Store) []byte {
+	if len(args) < 1 {
+		return diceerrors.NewErrArity("json.resp")
+	}
+	key := args[0]
+
+	path := defaultRootPath
+	if len(args) > 1 {
+		path = args[1]
+	}
+
+	obj := store.Get(key)
+	if obj == nil {
+		return clientio.RespNIL
+	}
+
+	// Check if the object is of JSON type
+	errWithMessage := object.AssertTypeAndEncoding(obj.TypeEncoding, object.ObjTypeJSON, object.ObjEncodingJSON)
+	if errWithMessage != nil {
+		return errWithMessage
+	}
+
+	jsonData := obj.Value
+	if path == defaultRootPath {
+		resp := parseJSONStructure(jsonData, false)
+
+		return clientio.Encode(resp, false)
+	}
+
+	// if path is not root then extract value at path
+	expr, err := jp.ParseString(path)
+	if err != nil {
+		return diceerrors.NewErrWithMessage("invalid JSONPath")
+	}
+	results := expr.Get(jsonData)
+
+	// process value at each path
+	ret := []any{}
+	for _, result := range results {
+		resp := parseJSONStructure(result, false)
+		ret = append(ret, resp)
+	}
+
+	return clientio.Encode(ret, false)
+}
+
+func parseJSONStructure(jsonData interface{}, nested bool) (resp []any) {
+	switch json := jsonData.(type) {
+	case string, bool:
+		resp = append(resp, json)
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, nil:
+		resp = append(resp, json)
+	case map[string]interface{}:
+		resp = append(resp, "{")
+		for key, value := range json {
+			resp = append(resp, key)
+			resp = append(resp, parseJSONStructure(value, true)...)
+		}
+		// wrap in another array to offset print
+		if nested {
+			resp = []interface{}{resp}
+		}
+	case []interface{}:
+		resp = append(resp, "[")
+		for _, value := range json {
+			resp = append(resp, parseJSONStructure(value, true)...)
+		}
+		// wrap in another array to offset print
+		if nested {
+			resp = []interface{}{resp}
+		}
+	default:
+		resp = append(resp, []byte("(unsupported type)"))
+	}
+	return resp
+}
+
 // evalZADD adds all the specified members with the specified scores to the sorted set stored at key.
 // If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering.
 // If key does not exist, a new sorted set with the specified members as sole members is created.