refactor: resolve all lint issues

internal/store/elasticsearch/discovery_repository.go

@@ -6,14 +6,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	generichelper "github.com/goto/compass/pkg/generic_helper"
-	queryexpr "github.com/goto/compass/pkg/query_expr"
 	"io"
 	"net/url"
 	"strings"
 	"time"
 
 	"github.com/goto/compass/core/asset"
+	generichelper "github.com/goto/compass/pkg/generic_helper"
+	queryexpr "github.com/goto/compass/pkg/query_expr"
 	"github.com/goto/salt/log"
 )
 

internal/store/postgres/asset_repository.go

@@ -6,15 +6,15 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	generichelper "github.com/goto/compass/pkg/generic_helper"
-	queryexpr "github.com/goto/compass/pkg/query_expr"
 	"log"
 	"strings"
 	"time"
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/goto/compass/core/asset"
 	"github.com/goto/compass/core/user"
+	generichelper "github.com/goto/compass/pkg/generic_helper"
+	queryexpr "github.com/goto/compass/pkg/query_expr"
 	"github.com/jmoiron/sqlx"
 	"github.com/r3labs/diff/v2"
 )

pkg/query_expr/es_expr.go

@@ -3,6 +3,7 @@ package queryexpr
 import (
 	"encoding/json"
 	"fmt"
+
 	"github.com/expr-lang/expr/ast"
 )
 
@@ -41,11 +42,11 @@ func (*ESExpr) Validate() error {
 
 // translateToEsQuery The idea came from ast.Walk. Currently, the development focus implement for the node type that most likely used in our needs.
 // TODO: implement translator for node type that still not covered right now.
-func (e *ESExpr) translateToEsQuery(node *ast.Node) interface{} {
-	if *node == nil {
+func (e *ESExpr) translateToEsQuery(node ast.Node) interface{} {
+	if node == nil {
 		return nil
 	}
-	switch n := (*node).(type) {
+	switch n := (node).(type) {
 	case *ast.BinaryNode:
 		return e.translateBinaryNodeToEsQuery(n)
 	case *ast.NilNode:
@@ -78,16 +79,16 @@ func (e *ESExpr) translateToEsQuery(node *ast.Node) interface{} {
 			return nil
 		}
 		if nodeV, ok := result.(ast.Node); ok {
-			return e.translateToEsQuery(&nodeV)
+			return e.translateToEsQuery(nodeV)
 		}
 	}
 
 	return nil
 }
 
 func (e *ESExpr) translateBinaryNodeToEsQuery(n *ast.BinaryNode) map[string]interface{} {
-	left := e.translateToEsQuery(&n.Left)
-	right := e.translateToEsQuery(&n.Right)
+	left := e.translateToEsQuery(n.Left)
+	right := e.translateToEsQuery(n.Right)
 
 	switch n.Operator {
 	case "&&":
@@ -111,13 +112,13 @@ func (e *ESExpr) translateUnaryNodeToEsQuery(n *ast.UnaryNode) interface{} {
 	switch n.Operator {
 	case "not":
 		if binaryNode, ok := n.Node.(*ast.BinaryNode); ok && binaryNode.Operator == "in" {
-			left := e.translateToEsQuery(&binaryNode.Left)
-			right := e.translateToEsQuery(&binaryNode.Right)
+			left := e.translateToEsQuery(binaryNode.Left)
+			right := e.translateToEsQuery(binaryNode.Right)
 			return e.mustNotTermsQuery(left.(string), right)
 		}
 		return nil
 	case "!":
-		nodeValue := e.translateToEsQuery(&n.Node)
+		nodeValue := e.translateToEsQuery(n.Node)
 		switch value := nodeValue.(type) {
 		case bool:
 			return !value
@@ -136,7 +137,7 @@ func (e *ESExpr) translateUnaryNodeToEsQuery(n *ast.UnaryNode) interface{} {
 func (e *ESExpr) translateArrayNodeToEsQuery(n *ast.ArrayNode) []interface{} {
 	values := make([]interface{}, len(n.Nodes))
 	for i, node := range n.Nodes {
-		values[i] = e.translateToEsQuery(&node)
+		values[i] = e.translateToEsQuery(node)
 	}
 	return values
 }

pkg/query_expr/query_expr.go

@@ -2,6 +2,7 @@ package queryexpr
 
 import (
 	"fmt"
+
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/ast"
 	"github.com/expr-lang/expr/parser"
@@ -30,7 +31,8 @@ func ValidateAndGetQueryFromExpr(exprStr ExprStr) (string, error) {
 	return sqlQuery, nil
 }
 
-func (s *QueryExpr) Visit(node *ast.Node) {
+// Visit is implementation Visitor interface from expr-lang/expr lib, used by ast.Walk
+func (s *QueryExpr) Visit(node *ast.Node) { //nolint:gocritic
 	if n, ok := (*node).(*ast.IdentifierNode); ok {
 		s.Identifiers = append(s.Identifiers, n.Value)
 	}
@@ -42,17 +44,17 @@ func GetIdentifiers(queryExpr string) ([]string, error) {
 		return nil, err
 	}
 	queryExprVisitor := &QueryExpr{}
-	ast.Walk(queryExprParsed, queryExprVisitor)
+	ast.Walk(&queryExprParsed, queryExprVisitor)
 	return queryExprVisitor.Identifiers, nil
 }
 
-func GetTreeNodeFromQueryExpr(queryExpr string) (*ast.Node, error) {
+func GetTreeNodeFromQueryExpr(queryExpr string) (ast.Node, error) {
 	parsed, err := parser.Parse(queryExpr)
 	if err != nil {
 		return nil, fmt.Errorf("error parsing expression: %w", err)
 	}
 
-	return &parsed.Node, nil
+	return parsed.Node, nil
 }
 
 func GetQueryExprResult(fn string) (any, error) {

pkg/query_expr/sql_expr.go

@@ -2,9 +2,10 @@ package queryexpr
 
 import (
 	"fmt"
-	"github.com/expr-lang/expr/ast"
 	"strconv"
 	"strings"
+
+	"github.com/expr-lang/expr/ast"
 )
 
 type SQLExpr struct {
@@ -29,20 +30,20 @@ func (*SQLExpr) Validate() error {
 
 // ConvertToSQL The idea came from ast.Walk. Currently, the development focus implement for the node type that most likely used in our needs.
 // TODO: implement translator for node type that still not covered right now.
-func (s *SQLExpr) ConvertToSQL(node *ast.Node) {
-	if *node == nil {
+func (s *SQLExpr) ConvertToSQL(node ast.Node) {
+	if node == nil {
 		return
 	}
-	switch n := (*node).(type) {
+	switch n := (node).(type) {
 	case *ast.BinaryNode:
 		s.SQLQuery.WriteString("(")
-		s.ConvertToSQL(&n.Left)
+		s.ConvertToSQL(n.Left)
 
 		// write operator
 		operator := s.operatorToSQL(n)
 		s.SQLQuery.WriteString(fmt.Sprintf(" %s ", strings.ToUpper(operator)))
 
-		s.ConvertToSQL(&n.Right)
+		s.ConvertToSQL(n.Right)
 		s.SQLQuery.WriteString(")")
 	case *ast.NilNode:
 		s.SQLQuery.WriteString("NULL")
@@ -60,7 +61,7 @@ func (s *SQLExpr) ConvertToSQL(node *ast.Node) {
 		s.SQLQuery.WriteString(fmt.Sprintf("%s", n.Value))
 	case *ast.UnaryNode:
 		s.patchUnaryNode(n)
-		s.ConvertToSQL(&n.Node)
+		s.ConvertToSQL(n.Node)
 	case *ast.BuiltinNode:
 		result, err := GetQueryExprResult(n.String())
 		if err != nil {
@@ -70,7 +71,7 @@ func (s *SQLExpr) ConvertToSQL(node *ast.Node) {
 	case *ast.ArrayNode:
 		s.SQLQuery.WriteString("(")
 		for i := range n.Nodes {
-			s.ConvertToSQL(&n.Nodes[i])
+			s.ConvertToSQL(n.Nodes[i])
 			if i != len(n.Nodes)-1 {
 				s.SQLQuery.WriteString(", ")
 			}
@@ -82,7 +83,7 @@ func (s *SQLExpr) ConvertToSQL(node *ast.Node) {
 			return
 		}
 		if nodeV, ok := result.(ast.Node); ok {
-			s.ConvertToSQL(&nodeV)
+			s.ConvertToSQL(nodeV)
 		}
 	}
 }