make pkg/grammar free from any mission-control dependencies

query/commons.go

@@ -1,105 +1,31 @@
 package query
 
 import (
-	"fmt"
-	"net/url"
-	"strings"
 	"time"
 
 	"github.com/flanksource/duty/context"
-	"github.com/flanksource/duty/types"
+	"github.com/flanksource/duty/query/grammar"
 	"github.com/patrickmn/go-cache"
-	"github.com/samber/lo"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
 
 var LocalFilter = "deleted_at is NULL AND agent_id = '00000000-0000-0000-0000-000000000000' OR agent_id IS NULL"
 
-type expressions struct {
-	In     []interface{}
-	Prefix []string
-	Suffix []string
-}
-
-type Expressions []clause.Expression
-
 var distinctTagsCache = cache.New(time.Minute*10, time.Hour)
 
-// postgrestValues returns ["a", "b", "c"] as `"a","b","c"`
-func postgrestValues(val []any) string {
-	return strings.Join(lo.Map(val, func(s any, i int) string {
-		return fmt.Sprintf(`"%s"`, s)
-	}), ",")
-}
-
-func (query FilteringQuery) AppendPostgrest(key string,
-	queryParam url.Values,
-) {
-	if len(query.In) > 0 {
-		queryParam.Add(key, fmt.Sprintf("in.(%s)", postgrestValues(query.In)))
-	}
-
-	if len(query.Not.In) > 0 {
-		queryParam.Add(key, fmt.Sprintf("not.in.(%s)", postgrestValues(query.Not.In)))
-	}
-
-	for _, p := range query.Prefix {
-		queryParam.Add(key, fmt.Sprintf("like.%s*", p))
-	}
-
-	for _, p := range query.Suffix {
-		queryParam.Add(key, fmt.Sprintf("like.*%s", p))
-	}
-}
-
-func (e expressions) ToExpression(field string) []clause.Expression {
-	var clauses []clause.Expression
-	if len(e.In) > 0 {
-		clauses = append(clauses, clause.IN{Column: clause.Column{Name: field}, Values: e.In})
-	}
-
-	for _, p := range e.Prefix {
-		clauses = append(clauses, clause.Like{
-			Column: clause.Column{Name: field},
-			Value:  p + "%",
-		})
-	}
-
-	for _, s := range e.Suffix {
-		clauses = append(clauses, clause.Like{
-			Column: clause.Column{Name: field},
-			Value:  "%" + s,
-		})
-	}
-
-	return clauses
-}
-
-// ParseFilteringQuery parses a filtering query string.
-// It returns four slices: 'in', 'notIN', 'prefix', and 'suffix'.
-type FilteringQuery struct {
-	expressions
-	Not expressions
-}
-
-func (fq *FilteringQuery) ToExpression(field string) []clause.Expression {
-	exprs := fq.expressions.ToExpression(field)
-	not := clause.Not(fq.Not.ToExpression(field)...)
-	return append(exprs, not)
-}
-
 // ParseFilteringQuery parses a filtering query string.
 // It returns four slices: 'in', 'notIN', 'prefix', and 'suffix'.
 func ParseFilteringQuery(query string, decodeURL bool) (in []interface{}, notIN []interface{}, prefix, suffix []string, err error) {
 	if query == "" {
 		return
 	}
 
-	q, err := types.ParseFilteringQueryV2(query, decodeURL)
+	q, err := grammar.ParseFilteringQueryV2(query, decodeURL)
 	if err != nil {
 		return nil, nil, nil, nil, err
 	}
+
 	return q.In, q.Not.In, q.Prefix, q.Suffix, nil
 }
 

query/config.go

@@ -13,6 +13,7 @@ import (
 	"github.com/flanksource/duty/api"
 	"github.com/flanksource/duty/context"
 	"github.com/flanksource/duty/models"
+	"github.com/flanksource/duty/query/grammar"
 	"github.com/flanksource/duty/types"
 	"github.com/google/uuid"
 	"gorm.io/gorm"
@@ -228,7 +229,7 @@ func (t *ConfigSummaryRequest) filterClause(q *gorm.DB) *gorm.DB {
 	var excludeClause *gorm.DB
 
 	for k, v := range t.Filter {
-		query, _ := types.ParseFilteringQueryV2(v, true)
+		query, _ := grammar.ParseFilteringQueryV2(v, true)
 
 		if len(query.Not.In) > 0 {
 			if excludeClause == nil {

types/filters.go → query/grammar/filters.go

@@ -1,4 +1,4 @@
-package types
+package grammar
 
 import (
 	"fmt"