feat: add support for query_string query (#210)

* feat: add support for `query_string` query

* feat: add support for sum_bucket aggreation

* fix: unit test

* feat: add support for date range aggregation

* chore: add timezone config for date range aggregation

* chore: format code

Author: silenceqi

core/elastic/search.go

@@ -24,8 +24,9 @@
 package elastic
 
 import (
-	"infini.sh/framework/core/util"
 	"time"
+
+	"infini.sh/framework/core/util"
 )
 
 type SearchTemplate struct {
@@ -142,17 +143,23 @@ func BuildSearchTermFilter(filterParam SearchFilterParam) []util.MapStr {
 
 func GetDateHistogramIntervalField(distribution, version string, bucketSize string) (string, error) {
 	if distribution == Easysearch || distribution == Opensearch {
-		return "interval", nil
+		return Interval, nil
 	}
 	cr, err := util.VersionCompare(version, "8.0")
 	if err != nil {
 		return "", err
 	}
 	if cr > -1 {
 		if util.StringInArray([]string{"1w", "week", "1M", "month", "1q", "quarter", "1y", "year"}, bucketSize) {
-			return "calendar_interval", nil
+			return CalendarInterval, nil
 		}
-		return "fixed_interval", nil
+		return FixedInterval, nil
 	}
-	return "interval", nil
+	return Interval, nil
 }
+
+const (
+	Interval         string = "interval"
+	CalendarInterval        = "calendar_interval"
+	FixedInterval           = "fixed_interval"
+)

core/orm/aggs.go

@@ -38,21 +38,23 @@ type Aggregation interface {
 
 const (
 	// Metric types
-	MetricAvg        = "avg"
-	MetricSum        = "sum"
-	MetricMin        = "min"
-	MetricMax        = "max"
-	MetricCount      = "count"
+	MetricAvg         = "avg"
+	MetricSum         = "sum"
+	MetricMin         = "min"
+	MetricMax         = "max"
+	MetricCount       = "count"
 	MetricPercentiles = "percentiles"
-	MetricTopHits    = "top_hits"
+	MetricTopHits     = "top_hits"
 	MetricCardinality = "cardinality"
-	MetricMedian = "median_absolute_deviation"
+	MetricMedian      = "median_absolute_deviation"
 	// Bucket types
 	MetricBucketTerms         = "terms"
 	MetricBucketDateHistogram = "date_histogram"
-	MetricBucketFilter      = "filter"
+	MetricBucketFilter        = "filter"
+	MetricDateRange           = "date_range"
 	// Pipeline types
 	MetricPipelineDerivative = "derivative"
+	MetricSumBucket          = "sum_bucket"
 )
 
 // baseAggregation provides common functionality for all aggregation types,
@@ -61,7 +63,7 @@ type baseAggregation struct {
 	// NestedAggs holds any sub-aggregations.
 	NestedAggs map[string]Aggregation `json:"-"`
 	// Params can hold additional parameters specific to certain aggregation types.
-	Params 	 map[string]interface{} `json:"-"`
+	Params map[string]interface{} `json:"-"`
 }
 
 // AddNested adds a sub-aggregation to the base aggregation.
@@ -105,9 +107,9 @@ func (a *TermsAggregation) AddNested(name string, sub Aggregation) Aggregation {
 
 // MetricAggregation represents a single-value metric calculation (avg, sum, etc.).
 type MetricAggregation struct {
-	baseAggregation // Although metrics rarely have sub-aggs in ES, the model allows it.
-	Type  string `mapstructure:"-"` // Type of metric: "avg", "sum", etc. Not part of the decoded structure.
-	Field string
+	baseAggregation        // Although metrics rarely have sub-aggs in ES, the model allows it.
+	Type            string `mapstructure:"-"` // Type of metric: "avg", "sum", etc. Not part of the decoded structure.
+	Field           string
 }
 
 // NewMetricAggregation creates a new MetricAggregation of the specified type and field.
@@ -124,6 +126,27 @@ func NewMetricAggregation(metricType, field string) *MetricAggregation {
 	}
 }
 
+// PipelineAggregation represents a pipeline aggregation that processes the output of other aggregations.
+type PipelineAggregation struct {
+	baseAggregation
+	Type        string `mapstructure:"-"` // Type of pipeline: "derivative", "sum_bucket", etc. Not part of the decoded structure.
+	BucketsPath string
+}
+
+// NewPipelineAggregation creates a new PipelineAggregation of the specified type and buckets path.
+func NewPipelineAggregation(pipelineType, bucketsPath string) *PipelineAggregation {
+	switch pipelineType {
+	case MetricSumBucket:
+		// Valid pipeline types
+	default:
+		panic("invalid pipeline type: " + pipelineType)
+	}
+	return &PipelineAggregation{
+		Type:        pipelineType,
+		BucketsPath: bucketsPath,
+	}
+}
+
 // AddNested provides a correctly typed chained call for MetricAggregation.
 func (a *MetricAggregation) AddNested(name string, sub Aggregation) Aggregation {
 	a.baseAggregation.AddNested(name, sub)
@@ -133,10 +156,11 @@ func (a *MetricAggregation) AddNested(name string, sub Aggregation) Aggregation
 // DateHistogramAggregation represents bucketing documents by a date/time interval.
 type DateHistogramAggregation struct {
 	baseAggregation
-	Field    string
-	Interval string // A generic interval string like "1d", "1M", "1h".
-	Format   string
-	TimeZone string
+	Field         string
+	Interval      string // A generic interval string like "1d", "1M", "1h".
+	Format        string
+	TimeZone      string
+	IntervalField string // es-specific field name for backward compatibility
 }
 
 // AddNested provides a correctly typed chained call for DateHistogramAggregation.
@@ -174,8 +198,23 @@ type FilterAggregation struct {
 	// Query holds the filter criteria for this aggregation.
 	Query map[string]interface{} `json:"query"`
 }
+
 // AddNested provides a correctly typed chained call for FilterAggregation.
 func (a *FilterAggregation) AddNested(name string, sub Aggregation) Aggregation {
 	a.baseAggregation.AddNested(name, sub)
 	return a
 }
+
+type DateRangeAggregation struct {
+	baseAggregation
+	Field    string        `json:"field"`
+	TimeZone string        `json:"time_zone,omitempty"`
+	Format   string        `json:"format,omitempty"`
+	Ranges   []interface{} `json:"ranges"`
+}
+
+// AddNested provides a correctly typed chained call for DateRangeAggregation.
+func (a *DateRangeAggregation) AddNested(name string, sub Aggregation) Aggregation {
+	a.baseAggregation.AddNested(name, sub)
+	return a
+}

core/orm/aggs_args_parser.go

@@ -14,7 +14,6 @@ import (
 // keyPartRegex is used to parse keys like "agg[key1][key2]" into parts: "agg", "key1", "key2".
 var keyPartRegex = regexp.MustCompile(`^([^\[\]]+)|\[([^\[\]]*)\]`)
 
-
 // ParseAggregationsFromQuery takes URL query values and converts them into a map of abstract aggregations.
 func ParseAggregationsFromQuery(values url.Values) (map[string]Aggregation, error) {
 	// Step 1: Convert flat URL params into a nested map.
@@ -47,15 +46,15 @@ func parseToNestedMap(values url.Values) (map[string]interface{}, error) {
 			} else {
 				part = match[2]
 			}
-			
+
 			decodedPart, err := url.QueryUnescape(part)
 			if err != nil {
 				// Fallback to the raw part if decoding fails
 				decodedPart = part
 			}
 			parts = append(parts, decodedPart)
 		}
-		
+
 		if len(parts) == 0 || parts[0] != "agg" {
 			continue // Malformed key, skip.
 		}
@@ -115,7 +114,7 @@ func stringToNumberHook() mapstructure.DecodeHookFunc {
 		if !isNumeric {
 			return data, nil
 		}
-		
+
 		str := data.(string)
 
 		// Try to parse as integer first.

core/orm/aggs_args_parser_test.go

@@ -10,7 +10,7 @@ func TestParseAggregationsFromQuery_SingleTerms(t *testing.T) {
 	// Arrange
 	rawURL := "http://example.com?agg[types][terms][field]=product.keyword&agg[types][terms][size]=5"
 	parsedURL, _ := url.Parse(rawURL)
-	
+
 	// Expected abstract structure
 	expected := map[string]Aggregation{
 		"types": &TermsAggregation{
@@ -142,4 +142,4 @@ func TestParseAggregationsFromQuery_URLEncoded(t *testing.T) {
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("Resulting aggregation map does not match expected.\nGot: %#v\nWant: %#v", result, expected)
 	}
-}
+}

core/orm/aggs_test.go

@@ -33,7 +33,7 @@ func TestTermsAggregation(t *testing.T) {
 	// Create a terms aggregation
 	termsAgg := TermsAggregation{
 		Field: "field1",
-		Size: 10,
+		Size:  10,
 	}
 	termsAgg.AddNested("count_values", NewMetricAggregation(MetricCount, "field2")).AddNested("max_value", NewMetricAggregation(MetricMax, "field2"))
 	assert.Equal(t, 2, len(termsAgg.GetNested()), "Expected one nested aggregation")
@@ -55,13 +55,13 @@ func TestDateHistogramAggregation(t *testing.T) {
 func TestAggregationWithParams(t *testing.T) {
 	termsAgg := TermsAggregation{
 		Field: "field1",
-		Size: 10,
+		Size:  10,
 	}
 	params := map[string]interface{}{
-			"order": map[string]string{
-				"_count": "desc",
-			},
-		}
+		"order": map[string]string{
+			"_count": "desc",
+		},
+	}
 	termsAgg.SetParams(params)
 	assert.Equal(t, "desc", termsAgg.Params["order"].(map[string]string)["_count"], "Expected order param to be set")
 }

core/orm/query.go

@@ -51,6 +51,7 @@ const (
 	QueryIn          QueryType = "in"
 	QueryNotIn       QueryType = "not_in"
 	QueryMatchPhrase QueryType = "match_phrase"
+	QueryQueryString QueryType = "query_string"
 )
 
 type Clause struct {
@@ -113,7 +114,7 @@ type QueryBuilder struct {
 	filters []*Clause
 
 	requestBodyBytes []byte
-	Aggs map[string]Aggregation
+	Aggs             map[string]Aggregation
 }
 
 func NewQuery() *QueryBuilder {
@@ -125,6 +126,7 @@ func NewQuery() *QueryBuilder {
 func (q *QueryBuilder) SetRequestBodyBytes(bytes []byte) {
 	q.requestBodyBytes = bytes
 }
+
 // SetAggregations sets the aggregations for the query builder.
 func (q *QueryBuilder) SetAggregations(aggs map[string]Aggregation) {
 	q.Aggs = aggs
@@ -310,6 +312,7 @@ func RegexpQuery(field string, value interface{}) *Clause {
 
 const fuzzyFuzziness = "fuzziness"
 const phraseSlop = "slop"
+const queryStringDefaultOperator = "default_operator"
 
 func FuzzyQuery(field string, value interface{}, fuzziness int) *Clause {
 	param := param.Parameters{}
@@ -335,6 +338,14 @@ func MatchPhraseQuery(field, value string, slop int) *Clause {
 	return newLeaf(field, QueryMatchPhrase, value, &param)
 }
 
+func QueryStringQuery(field string, value string, defaultOperator string) *Clause {
+	param := param.Parameters{}
+	if defaultOperator != "" {
+		param.Set(queryStringDefaultOperator, defaultOperator)
+	}
+	return newLeaf(field, QueryQueryString, value, &param)
+}
+
 type RangeQueryBuilder struct {
 	field string
 }

core/orm/query_test.go

@@ -25,10 +25,11 @@ package orm
 
 import (
 	"fmt"
-	"github.com/stretchr/testify/assert"
-	"infini.sh/framework/core/util"
 	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"infini.sh/framework/core/util"
 )
 
 func TestTermQuery(t *testing.T) {
@@ -190,6 +191,16 @@ func TestRangeLtQuery(t *testing.T) {
 	assertLeaf(t, q, "score", QueryRangeLt, 10)
 }
 
+func TestQueryStringQuery(t *testing.T) {
+	var (
+		field           = "name,description"
+		value           = "foo bar"
+		defaultOperator = "OR"
+	)
+	q := QueryStringQuery(field, value, defaultOperator)
+	assertLeaf(t, q, field, QueryQueryString, value)
+}
+
 // Helper: check leaf structure
 func assertLeaf(t *testing.T, clause *Clause, field string, op QueryType, value interface{}) {
 	t.Helper()

docs/content.en/docs/release-notes/_index.md

@@ -13,7 +13,7 @@ Information about release notes of INFINI Framework is provided here.
 ### 🚀 Features  
 - feat: add delete by query v2 #194
 - feat: support aggregation queries in orm
-
+- feat: add support for `query_string` query
 ### 🐛 Bug fix  
 - fix: localhost/127.0.0.1 with noproxy #185
 - fix: cluster metadata lost #200

lib/cache/cache_test.go

@@ -237,8 +237,8 @@ func Test_Cache_ReplaceChangesSize(t *testing.T) {
 }
 
 func Test_Cache_ResizeOnTheFly(t *testing.T) {
-	// On a busy system or during a slow run, the cleanup might take longer. 
-	// When this happens, the test continues 
+	// On a busy system or during a slow run, the cleanup might take longer.
+	// When this happens, the test continues
 	// and runs its assertions (e.g., assert.Equal(t, cache.GetDropped(), 2))
 	// before the cache has actually been pruned, causing the test to fail.
 	if os.Getenv("CI") == "true" {

lib/cache/layeredcache_test.go

@@ -225,8 +225,8 @@ func Test_LayeredCache_RemovesOldestItemWhenFull(t *testing.T) {
 }
 
 func Test_LayeredCache_ResizeOnTheFly(t *testing.T) {
-	// On a busy system or during a slow run, the cleanup might take longer. 
-	// When this happens, the test continues 
+	// On a busy system or during a slow run, the cleanup might take longer.
+	// When this happens, the test continues
 	// and runs its assertions (e.g., assert.Equal(t, cache.GetDropped(), 2))
 	// before the cache has actually been pruned, causing the test to fail.
 	if os.Getenv("CI") == "true" {