merge

Author: ashtonian

config.go

@@ -122,6 +122,14 @@ type Config struct {
 	// 	}
 	//
 	FieldSep string
+	// NameFn is a function that translates the incoming filter query field name to the struct field name.
+	// For example, given the following query fields and their column names:
+	//
+	//	fullName => "full_name"
+	// 	httpPort => "http_port"
+	//
+	// By default the field name is expected to match the column.
+	NameFn func(string, string) string
 	// ColumnFn is the function that translate the struct field string into a table column.
 	// For example, given the following fields and their column names:
 	//
@@ -174,6 +182,9 @@ func (c *Config) defaults() error {
 	if c.ColumnFn == nil {
 		c.ColumnFn = Column
 	}
+	if c.NameFn == nil {
+		c.NameFn = NameFn
+	}
 	if c.GetDBOp == nil {
 		c.GetDBOp = func(o Op, _ *FieldMeta) string {
 			return opFormat[o]

rql.go

@@ -119,6 +119,8 @@ type Field struct {
 type FieldMeta struct {
 	// Name of the column.
 	Name string
+	// name of the column.
+	Column string
 	// Has a "sort" option in the tag.
 	Sortable bool
 	// Has a "filter" option in the tag.
@@ -215,6 +217,7 @@ func (p *Parser) ParseQuery(q *Query) (pr *Params, err error) {
 //	FullName => full_name
 //	HTTPCode => http_code
 func Column(s string) string {
+	s = strings.Replace(s, ".", "_", -1)
 	var b strings.Builder
 	for i := 0; i < len(s); i++ {
 		r := rune(s[i])
@@ -339,6 +342,29 @@ func GetValidateFn(f *FieldMeta) Validator {
 	}
 }
 
+func NameFn(str string, sep string) string {
+	var buf bytes.Buffer
+
+	for i, r := range str {
+		if r == '.' {
+			buf.WriteRune(r)
+			continue
+		}
+
+		if unicode.IsUpper(r) {
+			if i > 0 && str[i-1] != '_' && str[i-1] != '.' && !unicode.IsUpper(rune(str[i-1])) {
+				buf.WriteRune('_')
+			} else if i > 0 && unicode.IsUpper(rune(str[i-1])) && i+1 < len(str) && unicode.IsUpper(r) && unicode.IsLower(rune(str[i+1])) {
+				buf.WriteRune('_')
+			}
+		}
+
+		buf.WriteRune(unicode.ToLower(r))
+	}
+
+	return buf.String()
+}
+
 // init initializes the parser parsing state. it scans the fields
 // in a breath-first-search order and for each one of the field calls parseField.
 func (p *Parser) init() error {
@@ -378,7 +404,8 @@ func (p *Parser) init() error {
 func (p *Parser) parseField(sf reflect.StructField) error {
 	f := &Field{
 		FieldMeta: &FieldMeta{
-			Name:      p.ColumnFn(sf.Name),
+			Name:      p.NameFn(sf.Name, p.FieldSep),
+			Column:    p.ColumnFn(sf.Name),
 			FilterOps: make(map[string]bool),
 		},
 		CovertFn: valueFn,
@@ -392,7 +419,9 @@ func (p *Parser) parseField(sf reflect.StructField) error {
 		case s == "filter":
 			f.Filterable = true
 		case strings.HasPrefix(opt, "column"):
-			f.Name = strings.TrimPrefix(opt, "column=")
+			f.Column = strings.TrimPrefix(opt, "column=")
+		case strings.HasPrefix(opt, "name"):
+			f.Name = strings.TrimPrefix(opt, "name=")
 		case strings.HasPrefix(opt, "layout"):
 			layout = strings.TrimPrefix(opt, "layout=")
 			// if it's one of the standard layouts, like: RFC822 or Kitchen.
@@ -415,7 +444,6 @@ func (p *Parser) parseField(sf reflect.StructField) error {
 	f.Type = indirect(sf.Type)
 	filterOps := p.Config.GetSupportedOps(f.FieldMeta)
 	if len(filterOps) == 0 {
-		return fmt.Errorf("rql: field type for %q is not supported", sf.Name)
 	}
 	f.CovertFn = p.Config.GetConverter(f.FieldMeta)
 	f.ValidateFn = p.Config.GetValidator(f.FieldMeta)
@@ -465,9 +493,10 @@ func (p *Parser) sort(fields []string) string {
 			field = field[1:]
 		}
 
-		expect(p.fields[field] != nil, "unrecognized key %q for sorting", field)
-		expect(p.fields[field].Sortable, "field %q is not sortable", field)
-		colName := p.colName(field)
+		f := p.fields[field]
+		expect(f != nil, "unrecognized key %q for sorting", field)
+		expect(f.Sortable, "field %q is not sortable", field)
+		colName := f.Column
 		if orderBy != "" {
 			colName += " " + orderBy
 		}
@@ -548,6 +577,7 @@ func (p *parseState) field(f *Field, v interface{}) {
 		p.WriteString(p.fmtOp(f, op))
 		arg := f.CovertFn(op, *f.FieldMeta, opVal)
 		p.values = append(p.values, arg)
+
 		i++
 	}
 	if len(terms) > 1 {

rql_test.go

@@ -955,6 +955,63 @@ func TestParse(t *testing.T) {
 				Sort:       "",
 			},
 		},
+		{
+			name: "support name struct opt",
+			conf: Config{
+				Model: struct {
+					SomeName string `rql:"filter,name=someName"`
+				}{},
+			},
+			input: []byte(`{
+				"filter": {
+					"someName": {
+						"$eq": "someName"
+					}
+				}
+			}`),
+			wantOut: &Params{
+				Limit:      25,
+				FilterExp:  "some_name = ?",
+				FilterArgs: []interface{}{"someName"},
+			},
+		},
+		{
+			name: "backwards compatibility to error with mismatching keys and no namefn",
+			conf: Config{
+				Model: struct {
+					SomeName string `rql:"filter"`
+				}{},
+			},
+			input: []byte(`{
+				"filter": {
+					"someName": {
+						"$eq": "someName"
+					}
+				}
+			}`),
+			wantErr: true,
+		},
+		{
+			name: "test nameFn works",
+			conf: Config{
+				Model: struct {
+					SomeName string `rql:"filter"`
+				}{},
+				NameFn: NameFn,
+			},
+			input: []byte(`{
+				"filter": {
+					"someName": {
+						"$eq": "someName"
+					}
+				}
+			}`),
+			wantOut: &Params{
+				Limit:      25,
+				FilterExp:  "some_name = ?",
+				FilterArgs: []interface{}{"someName"},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {