enhancement: simplify error handling

services/search/pkg/query/kql/factory.go

@@ -38,24 +38,16 @@ func buildAST(n interface{}, text []byte, pos position) (*ast.Ast, error) {
 		return nil, err
 	}
 
-	if len(nodes) == 0 {
-		return nil, nil
+	a := &ast.Ast{
+		Base:  b,
+		Nodes: connectNodes(DefaultConnector{sameKeyOPValue: BoolOR}, nodes...),
 	}
 
-	nodes = connectNodes(DefaultConnector{sameKeyOPValue: BoolOR}, nodes...)
-
-	switch node := nodes[0].(type) {
-	case *ast.OperatorNode:
-		switch node.Value {
-		case BoolAND, BoolOR:
-			return nil, StartsWithBinaryOperatorError{Node: node}
-		}
+	if err := validateAst(a); err != nil {
+		return nil, err
 	}
 
-	return &ast.Ast{
-		Base:  b,
-		Nodes: nodes,
-	}, nil
+	return a, nil
 }
 
 func buildStringNode(k, v interface{}, text []byte, pos position) (*ast.StringNode, error) {
@@ -170,32 +162,14 @@ func buildGroupNode(k, n interface{}, text []byte, pos position) (*ast.GroupNode
 		return nil, err
 	}
 
-	nodes = connectNodes(DefaultConnector{sameKeyOPValue: BoolAND}, nodes...)
-
 	gn := &ast.GroupNode{
 		Base:  b,
 		Key:   key,
-		Nodes: nodes,
+		Nodes: connectNodes(DefaultConnector{sameKeyOPValue: BoolAND}, nodes...),
 	}
 
-	if len(nodes) == 0 {
-		return gn, nil
-	}
-
-	switch node := nodes[0].(type) {
-	case *ast.OperatorNode:
-		switch node.Value {
-		case BoolAND, BoolOR:
-			return nil, StartsWithBinaryOperatorError{Node: node}
-		}
-	}
-
-	if key != "" {
-		for _, node := range nodes {
-			if ast.NodeKey(node) != "" {
-				return nil, NamedGroupInvalidNodesError{Node: node}
-			}
-		}
+	if err := validateGroupNode(gn); err != nil {
+		return nil, err
 	}
 
 	return gn, nil

services/search/pkg/query/kql/validate.go

@@ -0,0 +1,37 @@
+package kql
+
+import (
+	"github.com/owncloud/ocis/v2/services/search/pkg/query/ast"
+)
+
+func validateAst(a *ast.Ast) error {
+	switch node := a.Nodes[0].(type) {
+	case *ast.OperatorNode:
+		switch node.Value {
+		case BoolAND, BoolOR:
+			return StartsWithBinaryOperatorError{Node: node}
+		}
+	}
+
+	return nil
+}
+
+func validateGroupNode(n *ast.GroupNode) error {
+	switch node := n.Nodes[0].(type) {
+	case *ast.OperatorNode:
+		switch node.Value {
+		case BoolAND, BoolOR:
+			return StartsWithBinaryOperatorError{Node: node}
+		}
+	}
+
+	if n.Key != "" {
+		for _, node := range n.Nodes {
+			if ast.NodeKey(node) != "" {
+				return NamedGroupInvalidNodesError{Node: node}
+			}
+		}
+	}
+
+	return nil
+}