Elastic Builder.js

https://elastic-builder.js.org/docs
Admin
Elastic Builder.js is a JavaScript library for constructing Elasticsearch queries and aggregations...
Tokens:72,889
Snippets:699
Trust Score:8.1
Update:1 year ago
Show doc for...
Tokens:
Raw
### Elasticsearch Common Terms Query Example

Source: https://elastic-builder.js.org/docs/index

Example showing the CommonTermsQuery with minimumShouldMatch and cutoffFrequency parameters.

```javascript
const qry = esb.commonTermsQuery('body', 'nelly the elephant as a cartoon')
    .minimumShouldMatch(2)
    .cutoffFrequency(0.001);
```

--------------------------------

### Elasticsearch Multi-Match Query Example

Source: https://elastic-builder.js.org/docs/index

Example demonstrating the MultiMatchQuery with multiple fields, type, and analyzer settings.

```javascript
const qry = esb.multiMatchQuery(['first', 'last', '*.edge'], 'Jon')
    .type('cross_fields')
    .analyzer('standard');
```

--------------------------------

### Elasticsearch Match Phrase Query Example

Source: https://elastic-builder.js.org/docs/index

Example demonstrating how to use the MatchPhraseQuery with a custom analyzer.

```javascript
const qry = esb.matchPhraseQuery('message', 'this is a test')
    .analyzer('my_analyzer');
```

--------------------------------

### Elasticsearch Query String Query Example

Source: https://elastic-builder.js.org/docs/index

Example demonstrating the QueryStringQuery with a complex query string and enabling dis_max.

```javascript
const qry = esb.queryStringQuery()
    .query('city.\*:(this AND that OR thus)')
    .useDisMax(true);
```

--------------------------------

### SpanFirstQuery Example

Source: https://elastic-builder.js.org/docs/index

Shows how to implement a SpanFirstQuery, which matches spans located at the beginning of a field. The example demonstrates setting the inner span query and the maximum end position.

```javascript
const spanQry = esb.spanFirstQuery()
    .match(esb.spanTermQuery('user', 'kimchy'))
    .end(3);
```

--------------------------------

### Example: MatchPhrasePrefixQuery with maxExpansions

Source: https://elastic-builder.js.org/docs/index

Shows how to set the maxExpansions limit for a MatchPhrasePrefixQuery. This example limits the prefix expansion to 10 for the query.

```javascript
const qry = esb.matchPhrasePrefixQuery('message', 'quick brown f')
    .maxExpansions(10);
```

--------------------------------

### Example: MatchQuery with zeroTermsQuery

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to use the zeroTermsQuery option with a MatchQuery. This example sets the operator to 'and' and configures zero terms to match 'all' documents.

```javascript
const qry = esb.matchQuery('message', 'to be or not to be')
    .operator('and')
    .zeroTermsQuery('all');
```

--------------------------------

### Elasticsearch BoolQuery Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to construct a BoolQuery in Elasticsearch.js. It includes examples of using must, filter, mustNot, should, and minimumShouldMatch clauses to build complex search criteria.

```javascript
const qry = esb.boolQuery()
    .must(esb.termQuery('user', 'kimchy'))
    .filter(esb.termQuery('tag', 'tech'))
    .mustNot(esb.rangeQuery('age').gte(10).lte(20))
    .should([
        esb.termQuery('tag', 'wow'),
        esb.termQuery('tag', 'elasticsearch')
    ])
    .minimumShouldMatch(1)
    .boost(1.0);
```

--------------------------------

### SamplerAggregation Example

Source: https://elastic-builder.js.org/docs/index

Illustrates the use of SamplerAggregation to process sub-aggregations on a sample of top-scoring documents. This example samples documents related to 'kibana' or 'javascript' tags and then finds significant terms within those tags.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.queryStringQuery('tags:kibana OR tags:javascript'))
    .agg(
        esb.samplerAggregation('sample')
            .shardSize(200)
            .agg(
                esb.significantTermsAggregation(
                    'keywords',
                    'tags'
                ).exclude(['kibana', 'javascript'])
            )
    );
```

--------------------------------

### Example: MatchQuery with cutoffFrequency

Source: https://elastic-builder.js.org/docs/index

Illustrates setting a cutoff frequency for a MatchQuery. This example uses a relative frequency of 0.001 to influence term scoring.

```javascript
const qry = esb.matchQuery('message', 'to be or not to be')
    .cutoffFrequency(0.001);
```

--------------------------------

### Example: Create MatchPhraseQuery

Source: https://elastic-builder.js.org/docs/index

Demonstrates the creation of a MatchPhraseQuery to search for the phrase 'to be or not to be' in the 'message' field.

```javascript
const qry = esb.matchPhraseQuery('message', 'to be or not to be');
```

--------------------------------

### Elasticsearch Bool Query Example

Source: https://elastic-builder.js.org/docs/index

Example of constructing a complex boolean query with multiple should and filter clauses, including named queries.

```javascript
const boolQry = esb.boolQuery()
    .should([
        esb.matchQuery('name.first', 'shay').name('first'),
        esb.matchQuery('name.last', 'banon').name('last')
    ])
    .filter(esb.termsQuery('name.last', ['banon', 'kimchy']).name('test'));
```

--------------------------------

### Create and Configure PercolateQuery

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create a PercolateQuery instance and configure it with a field and document type, then add a document to be percolated. It also shows an extended example setting various parameters like index, type, ID, and version.

```javascript
const percolateQry = esb.percolateQuery('query', 'doctype')
    .document({ message: 'A new bonsai tree in the office' });
```

```javascript
const percolateQry = esb.percolateQuery()
    .field('query')
    .documentType('doctype')
    .index('my-index')
    .type('message')
    .id('1')
    .version(1);
```

--------------------------------

### Create MultiMatchQuery

Source: https://elastic-builder.js.org/docs/index

Initializes a MultiMatchQuery with specified fields and a query string. This is the fundamental step to start building a multi-field search query.

```javascript
const qry = esb.multiMatchQuery(['subject', 'message'], 'this is a test');
```

--------------------------------

### Example: Query String Query with Fields and DisMax

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create a Query String Query in JavaScript, specifying the query text, the fields to search within (with boost), and enabling the 'dis_max' combination strategy.

```javascript
const qry = esb.queryStringQuery('this AND that OR thus')
    .fields(['content', 'name^5'])
    .useDisMax(true);
```

--------------------------------

### Create Search Request with Suggestion

Source: https://elastic-builder.js.org/docs/index

Provides an example of creating a search request that incorporates a term suggester to find suggestions based on a given query.

```javascript
const req = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'trying out elasticsearch'))
    .suggest(
        esb.termSuggester(
            'my-suggestion',
            'message',
            'tring out Elasticsearch'
        )
    );
```

--------------------------------

### Set Model-Specific Settings

Source: https://elastic-builder.js.org/docs/index

Provides an example of setting model-specific parameters, such as 'alpha' for the EWMA model.

```javascript
const agg = esb.movingAverageAggregation('the_movavg', 'the_sum')
    .model('ewma')
    .window(30)
    .settings({ alpha: 0.8 });
```

--------------------------------

### SpanContainingQuery Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to use SpanContainingQuery to find matches within a specified range. It requires a 'little' and a 'big' span query.

```javascript
const spanQry = esb.spanContainingQuery()
    .little(esb.spanTermQuery('field1', 'foo'))
    .big(esb.spanNearQuery()
        .clauses([
            esb.spanTermQuery('field1', 'bar'),
            esb.spanTermQuery('field1', 'baz')
        ])
        .slop(5)
        .inOrder(true))
```

--------------------------------

### PipelineAggregationBase Example

Source: https://elastic-builder.js.org/docs/index

Illustrates chaining multiple aggregations, including a bucket selector, within a date histogram aggregation using PipelineAggregationBase.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('histo', 'date')
            .interval('day')
            .agg(esb.termsAggregation('categories', 'category'))
            .agg(
                esb.bucketSelectorAggregation('min_bucket_selector')
                    .bucketsPath({ count: 'categories._bucket_count' })
                    .script(esb.script('inline', 'params.count != 0'))
            )
    )
    .size(0);
```

--------------------------------

### WeightedAverageAggregation Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates calculating the weighted average of a 'grade' field, using 'teacher_score' as the weight. Includes an example of using a script for weight calculation and handling missing values.

```javascript
const agg = esb.weightedAverageAggregation('avg_grade', 'grade', 'teacher_score');
```

```javascript
const agg = esb.weightedAverageAggregation('avg_grade', 'grade')
     .weight(esb.script('inline', "doc['teacher_score'].value").lang('painless'), 10)
);
```

```javascript
const agg = esb.weightedAverageAggregation('avg_grade').value('grade', 5).weight('teacher_score', 10));
```

```javascript
const agg = esb.weightedAverageAggregation('avg_grade').value('grade').weight('teacher_score');
```

--------------------------------

### SignificantAggregationBase - Usage Example

Source: https://elastic-builder.js.org/docs/index

This example demonstrates how to use the SignificantAggregationBase class to configure a significant terms aggregation. It sets a background filter using a term query to narrow the scope of statistical information for background term frequencies.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('text', 'madrid'))
    .agg(
        esb.significantAggregationBase('tags', 'tag').backgroundFilter(
            esb.termQuery('text', 'spain')
        )
    );
```

--------------------------------

### SpanFieldMaskingQuery Example

Source: https://elastic-builder.js.org/docs/index

Shows how to use SpanFieldMaskingQuery to enable span queries across different fields, particularly useful with multi-fields and analyzers.

```javascript
const spanQry = esb.spanNearQuery()
    .clauses([
        esb.spanTermQuery('text', 'quick brown'),
        esb.spanFieldMaskingQuery()
            .field('text')
            .query(esb.spanTermQuery('text.stems', 'fox'))
    ])
    .slop(5)
    .inOrder(false);
```

--------------------------------

### AvgBucketAggregation Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates the usage of AvgBucketAggregation to calculate the average monthly sales from a date histogram aggregation.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('sales_per_month', 'date')
            .interval('month')
            .agg(esb.sumAggregation('sales', 'price'))
    )
    .agg(
        esb.avgBucketAggregation(
            'avg_monthly_sales',
            'sales_per_month>sales'
        )
    )
    .size(0);
```

--------------------------------

### SpanMultiTermQuery Example

Source: https://elastic-builder.js.org/docs/index

Illustrates the usage of SpanMultiTermQuery to wrap other span-compatible queries, such as a prefix query. This allows for nesting more complex queries within the span query framework.

```javascript
const spanQry = esb.spanMultiTermQuery()
    .match(esb.prefixQuery('user', 'ki').boost(1.08));
```

--------------------------------

### WeightScoreFunction Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create a WeightScoreFunction to multiply a score by a given weight. This function allows for score manipulation without the normalization issues of boost values.

```javascript
const scoreFunc = esb.weightScoreFunction(42);
```

--------------------------------

### SpanTermQuery Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create a SpanTermQuery to match documents containing a specific term in a given field. It shows both direct instantiation and chained method calls for setting the field and value.

```javascript
const qry = esb.spanTermQuery('user', 'kimchy');
```

```javascript
const qry = esb.spanTermQuery()
    .field('user')
    .value('kimchy')
    .boost(2.0);
```

--------------------------------

### Configure Highlight Options

Source: https://elastic-builder.js.org/docs/index

Sets various options for highlighting, including the number of fragments, fragment size, fields to highlight, pre/post tags, and sorting order by score for specific fields. This example demonstrates advanced configuration for multiple fields.

```javascript
const highlight = esb.highlight()
    .numberOfFragments(3)
    .fragmentSize(150)
    .fields(['_all', 'bio.title', 'bio.author', 'bio.content'])
    .preTags('<em>', '_all')
    .postTags('</em>', '_all')
    .numberOfFragments(0, 'bio.title')
    .numberOfFragments(0, 'bio.author')
    .numberOfFragments(5, 'bio.content')
    .scoreOrder('bio.content');

highlight.toJSON()
```

--------------------------------

### RangeAggregationBase - Geo Distance Example

Source: https://elastic-builder.js.org/docs/index

Illustrates the configuration of a geo distance aggregation with multiple ranges using `RangeAggregationBase`. It includes setting an origin point and defining distance-based ranges.

```javascript
const agg = esb.geoDistanceAggregation('rings_around_amsterdam', 'location')
    .origin(esb.geoPoint().string('52.3760, 4.894'))
    .ranges([
        { to: 100000, key: 'first_ring' },
        { from: 100000, to: 300000, key: 'second_ring' },
        { from: 300000, key: 'third_ring' }
    ])
    .keyed(true);
```

--------------------------------

### MovingFunctionAggregation Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates creating a MovingFunctionAggregation with a specified name, buckets path, model, window size, gap policy, and custom settings. This aggregation is used for sliding window calculations on ordered data.

```javascript
const agg = esb.movingFunctionAggregation('the_movfn', 'the_sum')
    .model('holt')
    .window(5)
    .gapPolicy('insert_zeros')
    .settings({ alpha: 0.8 });
```

--------------------------------

### TopHitsAggregation Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to use TopHitsAggregation as a sub-aggregator within a terms aggregation to retrieve the top matching documents per bucket, sorted by date.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.termsAggregation('top_tags', 'type')
            .size(3)
            .agg(
                esb.topHitsAggregation('top_sales_hits')
                    .sort(esb.sort('date', 'desc'))
                    .source({ includes: ['date', 'price'] })
                    .size(1)
            )
    )
    .size(0);
```

--------------------------------

### Create DisMaxQuery with Match Queries

Source: https://elastic-builder.js.org/docs/index

Builds a DisMaxQuery using two match queries for different fields and sets a tie-breaker value. This example shows how to use match queries within a DisMaxQuery.

```javascript
const qry = esb.disMaxQuery()
    .queries([
        esb.matchQuery('subject', 'brown fox'),
        esb.matchQuery('message', 'brown fox')
    ])
    .tieBreaker(0.3);
```

--------------------------------

### IpRangeAggregation Example

Source: https://elastic-builder.js.org/docs/index

Creates an IpRangeAggregation for IP fields, allowing aggregation by IP address ranges. It can be configured with 'to' and 'from' values or by IP masks.

```javascript
const agg = esb.ipRangeAggregation('ip_ranges', 'ip').ranges([
    { to: '10.0.0.5' },
    { from: '10.0.0.5' }
]);
```

```javascript
const agg = esb.ipRangeAggregation('ip_ranges', 'ip').ranges([
    { mask: '10.0.0.0/25' },
    { mask: '10.0.0.127/25' }
]);
```

--------------------------------

### VariableWidthHistogramAggregation Example

Source: https://elastic-builder.js.org/docs/index

Illustrates creating a VariableWidthHistogramAggregation to group data dynamically based on a specified field and target number of buckets.

```javascript
const agg = esb.variableWidthHistogramAggregation('price', 'lowestPrice', 10)
```

--------------------------------

### RangeAggregationBase - Date Range Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create and configure a date range aggregation using the `RangeAggregationBase` class. It sets a date format and defines specific date ranges.

```javascript
const agg = esb.dateRangeAggregation('range', 'date')
    .format('MM-yyy')
    .ranges([{ to: 'now-10M/M' }, { from: 'now-10M/M' }])
    .keyed(true);
```

--------------------------------

### SpanWithinQuery Example

Source: https://elastic-builder.js.org/docs/index

Illustrates the usage of SpanWithinQuery to find matches enclosed within another span query. It also requires 'little' and 'big' clauses.

```javascript
const spanQry = esb.spanWithinQuery()
    .little(esb.spanTermQuery('field1', 'foo'))
    .big(esb.spanNearQuery()
        .clauses([
            esb.spanTermQuery('field1', 'bar'),
            esb.spanTermQuery('field1', 'baz')
        ])
        .slop(5)
        .inOrder(true))
```

--------------------------------

### NestedAggregation Example

Source: https://elastic-builder.js.org/docs/index

Creates a NestedAggregation for aggregating nested documents. It allows defining a nested path and applying further aggregations within the nested documents.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('name', 'led tv'))
    .agg(
        esb.nestedAggregation('resellers', 'resellers').agg(
            esb.minAggregation('min_price', 'resellers.price')
        )
    );
```

--------------------------------

### Set Date Histogram Offset

Source: https://elastic-builder.js.org/docs/index

Sets the offset for date histogram buckets. This shifts the start value of each bucket by a specified duration. For example, '6h' for 6 hours.

```javascript
const agg = esb.dateHistogramAggregation('by_day', 'date', 'day').offset('6h');
```

--------------------------------

### ReverseNestedAggregation Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to use ReverseNestedAggregation to break out of nested document structures and link to parent documents or other nested structures. It's used here to aggregate tags from comments related to 'led tv'.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('name', 'led tv'))
    .agg(
        esb.nestedAggregation('comments', 'comments').agg(
            esb.termsAggregation('top_usernames', 'comments.username').agg(
                esb.reverseNestedAggregation('comment_to_issue').agg(
                    esb.termsAggregation('top_tags_per_comment', 'tags')
                )
            )
        )
    );
```

--------------------------------

### CompletionSuggester with Contexts (Array)

Source: https://elastic-builder.js.org/docs/index

Adds context mappings to the completion suggester to filter and boost suggestions. This example demonstrates using an array of context objects, where each object specifies a context and an optional boost value, useful for categorizing suggestions.

```javascript
const suggest = new esb.CompletionSuggester('place_suggestion', 'suggest')
    .prefix('tim')
    .size(10)
    .contexts('place_type', [
        { context: 'cafe' },
        { context: 'restaurants', boost: 2 }
    ]);
```

--------------------------------

### Enabling Explanation for Score Computation

Source: https://elastic-builder.js.org/docs/index

Shows how to enable the `explain` option to get details on how each hit's score was computed. This method takes a boolean parameter and returns the `RequestBodySearch` instance.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .explain(true);
```

--------------------------------

### MatchQuery with Options in elastic-builder.js

Source: https://elastic-builder.js.org/docs/index

Demonstrates configuring a MatchQuery with various parameters like operator, fuzziness, and rewrite strategy. This allows for more flexible full-text searching.

```javascript
const { MatchQuery } = require('elastic-builder');

const query = new MatchQuery('message', 'this is a test')
    .operator('and')
    .fuzziness('AUTO')
    .rewrite('constant_score');

console.log(query.toJSON());
```

--------------------------------

### Import and Use elastic-builder

Source: https://elastic-builder.js.org/docs/index

Demonstrates two ways to import and use the elastic-builder library to construct an Elasticsearch request body. It shows both using the 'new' keyword for class instances and using helper methods for a more concise approach.

```javascript
const esb = require('elastic-builder'); // the builder

// Use `new` keyword for constructor instances of class
const requestBody = new esb.RequestBodySearch()
    .query(new esb.MatchQuery('message', 'this is a test'));

// Or use helper methods which construct the object without need for the `new` keyword
const requestBody = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'this is a test'));

// Build the request body
requestBody.toJSON()
```

```json
{
   "query": {
     "match": {
       "message": "this is a test"
     }
   }
 }
```

--------------------------------

### NestedQuery Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create a NestedQuery to search within nested objects. It specifies the nested object path and applies boolean and range queries to filter the nested documents.

```javascript
const qry = esb.nestedQuery()
    .path('obj1')
    .scoreMode('avg')
    .query(
        esb.boolQuery().must([
            esb.matchQuery('obj1.name', 'blue'),
            esb.rangeQuery('obj1.count').gt(5)
        ])
    );
```

--------------------------------

### BucketScriptAggregation Example

Source: https://elastic-builder.js.org/docs/index

Demonstrates creating a BucketScriptAggregation to calculate the percentage of t-shirt sales out of total sales within a date histogram. It requires a parent aggregation with sum aggregations for total sales and t-shirt sales.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('sales_per_month', 'date', 'month')
            .agg(esb.sumAggregation('total_sales', 'price'))
            .agg(
                esb.filterAggregation('t-shirts')
                    .filter(esb.termQuery('type', 't-shirt'))
                    .agg(esb.sumAggregation('sales', 'price'))
            )
            .agg(
                esb.bucketScriptAggregation('t-shirt-percentage')
                    .bucketsPath({
                        tShirtSales: 't-shirts>sales',
                        totalSales: 'total_sales'
                    })
                    .script('params.tShirtSales / params.totalSales * 100')
            )
    )
    .size(0);
```

--------------------------------

### SumAggregation Example

Source: https://elastic-builder.js.org/docs/index

Creates a SumAggregation to calculate the sum of numeric values from documents. It supports aggregation on a specific field or using scripts for custom value retrieval.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.constantScoreQuery(esb.matchQuery('type', 'hat')))
    .agg(esb.sumAggregation('hat_prices', 'price'));
```

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.constantScoreQuery(esb.matchQuery('type', 'hat')))
    .agg(
        esb.sumAggregation('hat_prices').script(
            esb.script('inline', 'doc.price.value')
        )
    );
```

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.constantScoreQuery(esb.matchQuery('type', 'hat')))
    .agg(
        esb.sumAggregation('square_hats', 'price').script(
            esb.script('inline', '_value * _value')
        )
    );
```

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.constantScoreQuery(esb.matchQuery('type', 'hat')))
    .agg(esb.sumAggregation('hat_prices', 'price').missing(100));
```

--------------------------------

### CompletionSuggester with Contexts (Array - GeoBoost)

Source: https://elastic-builder.js.org/docs/index

Boosts suggestions based on their proximity to geo-points, allowing suggestions closer to specified locations to rank higher. This example uses an array of context objects, each defining a geo-point and an optional precision and boost value.

```javascript
const suggest = new esb.CompletionSuggester('place_suggestion', 'suggest')
    .prefix('tim')
    .size(10)
    .contexts('location', [
        {
            lat: 43.6624803,
            lon: -79.3863353,
            precision: 2
        },
        {
            context: {
                lat: 43.6624803,
                lon: -79.3863353
            },
            boost: 2
        }
    ]);
```

--------------------------------

### StatsBucketAggregation Example

Source: https://elastic-builder.js.org/docs/index

Calculates various statistics across all buckets of a specified metric in a sibling aggregation. The metric must be numeric and the sibling aggregation must be a multi-bucket aggregation.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('sales_per_month', 'date')
            .interval('month')
            .agg(esb.sumAggregation('sales', 'price'))
    )
    .agg(
        // Calculates stats for monthly sales
        esb.statsBucketAggregation(
            'stats_monthly_sales',
            'sales_per_month>sales'
        )
    )
    .size(0);
```

--------------------------------

### BucketSelectorAggregation Example (Sales Threshold)

Source: https://elastic-builder.js.org/docs/index

Illustrates using BucketSelectorAggregation to filter monthly sales data, retaining only those months where total sales exceed a specified threshold. It requires a sum aggregation for total sales.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('sales_per_month', 'date')
            .interval('month')
            .agg(esb.sumAggregation('sales', 'price'))
            .agg(
                esb.bucketSelectorAggregation('sales_bucket_filter')
                    .bucketsPath({ totalSales: 'total_sales' })
                    .script('params.totalSales > 200')
            )
    )
    .size(0);
```

--------------------------------

### Create Search Request with Suggest Text and Multiple Suggestions

Source: https://elastic-builder.js.org/docs/index

Demonstrates setting a global suggest text and then applying multiple term suggesters to a search request.

```javascript
const req = esb.requestBodySearch()
    .suggestText('tring out elasticsearch')
    .suggest(esb.termSuggester('my-suggest-1', 'message'))
    .suggest(esb.termSuggester('my-suggest-2', 'user'));
```

--------------------------------

### Highlighting Configuration

Source: https://elastic-builder.js.org/docs/index

Sets up highlighting for search results, specifying fields to highlight, pre and post tags, fragment size, and number of fragments. Supports custom tag schemas and boundary characters for fragmenting.

```javascript
new Highlight()
  .field('content')
  .fields(['title', 'body'])
  .preTags('<em>')
  .postTags('</em>')
  .styledTagsSchema('styled')
  .scoreOrder(true)
  .fragmentSize(150)
  .numberOfFragments(3)
  .noMatchSize(0)
  .highlightQuery('search query')
  .matchedFields(['content'])
  .phraseLimit(10)
  .encoder('html')
  .requireFieldMatch(true)
  .boundaryMaxScan(20)
  .boundaryChars('#')
  .type('fvh')
  .forceSource(true)
  .fragmenter('simple');
```

--------------------------------

### Configure Phrase Suggester with Direct Generators

Source: https://elastic-builder.js.org/docs/index

Configures a phrase suggester with multiple direct generators to produce candidate terms per text term. This example shows how to add two direct generators with specific suggest modes and filters.

```javascript
const suggest = esb.phraseSuggester('simple_phrase', 'title.trigram')
    .size(1)
    .directGenerator([
        esb.directGenerator('title.trigram').suggestMode('always'),
        esb.directGenerator('title.reverse')
            .suggestMode('always')
            .preFilter('reverse')
            .postFilter('reverse')
    ]);
```

--------------------------------

### Configure BoostingQuery

Source: https://elastic-builder.js.org/docs/index

Provides methods to configure the BoostingQuery instance. The `positive()` method sets the main query, `negative()` sets the query for documents to be demoted, and `negativeBoost()` adjusts the demotion factor. All methods return the BoostingQuery instance for chaining.

```javascript
boostingQueryInstance.positive(query).negative(query).negativeBoost(0.5);
```

--------------------------------

### Create Range Query with Date Bounds

Source: https://elastic-builder.js.org/docs/index

Creates a Range query for a 'date' field, specifying a lower bound of 'now-1d/d' (start of yesterday) and an upper bound of 'now/d' (start of today), using less than for the upper bound.

```javascript
const qry = esb.rangeQuery('date').gte('now-1d/d').lt('now/d');
```

--------------------------------

### Set Execution Hint for Terms Aggregation (Standard)

Source: https://elastic-builder.js.org/docs/index

This example demonstrates setting the execution hint for a standard terms aggregation using the Elasticsearch DSL Builder for JavaScript. The 'map' hint is used to control value de-duplication.

```javascript
const agg = esb.termsAggregation('tags', 'tags').executionHint('map');
```

--------------------------------

### Initialize TermSuggester

Source: https://elastic-builder.js.org/docs/index

Creates a new TermSuggester instance with a name, field, and text to suggest terms for. The suggester analyzes the provided text before suggesting terms.

```javascript
const suggest = esb.termSuggester(
    'my-suggestion',
    'message',
    'tring out Elasticsearch'
);
```

--------------------------------

### Create IndexedShape Instance

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create an IndexedShape instance with or without initial ID and type, and chain methods to specify the index and path for the pre-indexed shape.

```javascript
const shape = esb.indexedShape('DEU', 'countries')
    .index('shapes')
    .path('location');

const shape = esb.indexedShape()
    .id('DEU')
    .type('countries')
    .index('shapes')
    .path('location');
```

--------------------------------

### Initialize DirectGenerator

Source: https://elastic-builder.js.org/docs/index

Initializes a new DirectGenerator instance. Optionally, a field can be provided to fetch candidate suggestions from.

```javascript
new DirectGenerator(field: string?)
```

--------------------------------

### Get Highlight DSL Representation

Source: https://elastic-builder.js.org/docs/index

Overrides the default toJSON method to return the DSL representation for the highlight request.

```javascript
toJSON(): Object
```

--------------------------------

### GeoPoint: Create and Chain Methods

Source: https://elastic-builder.js.org/docs/index

Demonstrates creating a GeoPoint object and chaining methods like lat(), lon(), object(), array(), and string() to set its value. The toJSON() method is used to get the Elasticsearch DSL representation.

```JavaScript
const esb = require('elastic-builder');

// Example using lat and lon
const geoPoint1 = esb.geoPoint().lat(40.7128).lon(-74.0060);
console.log(geoPoint1.toJSON());

// Example using an object
const geoPoint2 = esb.geoPoint().object({ lat: 34.0522, lon: -118.2437 });
console.log(geoPoint2.toJSON());

// Example using an array [lon, lat]
const geoPoint3 = esb.geoPoint().array([-74.0060, 40.7128]);
console.log(geoPoint3.toJSON());

// Example using a string
const geoPoint4 = esb.geoPoint().string('40.7128,-74.0060');
console.log(geoPoint4.toJSON());

// Example using a geo hash
const geoPoint5 = esb.geoPoint().string('ezs42');
console.log(geoPoint5.toJSON());

```

--------------------------------

### Set Moving Average Model

Source: https://elastic-builder.js.org/docs/index

Demonstrates setting the moving average weighting model to 'simple' and configuring the window size.

```javascript
const agg = esb.movingAverageAggregation('the_movavg', 'the_sum')
    .model('simple')
    .window(30);
```

--------------------------------

### Get Sort DSL Representation

Source: https://elastic-builder.js.org/docs/index

Overrides the default toJSON method to return the Elasticsearch DSL representation for the sort parameter.

```javascript
toJSON(): (Object | string)
```

--------------------------------

### ParentAggregation Example

Source: https://elastic-builder.js.org/docs/index

Creates a ParentAggregation to aggregate from child documents to parent documents, relying on the '_parent' field mapping. It can be chained with other aggregations.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.termsAggregation('top-names', 'owner.display_name.keyword')
            .size(10)
            .agg(
                esb.parentAggregation('to-questions')
                    .type('answer')
                    .agg(
                        esb.termsAggregation(
                            'top-tags',
                            'tags.keyword'
                        ).size(10)
                    )
            )
    )
    .size(0);
```

--------------------------------

### Create Basic Search Request

Source: https://elastic-builder.js.org/docs/index

Demonstrates creating a basic Elasticsearch search request body using `RequestBodySearch`. It includes setting a term query, 'from' offset, and 'size' limit.

```javascript
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .from(0)
    .size(10);

reqBody.toJSON();
```

--------------------------------

### Import elastic-builder from src

Source: https://elastic-builder.js.org/docs/index

Shows how to import the elastic-builder library directly from the 'src' directory, which can be used in Node.js environments version 6 and above, bypassing the default Babel transpilation.

```javascript
const esb = require('elastic-builder/src');
```

--------------------------------

### Access Missing Query Recipe

Source: https://elastic-builder.js.org/docs/index

Demonstrates accessing the `missingQuery` helper recipe using the `recipes` namespace.

```javascript
// `recipes` namespace
const qry = esb.recipes.missingQuery('user');
```

--------------------------------

### Get Script JSON Representation

Source: https://elastic-builder.js.org/docs/index

Overrides the default toJSON method to return the Elasticsearch query DSL representation of the script object.

```javascript
toJSON(): Object
```

--------------------------------

### Initialize CompletionSuggester

Source: https://elastic-builder.js.org/docs/index

Initializes a new CompletionSuggester with a name and an optional field. This suggester is optimized for speed to provide instant auto-complete feedback.

```javascript
const suggest = esb.completionSuggester('song-suggest', 'suggest').prefix('nir');
```

```javascript
const suggest = new esb.CompletionSuggester('place_suggestion', 'suggest')
    .prefix('tim')
    .size(10)
    .contexts('place_type', ['cafe', 'restaurants']);
```

--------------------------------

### Get ValueTermQueryBase DSL Representation

Source: https://elastic-builder.js.org/docs/index

Overrides the default toJSON method to return the Elasticsearch DSL representation of the term-level query instance.

```javascript
toJSON(): Object
```

--------------------------------

### MonoFieldQueryBase Initialization

Source: https://elastic-builder.js.org/docs/index

Initializes a MonoFieldQueryBase instance. While direct instantiation is not typically required, it can be extended for custom implementations. It takes the query type, an optional field, and an optional query string as parameters.

```javascript
new MonoFieldQueryBase(queryType: string, field: string?, queryString: string?)
```

--------------------------------

### MissingAggregation Example

Source: https://elastic-builder.js.org/docs/index

Creates a MissingAggregation to bucket documents that are missing a specific field or have a configured NULL value. It's a field-data based aggregation.

```javascript
const agg = esb.missingAggregation('products_without_a_price', 'price');
```

--------------------------------

### Configure GeoDistanceAggregation Unit

Source: https://elastic-builder.js.org/docs/index

Shows how to set the distance unit for the GeoDistanceAggregation to kilometers. This example also defines distance ranges and the origin point.

```javascript
const agg = esb.geoDistanceAggregation('rings_around_amsterdam', 'location')
    .origin(esb.geoPoint().string('52.3760, 4.894'))
    .unit('km')
    .ranges([{ to: 100 }, { from: 100, to: 300 }, { from: 300 }]);

```

--------------------------------

### SumBucketAggregation Example

Source: https://elastic-builder.js.org/docs/index

Calculates the sum across all buckets of a specified metric in a sibling aggregation. Requires the metric to be numeric and the sibling aggregation to be a multi-bucket aggregation.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('sales_per_month', 'date')
            .interval('month')
            .agg(esb.sumAggregation('sales', 'price'))
    )
    .agg(
        // Get the sum of all the total monthly `sales` buckets
        esb.sumBucketAggregation(
            'sum_monthly_sales',
            'sales_per_month>sales'
        )
    )
    .size(0);
```

--------------------------------

### CompletionSuggester Configuration

Source: https://elastic-builder.js.org/docs/index

Configures the CompletionSuggester for fuzzy matching, prefix matching, and Unicode awareness. Supports skipping duplicate suggestions and defining fuzzy parameters like transpositions and minimum length.

```javascript
new CompletionSuggester()
  .prefix('somePrefix')
  .skipDuplicates(true)
  .fuzzy(true)
  .fuzziness(0.7)
  .transpositions(true)
  .minLength(3)
  .prefixLength(2)
  .unicodeAware(true)
  .regex('pattern')
  .flags('i')
  .maxDeterminizedStates(10000)
  .contexts({
    'context_field': 'context_value'
  });
```

--------------------------------

### Create File-Based Search Template with Parameters

Source: https://elastic-builder.js.org/docs/index

Creates a search template using a file source and provides parameters to render the template. The filename refers to a `.mustache` file in the scripts directory.

```javascript
// `templId` - Name of the query template in config/scripts/, i.e.,
// storedTemplate.mustache.
const templ = new esb.SearchTemplate('file', 'storedTemplate').params({
    query_string: 'search for these words'
});
```

--------------------------------

### Get Phrase Suggester DSL Representation

Source: https://elastic-builder.js.org/docs/index

Overrides the default toJSON method to return the DSL representation for the phrase suggester, which maps to the Elasticsearch DSL.

```javascript
toJSON(): Object
```

--------------------------------

### Create MovingAverageAggregation

Source: https://elastic-builder.js.org/docs/index

Demonstrates how to create a MovingAverageAggregation with a specified name, buckets path, model, window size, and gap policy.

```javascript
const agg = esb.movingAverageAggregation('the_movavg', 'the_sum')
    .model('holt')
    .window(5)
    .gapPolicy('insert_zeros')
    .settings({ alpha: 0.8 });
```

--------------------------------

### Create CompositeAggregation with Date Histogram and Terms Sources

Source: https://elastic-builder.js.org/docs/index

Illustrates creating a CompositeAggregation with multiple sources: a date histogram on 'timestamp' and a terms source on 'product'. It also demonstrates setting the size and ordering for the sources, and using the 'after' parameter for pagination.

```javascript
const { CompositeAggregation } = esb;
const reqBody = esb.requestBodySearch()
  .agg(
    esb.compositeAggregation('my_buckets')
      .sources(
        CompositeAggregation.dateHistogramValuesSource(
          'date',
          'timestamp',
          '1d'
        ),
        CompositeAggregation.termsValuesSource('product', 'product')
      )
  );
```

```javascript
const { CompositeAggregation } = esb;
const reqBody = esb.requestBodySearch().agg(
  esb.compositeAggregation('my_buckets')
    .size(2)
    .sources(
      CompositeAggregation.dateHistogramValuesSource(
        'date',
        'timestamp',
        '1d'
      ).order('desc'),
      CompositeAggregation.termsValuesSource('product', 'product').order('asc')
    )
    .after({ date: 1494288000000, product: 'mad max' })
);
```

--------------------------------

### Generate Elasticsearch DSL

Source: https://elastic-builder.js.org/docs/index

Builds and returns the Elasticsearch DSL representation of the Aggregation instance. This method is used to get the query structure that can be sent to Elasticsearch.

```javascript
getDSL(): Object
```

```javascript
toJSON(): Object
```

--------------------------------

### Enable Minimization for Holt-Winters

Source: https://elastic-builder.js.org/docs/index

Demonstrates enabling minimization for the 'holt_winters' model and setting specific model parameters like period.

```javascript
const agg = esb.movingAverageAggregation('the_movavg', 'the_sum')
    .model('holt_winters')
    .window(30)
    .minimize(true)
    .settings({ period: 7 });
```

--------------------------------

### CumulativeSumAggregation within DateHistogram

Source: https://elastic-builder.js.org/docs/index

Provides an example of using CumulativeSumAggregation within a date_histogram. It first calculates the sum of 'price' and then computes the cumulative sum of these sales figures.

```javascript
const reqBody = esb.requestBodySearch()
    .agg(
        esb.dateHistogramAggregation('sales_per_month', 'date', 'month')
            .agg(esb.sumAggregation('sales', 'price'))
            .agg(esb.cumulativeSumAggregation('cumulative_sales', 'sales'))
    )
    .size(0);
```

--------------------------------

### Set GeoDistanceAggregation Distance Type

Source: https://elastic-builder.js.org/docs/index

Illustrates setting the distance calculation mode to 'plane' for the GeoDistanceAggregation. This example includes setting the origin, unit, and distance ranges.

```javascript
const agg = esb.geoDistanceAggregation('rings_around_amsterdam', 'location')
    .origin(esb.geoPoint().string('52.3760, 4.894'))
    .unit('km')
    .distanceType('plane')
    .ranges([{ to: 100 }, { from: 100, to: 300 }, { from: 300 }]);

```

--------------------------------

### Create PhraseSuggester

Source: https://elastic-builder.js.org/docs/index

Initializes a new PhraseSuggester with a name, field, and text. It allows chaining of configuration methods like setting size, gram size, direct generators, and highlighting.

```javascript
const suggest = esb.phraseSuggester(
    'simple_phrase',
    'title.trigram',
    'noble prize'
)
    .size(1)
    .gramSize(3)
    .directGenerator(esb.directGenerator('title.trigram').suggestMode('always'))
    .highlight('<em>', '</em>');
```
Tokens:
Raw