Merge pull request #5 from Trendyol/feature/panic-safe-casting

improvement: Update `interface{}` casting to avoid runtime `panic`

es/aggregations.go

@@ -206,11 +206,11 @@ func (agg aggsType) putInTheField(key string, value any) aggsType {
 //
 //	The updated aggsType object with the nested aggregation added.
 func (agg aggsType) Aggs(name string, nestedAgg aggsType) aggsType {
-	aggs, exists := agg["aggs"]
-	if !exists {
+	aggs, ok := agg["aggs"].(Object)
+	if !ok {
 		aggs = Object{}
 	}
-	aggs.(Object)[name] = nestedAgg
+	aggs[name] = nestedAgg
 	agg["aggs"] = aggs
 	return agg
 }
@@ -377,11 +377,11 @@ func (agg aggsType) Terms(terms ...aggTermType) aggsType {
 //
 //	The updated Object with the "aggs" field containing the new named aggregation.
 func (o Object) Aggs(name string, agg aggsType) Object {
-	aggs, exists := o["aggs"]
-	if !exists {
+	aggs, ok := o["aggs"].(Object)
+	if !ok {
 		aggs = Object{}
 	}
-	aggs.(Object)[name] = agg
+	aggs[name] = agg
 	o["aggs"] = aggs
 	return o
 }

es/bool_query.go

@@ -98,13 +98,13 @@ func (b boolType) Boost(boost float64) boolType {
 //
 //	The updated boolType object with the new filter conditions added.
 func (b boolType) Filter(items ...any) boolType {
-	filter, exists := b["filter"]
-	if !exists {
+	filter, ok := b["filter"].(filterType)
+	if !ok {
 		filter = filterType{}
 	}
 	for i := 0; i < len(items); i++ {
-		if field, ok := correctType(items[i]); ok {
-			filter = append(filter.(filterType), field)
+		if field, fOk := correctType(items[i]); fOk {
+			filter = append(filter, field)
 		}
 	}
 	b["filter"] = filter
@@ -133,13 +133,13 @@ func (b boolType) Filter(items ...any) boolType {
 //
 //	The updated boolType object with the new conditions added to the "must" section.
 func (b boolType) Must(items ...any) boolType {
-	must, exists := b["must"]
-	if !exists {
+	must, ok := b["must"].(mustType)
+	if !ok {
 		must = mustType{}
 	}
 	for i := 0; i < len(items); i++ {
-		if field, ok := correctType(items[i]); ok {
-			must = append(must.(mustType), field)
+		if field, fOk := correctType(items[i]); fOk {
+			must = append(must, field)
 		}
 	}
 	b["must"] = must
@@ -168,13 +168,13 @@ func (b boolType) Must(items ...any) boolType {
 //
 //	The updated boolType object with the new conditions added to the "must_not" section.
 func (b boolType) MustNot(items ...any) boolType {
-	mustNot, exists := b["must_not"]
-	if !exists {
+	mustNot, ok := b["must_not"].(mustNotType)
+	if !ok {
 		mustNot = mustNotType{}
 	}
 	for i := 0; i < len(items); i++ {
-		if field, ok := correctType(items[i]); ok {
-			mustNot = append(mustNot.(mustNotType), field)
+		if field, fOk := correctType(items[i]); fOk {
+			mustNot = append(mustNot, field)
 		}
 	}
 	b["must_not"] = mustNot
@@ -203,13 +203,13 @@ func (b boolType) MustNot(items ...any) boolType {
 //
 //	The updated boolType object with the new conditions added to the "should" section.
 func (b boolType) Should(items ...any) boolType {
-	should, exists := b["should"]
-	if !exists {
+	should, ok := b["should"].(shouldType)
+	if !ok {
 		should = shouldType{}
 	}
 	for i := 0; i < len(items); i++ {
-		if field, ok := correctType(items[i]); ok {
-			should = append(should.(shouldType), field)
+		if field, fOk := correctType(items[i]); fOk {
+			should = append(should, field)
 		}
 	}
 	b["should"] = should

es/match_all_query.go

@@ -23,8 +23,8 @@ func MatchAll() matchAllType {
 }
 
 func (m matchAllType) putInTheField(key string, value any) matchAllType {
-	if matchAll, exists := m["match_all"]; exists {
-		matchAll.(Object)[key] = value
+	if matchAll, ok := m["match_all"].(Object); ok {
+		matchAll[key] = value
 	}
 	return m
 }

es/match_none_query.go

@@ -33,12 +33,10 @@ func MatchNone[T any](key string, query T) matchNoneType {
 }
 
 func (m matchNoneType) putInTheField(key string, value any) matchNoneType {
-	if matchNone, exists := m["match_none"]; exists {
-		if matchNoneObject, mnoOk := matchNone.(Object); mnoOk {
-			for field := range matchNoneObject {
-				if fieldObject, foOk := matchNoneObject[field].(Object); foOk {
-					fieldObject[key] = value
-				}
+	if matchNone, ok := m["match_none"].(Object); ok {
+		for field := range matchNone {
+			if fieldObject, foOk := matchNone[field].(Object); foOk {
+				fieldObject[key] = value
 			}
 		}
 	}

es/match_query.go

@@ -33,12 +33,10 @@ func Match[T any](key string, query T) matchType {
 }
 
 func (m matchType) putInTheField(key string, value any) matchType {
-	if match, exists := m["match"]; exists {
-		if matchObject, moOk := match.(Object); moOk {
-			for field := range matchObject {
-				if fieldObject, foOk := matchObject[field].(Object); foOk {
-					fieldObject[key] = value
-				}
+	if match, ok := m["match"].(Object); ok {
+		for field := range match {
+			if fieldObject, foOk := match[field].(Object); foOk {
+				fieldObject[key] = value
 			}
 		}
 	}

es/nested_query.go

@@ -31,8 +31,8 @@ func Nested[T any](path string, nestedQuery T) nestedType {
 }
 
 func (n nestedType) putInNested(key string, value any) nestedType {
-	if nested, exists := n["nested"]; exists {
-		nested.(Object)[key] = value
+	if nestedObject, ok := n["nested"].(Object); ok {
+		nestedObject[key] = value
 	}
 	return n
 }