feature: add highlight query support (#71)

Implement highlight configuration with full DSL support including:

highlightType (global settings):
- PreTags, PostTags for custom highlight markers
- Field for adding field-specific highlight configurations
- Type (unified, plain, fvh) for highlighter selection
- Order, Encoder, RequireFieldMatch
- FragmentSize, NumberOfFragments, NoMatchSize
- BoundaryScanner, BoundaryChars, BoundaryMaxScan, BoundaryScannerLocale
- Fragmenter, FragmentOffset, MaxFragmentLength, MaxAnalyzedOffset
- HighlightQuery for custom highlight queries
- TagsSchema for built-in tag schemas

highlightFieldType (per-field settings):
- PreTags, PostTags, Type, Order
- FragmentSize, NumberOfFragments, NoMatchSize
- HighlightQuery, RequireFieldMatch, Fragmenter, MatchedFields

Object.Highlight method added to base_query.go for top-level query integration.

New enums:
- highlighter-type: unified, plain, fvh
- boundary-scanner: chars, sentence, word
- fragmenter: simple, span

All implementations follow existing project conventions and patterns.

* test: add nil query handling test for HighlightField.HighlightQuery

Author: GokselKUCUKSAHIN

es/base_query.go

@@ -218,6 +218,34 @@ func (o Object) Sort(sorts ...sortType) Object {
 	return o
 }
 
+// Highlight sets the "highlight" parameter in an es.Object.
+//
+// This method allows you to specify highlighting configuration for the search query.
+// Highlighting enables you to get highlighted snippets from one or more fields in your
+// search results so you can show users where the query matches are.
+//
+// Example usage:
+//
+//	query := es.NewQuery(es.MatchAll()).
+//		Highlight(
+//			es.Highlight().
+//				PreTags("<em>").
+//				PostTags("</em>").
+//				Field(es.HighlightField("title")),
+//		)
+//	// query now includes a "highlight" parameter with the specified configuration.
+//
+// Parameters:
+//   - highlight: An es.highlightType object representing the highlight configuration.
+//
+// Returns:
+//
+//	The updated es.Object with the "highlight" parameter set.
+func (o Object) Highlight(highlight highlightType) Object {
+	o["highlight"] = highlight
+	return o
+}
+
 // Aggs adds one or more es.aggsType objects to an es.Object.
 //
 // This method allows you to specify multiple aggregation criteria for the search query.

es/enums/boundary-scanner/boundary_scanner.go

@@ -0,0 +1,33 @@
+package boundaryscanner
+
+// BoundaryScanner represents the different boundary scanner types for highlighting in Elasticsearch.
+//
+// BoundaryScanner is a string type used to specify how highlighted fragments are bounded.
+// It determines the strategy for finding the boundaries of highlighted snippets.
+//
+// Example usage:
+//
+//	var bs BoundaryScanner = Sentence
+//
+//	// Use bs in a highlight configuration
+//
+// Constants:
+//   - Chars: The chars boundary scanner breaks highlighted fragments at characters specified by boundary_chars.
+//   - Sentence: The sentence boundary scanner breaks highlighted fragments at the next sentence boundary.
+//   - Word: The word boundary scanner breaks highlighted fragments at the next word boundary.
+type BoundaryScanner string
+
+const (
+	// Chars indicates that the boundary scanner should break at specified boundary characters.
+	Chars BoundaryScanner = "chars"
+
+	// Sentence indicates that the boundary scanner should break at sentence boundaries.
+	Sentence BoundaryScanner = "sentence"
+
+	// Word indicates that the boundary scanner should break at word boundaries.
+	Word BoundaryScanner = "word"
+)
+
+func (boundaryScanner BoundaryScanner) String() string {
+	return string(boundaryScanner)
+}

es/enums/boundary-scanner/boundary_scanner_test.go

@@ -0,0 +1,26 @@
+package boundaryscanner_test
+
+import (
+	"testing"
+
+	BoundaryScanner "github.com/Trendyol/es-query-builder/es/enums/boundary-scanner"
+
+	"github.com/Trendyol/es-query-builder/test/assert"
+)
+
+func Test_BoundaryScannerString(t *testing.T) {
+	tests := []struct {
+		boundaryScanner BoundaryScanner.BoundaryScanner
+		result          string
+	}{
+		{BoundaryScanner.Chars, "chars"},
+		{BoundaryScanner.Sentence, "sentence"},
+		{BoundaryScanner.Word, "word"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.result, func(t *testing.T) {
+			assert.Equal(t, test.result, test.boundaryScanner.String())
+		})
+	}
+}

es/enums/fragmenter/fragmenter.go

@@ -0,0 +1,30 @@
+package fragmenter
+
+// Fragmenter represents the different fragmenter types for highlighting in Elasticsearch.
+//
+// Fragmenter is a string type used to specify how text should be broken up into
+// highlight fragments. It determines the strategy for creating text fragments
+// that contain highlighted terms.
+//
+// Example usage:
+//
+//	var f Fragmenter = Span
+//
+//	// Use f in a highlight configuration
+//
+// Constants:
+//   - Simple: The simple fragmenter breaks text into same-sized fragments.
+//   - Span: The span fragmenter breaks text into same-sized fragments, but tries to avoid breaking up highlighted terms.
+type Fragmenter string
+
+const (
+	// Simple indicates that text should be broken into same-sized fragments.
+	Simple Fragmenter = "simple"
+
+	// Span indicates that text should be broken into same-sized fragments while trying to avoid breaking highlighted terms.
+	Span Fragmenter = "span"
+)
+
+func (fragmenter Fragmenter) String() string {
+	return string(fragmenter)
+}

es/enums/fragmenter/fragmenter_test.go

@@ -0,0 +1,25 @@
+package fragmenter_test
+
+import (
+	"testing"
+
+	Fragmenter "github.com/Trendyol/es-query-builder/es/enums/fragmenter"
+
+	"github.com/Trendyol/es-query-builder/test/assert"
+)
+
+func Test_FragmenterString(t *testing.T) {
+	tests := []struct {
+		fragmenter Fragmenter.Fragmenter
+		result     string
+	}{
+		{Fragmenter.Simple, "simple"},
+		{Fragmenter.Span, "span"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.result, func(t *testing.T) {
+			assert.Equal(t, test.result, test.fragmenter.String())
+		})
+	}
+}

es/enums/highlighter-type/highlighter_type.go

@@ -0,0 +1,34 @@
+package highlightertype
+
+// HighlighterType represents the different highlighter types available in Elasticsearch.
+//
+// HighlighterType is a string type used to specify which highlighter implementation
+// to use for highlighting search results. Elasticsearch provides three highlighter
+// implementations: unified, plain, and fvh (Fast Vector Highlighter).
+//
+// Example usage:
+//
+//	var ht HighlighterType = Unified
+//
+//	// Use ht in a highlight configuration
+//
+// Constants:
+//   - Unified: The unified highlighter uses the Lucene Unified Highlighter (default).
+//   - Plain: The plain highlighter uses the standard Lucene highlighter.
+//   - Fvh: The fvh (Fast Vector Highlighter) highlighter uses the Lucene Fast Vector Highlighter.
+type HighlighterType string
+
+const (
+	// Unified indicates the unified highlighter, which is the default highlighter in Elasticsearch.
+	Unified HighlighterType = "unified"
+
+	// Plain indicates the plain highlighter, which uses the standard Lucene highlighter.
+	Plain HighlighterType = "plain"
+
+	// Fvh indicates the Fast Vector Highlighter, which requires term_vector set to with_positions_offsets.
+	Fvh HighlighterType = "fvh"
+)
+
+func (highlighterType HighlighterType) String() string {
+	return string(highlighterType)
+}

es/enums/highlighter-type/highlighter_type_test.go

@@ -0,0 +1,26 @@
+package highlightertype_test
+
+import (
+	"testing"
+
+	HighlighterType "github.com/Trendyol/es-query-builder/es/enums/highlighter-type"
+
+	"github.com/Trendyol/es-query-builder/test/assert"
+)
+
+func Test_HighlighterTypeString(t *testing.T) {
+	tests := []struct {
+		highlighterType HighlighterType.HighlighterType
+		result          string
+	}{
+		{HighlighterType.Unified, "unified"},
+		{HighlighterType.Plain, "plain"},
+		{HighlighterType.Fvh, "fvh"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.result, func(t *testing.T) {
+			assert.Equal(t, test.result, test.highlighterType.String())
+		})
+	}
+}