[add] initial version

Author: mkozhukh

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -0,0 +1,21 @@
+JSON to SQL Query
+==================
+
+Converts JSON config to SQL Query
+
+```json
+{
+  "glue": "and",
+  "data": [{
+    "field":"age",
+    "condition":{
+      "rule": "less",
+      "value": 42
+    } 
+  },{
+    "field":"region",
+    "includes": [1,2,6]
+  }] 
+}
+```
+

go.mod

@@ -0,0 +1,3 @@
+module github.com/xbsoftware/querysql
+
+go 1.13

sql.go

@@ -0,0 +1,103 @@
+package querysql
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type Filter struct {
+	Glue      string        `json:"glue"`
+	Field     string        `json:"field"`
+	Condition Condition     `json:"condition"`
+	Includes  []interface{} `json:"includes"`
+	Kids      []Filter      `json:"data"`
+}
+
+type Condition struct {
+	Rule  string      `json:"rule"`
+	Value interface{} `json:"value"`
+}
+
+type CustomOperation func(string, Condition) (string, []interface{}, error)
+
+type SQLConfig struct {
+	Whitelist  map[string]bool
+	Operations map[string]CustomOperation
+}
+
+func FromJSON(text []byte) (Filter, error) {
+	f := Filter{}
+	err := json.Unmarshal(text, &f)
+	return f, err
+}
+
+var NoValues = make([]interface{}, 0)
+
+func inSQL(field string, data []interface{}) (string, []interface{}, error) {
+	marks := make([]string, len(data))
+	for i := range marks {
+		marks[i] = "?"
+	}
+
+	sql := fmt.Sprintf("%s IN(%s)", field, strings.Join(marks, ","))
+	return sql, data, nil
+}
+
+func GetSQL(data Filter, config *SQLConfig) (string, []interface{}, error) {
+	if data.Kids == nil {
+		if config != nil && config.Whitelist != nil && !config.Whitelist[data.Field] {
+			return "", nil, fmt.Errorf("field name is not in whitelist: %s", data.Field)
+		}
+
+		if len(data.Includes) > 0 {
+			return inSQL(data.Field, data.Includes)
+		}
+
+		switch data.Condition.Rule {
+		case "":
+			return "", NoValues, nil
+		case "equal":
+			return fmt.Sprintf("%s = ?", data.Field), []interface{}{data.Condition.Value}, nil
+		case "less":
+			return fmt.Sprintf("%s < ?", data.Field), []interface{}{data.Condition.Value}, nil
+		case "greater":
+			return fmt.Sprintf("%s > ?", data.Field), []interface{}{data.Condition.Value}, nil
+		}
+
+		if config.Operations != nil {
+			op, opOk := config.Operations[data.Condition.Rule]
+			if opOk {
+				return op(data.Field, data.Condition)
+			}
+		}
+
+		return "", NoValues, fmt.Errorf("unknown operation: %s", data.Condition.Rule)
+	}
+
+	out := make([]string, 0, len(data.Kids))
+	values := make([]interface{}, 0)
+
+	for _, r := range data.Kids {
+		subSql, subValues, err := GetSQL(r, config)
+		if err != nil {
+			return "", nil, err
+		}
+		out = append(out, subSql)
+		values = append(values, subValues...)
+	}
+
+	var glue string
+	if data.Glue == "or" {
+		glue = " OR "
+	} else {
+		glue = " AND "
+	}
+
+	outStr := strings.Join(out, glue)
+	if len(data.Kids) > 1 {
+		outStr = "( " + outStr + " )"
+	}
+
+	return outStr, values, nil
+}

sql_test.go

@@ -0,0 +1,177 @@
+package querysql
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var aAndB = `{ "glue":"and", "data":[{ "field": "a", "condition":{ "rule":"less", "value":1}}, { "field": "b", "condition":{ "rule":"greater", "value":"abc" }}]}`
+var aOrB = `{ "glue":"or", "data":[{ "field": "a", "condition":{ "rule":"less", "value":1}}, { "field": "b", "condition":{ "rule":"greater", "value":"abc" }}]}`
+var cOrC = `{ "glue":"or", "data":[{ "field": "a", "condition":{ "rule":"is null" }}, { "field": "b", "condition":{ "rule":"range100", "value":500 }}]}`
+
+var cases = [][]string{
+	[]string{`{}`, "", ""},
+	[]string{
+		`{ "glue":"and", "data":[{ "field": "a", "condition":{ "rule":"equal", "value":1 }}]}`,
+		"a = ?",
+		"1",
+	},
+	[]string{
+		aAndB,
+		"( a < ? AND b > ? )",
+		"1,abc",
+	},
+	[]string{
+		aOrB,
+		"( a < ? OR b > ? )",
+		"1,abc",
+	},
+	[]string{
+		`{ "glue":"AND", "data":[` + aAndB + `,` + aOrB + `,{ "field":"c", "condition": { "rule":"equal", "value":3 } }]}`,
+		"( ( a < ? AND b > ? ) AND ( a < ? OR b > ? ) AND c = ? )",
+		"1,abc,1,abc,3",
+	},
+	[]string{
+		`{ "glue":"and", "data":[{ "field": "a", "includes":[1,2,3]}]}`,
+		"a IN(?,?,?)",
+		"1,2,3",
+	},
+	[]string{
+		`{ "glue":"and", "data":[{ "field": "a", "includes":["a","b","c"]}]}`,
+		"a IN(?,?,?)",
+		"a,b,c",
+	},
+}
+
+func anyToStringArray(some []interface{}) (string, error) {
+	out := make([]string, 0, len(some))
+	for _, x := range some {
+		str, strOk := x.(string)
+		if strOk {
+			out = append(out, str)
+			continue
+		}
+
+		num, numOk := x.(float64)
+		if numOk {
+			out = append(out, strconv.Itoa(int(num)))
+			continue
+		}
+
+		return "", fmt.Errorf("can't convert %+v to a string", x)
+	}
+
+	return strings.Join(out, ","), nil
+}
+
+func TestSQL(t *testing.T) {
+	for _, line := range cases {
+		format, err := FromJSON([]byte(line[0]))
+		if err != nil {
+			t.Errorf("can't parse json\nj: %s\n%f", line[0], err)
+			continue
+		}
+
+		sql, vals, err := GetSQL(format, nil)
+		if err != nil {
+			t.Errorf("can't generate sql\nj: %s\n%f", line[0], err)
+			continue
+		}
+		if sql != line[1] {
+			t.Errorf("wrong sql generated\nj: %s\ns: %s\nr: %s", line[0], line[1], sql)
+			continue
+		}
+
+		valsStr, err := anyToStringArray(vals)
+		if err != nil {
+			t.Errorf("can't convert parameters\nj: %s\n%f", line[0], err)
+			continue
+		}
+
+		if valsStr != line[2] {
+			t.Errorf("wrong sql generated\nj: %s\ns: %s\nr: %s", line[0], line[2], valsStr)
+			continue
+		}
+	}
+}
+
+func TestWhitelist(t *testing.T) {
+	format, err := FromJSON([]byte(aAndB))
+	if err != nil {
+		t.Errorf("can't parse json\nj: %s\n%f", aAndB, err)
+		return
+	}
+
+	_, _, err = GetSQL(format, nil)
+	if err != nil {
+		t.Errorf("doesn't work without config")
+		return
+	}
+	_, _, err = GetSQL(format, &SQLConfig{})
+	if err != nil {
+		t.Errorf("doesn't work without whitelist")
+		return
+	}
+
+	_, _, err = GetSQL(format, &SQLConfig{Whitelist: map[string]bool{"a": true, "b": true}})
+	if err != nil {
+		t.Errorf("doesn't work with fields allowed")
+		return
+	}
+
+	_, _, err = GetSQL(format, &SQLConfig{Whitelist: map[string]bool{"a": true}})
+	if err == nil {
+		t.Errorf("doesn't return error when field is not allowed")
+		return
+	}
+
+	_, _, err = GetSQL(format, &SQLConfig{Whitelist: map[string]bool{"b": true}})
+	if err == nil {
+		t.Errorf("doesn't return error when field is not allowed")
+		return
+	}
+}
+
+func TestCustomOperation(t *testing.T) {
+	format, err := FromJSON([]byte(cOrC))
+	if err != nil {
+		t.Errorf("can't parse json\nj: %s\n%f", aAndB, err)
+		return
+	}
+
+	sql, vals, err := GetSQL(format, &SQLConfig{
+		Operations: map[string]CustomOperation{
+			"is null" : func(n string, c Condition) (string, []interface{}, error) {
+				return fmt.Sprintf("%s IS NULL", n), NoValues, nil
+			},
+			"range100" : func(n string, c Condition) (string, []interface{}, error) {
+				return fmt.Sprintf("( %s > ? AND %s < ? + 100 )", n, n), []interface{}{c.Value, c.Value}, nil
+			},
+		},
+	})
+
+	if err != nil {
+		t.Errorf("can't generate sql: %s\n%f", cOrC, err)
+		return
+	}
+
+	check := "( a IS NULL OR ( b > ? AND b < ? + 100 ) )"
+	if sql != check {
+		t.Errorf("wrong sql generated\nj: %s\ns: %s\nr: %s", cOrC, check, sql)
+		return
+	}
+
+		valsStr, err := anyToStringArray(vals)
+		if err != nil {
+			t.Errorf("can't convert parameters\nj: %s\n%f", cOrC, err)
+			return
+		}
+
+		check = "500,500"
+		if valsStr != check {
+			t.Errorf("wrong sql generated\nj: %s\ns: %s\nr: %s", cOrC, check, valsStr)
+			return
+		}
+}