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
 }