elasticlink 0.2.1-beta → 0.3.0-beta

package/dist/query.builder.js

@@ -4,10 +4,6 @@
  */
 import { createAggregationBuilder } from './aggregation.builder.js';
 import { createSuggesterBuilder } from './suggester.builder.js';
-/**
- * Creates a clause builder for constructing query clauses
- * Used within bool query contexts (must, should, filter, must_not)
- */
 const createClauseBuilder = () => ({
     matchAll: () => ({ match_all: {} }),
     match: (field, value, options) => {
@@ -60,11 +56,7 @@ const createClauseBuilder = () => ({
         const { source, lang = 'painless', params, boost } = options;
         return {
             script: {
-                script: {
-                    source,
-                    lang,
-                    ...(params ? { params } : {})
-                },
+                script: { source, lang, ...(params ? { params } : {}) },
                 ...(boost ? { boost } : {})
             }
         };
@@ -76,18 +68,10 @@ const createClauseBuilder = () => ({
         return elseFn ? elseFn(createClauseBuilder()) : undefined;
     }
 });
-/** Shared clause builder instance */
-const clauseBuilder = createClauseBuilder();
-/**
- * Creates a query builder with immutable state
- * @param state - Current query state (optional)
- * @returns QueryBuilder instance with fluent API
- */
 export const createQueryBuilder = (state = {}) => ({
-    // Boolean query methods
     bool: () => createQueryBuilder({ ...state, query: { bool: {} } }),
     must: (builderFn) => {
-        const clause = builderFn(clauseBuilder);
+        const clause = builderFn(createClauseBuilder());
         const existing = state.query?.bool?.must || [];
         return createQueryBuilder({
             ...state,
@@ -95,7 +79,7 @@ export const createQueryBuilder = (state = {}) => ({
         });
     },
     mustNot: (builderFn) => {
-        const clause = builderFn(clauseBuilder);
+        const clause = builderFn(createClauseBuilder());
         const existing = state.query?.bool?.must_not || [];
         return createQueryBuilder({
             ...state,
@@ -103,7 +87,7 @@ export const createQueryBuilder = (state = {}) => ({
         });
     },
     should: (builderFn) => {
-        const clause = builderFn(clauseBuilder);
+        const clause = builderFn(createClauseBuilder());
         const existing = state.query?.bool?.should || [];
         return createQueryBuilder({
             ...state,
@@ -111,20 +95,17 @@ export const createQueryBuilder = (state = {}) => ({
         });
     },
     filter: (builderFn) => {
-        const clause = builderFn(clauseBuilder);
+        const clause = builderFn(createClauseBuilder());
         const existing = state.query?.bool?.filter || [];
         return createQueryBuilder({
             ...state,
             query: { bool: { ...state.query.bool, filter: [...existing, clause] } }
         });
     },
-    minimumShouldMatch: (value) => {
-        return createQueryBuilder({
-            ...state,
-            query: { bool: { ...state.query.bool, minimum_should_match: value } }
-        });
-    },
-    // Full-text query methods
+    minimumShouldMatch: (value) => createQueryBuilder({
+        ...state,
+        query: { bool: { ...state.query.bool, minimum_should_match: value } }
+    }),
     matchAll: () => createQueryBuilder({ ...state, query: { match_all: {} } }),
     match: (field, value, options) => {
         if (!options || Object.keys(options).length === 0) {
@@ -150,8 +131,6 @@ export const createQueryBuilder = (state = {}) => ({
             query: { multi_match: { fields, query, ...options } }
         });
     },
-    // Term-level query methods
-    term: (field, value) => createQueryBuilder({ ...state, query: { term: { [field]: value } } }),
     matchPhrase: (field, value) => createQueryBuilder({
         ...state,
         query: { match_phrase: { [field]: value } }
@@ -168,7 +147,12 @@ export const createQueryBuilder = (state = {}) => ({
             query: { match_phrase_prefix: { [field]: { query: value, ...options } } }
         });
     },
-    terms: (field, value) => createQueryBuilder({ ...state, query: { terms: { [field]: value } } }),
+    term: (field, value) => createQueryBuilder({ ...state, query: { term: { [field]: value } } }),
+    terms: (field, values) => createQueryBuilder({ ...state, query: { terms: { [field]: values } } }),
+    range: (field, conditions) => createQueryBuilder({
+        ...state,
+        query: { range: { [field]: conditions } }
+    }),
     exists: (field) => createQueryBuilder({ ...state, query: { exists: { field } } }),
     prefix: (field, value) => createQueryBuilder({ ...state, query: { prefix: { [field]: value } } }),
     wildcard: (field, value) => createQueryBuilder({
@@ -187,11 +171,7 @@ export const createQueryBuilder = (state = {}) => ({
             query: { fuzzy: { [field]: { value, ...options } } }
         });
     },
-    ids: (values) => createQueryBuilder({
-        ...state,
-        query: { ids: { values } }
-    }),
-    // Nested query
+    ids: (values) => createQueryBuilder({ ...state, query: { ids: { values } } }),
     nested: (path, fn, options) => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const nestedQuery = fn(createClauseBuilder());
@@ -206,7 +186,6 @@ export const createQueryBuilder = (state = {}) => ({
             }
         });
     },
-    // Vector search
     knn: (field, queryVector, options) => {
         const { k, num_candidates, filter, boost, similarity } = options;
         return createQueryBuilder({
@@ -222,36 +201,27 @@ export const createQueryBuilder = (state = {}) => ({
             }
         });
     },
-    // Script queries
     script: (options) => {
         const { source, lang = 'painless', params, boost } = options;
         return createQueryBuilder({
             ...state,
             query: {
                 script: {
-                    script: {
-                        source,
-                        lang,
-                        ...(params ? { params } : {})
-                    },
+                    script: { source, lang, ...(params ? { params } : {}) },
                     ...(boost ? { boost } : {})
                 }
             }
         });
     },
     scriptScore: (queryFn, script, options) => {
-        const innerQuery = queryFn(clauseBuilder);
+        const innerQuery = queryFn(createClauseBuilder());
         const { source, lang = 'painless', params } = script;
         return createQueryBuilder({
             ...state,
             query: {
                 script_score: {
                     query: innerQuery,
-                    script: {
-                        source,
-                        lang,
-                        ...(params ? { params } : {})
-                    },
+                    script: { source, lang, ...(params ? { params } : {}) },
                     ...(options?.min_score !== undefined
                         ? { min_score: options.min_score }
                         : {}),
@@ -260,47 +230,30 @@ export const createQueryBuilder = (state = {}) => ({
             }
         });
     },
-    percolate: (options) => {
-        return createQueryBuilder({
-            ...state,
-            query: {
-                percolate: {
-                    ...options
-                }
-            }
-        });
-    },
-    // Conditional building
+    percolate: (options) => createQueryBuilder({ ...state, query: { percolate: { ...options } } }),
     when: (condition, thenFn, elseFn) => {
         if (condition) {
             return thenFn(createQueryBuilder(state));
         }
         return elseFn ? elseFn(createQueryBuilder(state)) : undefined;
     },
-    range: (field, conditions) => createQueryBuilder({ ...state, query: { range: { [field]: conditions } } }),
-    // Sorting
     sort: (field, direction = 'asc') => {
         const existing = state.sort || [];
         return createQueryBuilder({
             ...state,
-            sort: [
-                ...existing,
-                { [field]: direction }
-            ]
+            sort: [...existing, { [field]: direction }]
         });
     },
-    // Pagination and source filtering
     from: (from) => createQueryBuilder({ ...state, from }),
     size: (size) => createQueryBuilder({ ...state, size }),
     _source: (_source) => createQueryBuilder({ ...state, _source }),
-    // Query parameters
     timeout: (timeout) => createQueryBuilder({ ...state, timeout }),
     trackScores: (track_scores) => createQueryBuilder({ ...state, track_scores }),
     explain: (explain) => createQueryBuilder({ ...state, explain }),
     minScore: (min_score) => createQueryBuilder({ ...state, min_score }),
     version: (version) => createQueryBuilder({ ...state, version }),
     seqNoPrimaryTerm: (seq_no_primary_term) => createQueryBuilder({ ...state, seq_no_primary_term }),
-    trackTotalHits: (track_total_hits) => createQueryBuilder({ ...state, track_total_hits }),
+    trackTotalHits: (track_total_hits = true) => createQueryBuilder({ ...state, track_total_hits }),
     highlight: (fields, options) => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const highlightFields = {};
@@ -318,33 +271,18 @@ export const createQueryBuilder = (state = {}) => ({
             }
         });
     },
-    // Geo queries
     geoDistance: (field, center, options) => createQueryBuilder({
         ...state,
-        query: {
-            geo_distance: {
-                [String(field)]: center,
-                ...options
-            }
-        }
+        query: { geo_distance: { [String(field)]: center, ...options } }
     }),
     geoBoundingBox: (field, options) => createQueryBuilder({
         ...state,
-        query: {
-            geo_bounding_box: {
-                [String(field)]: options
-            }
-        }
+        query: { geo_bounding_box: { [String(field)]: options } }
     }),
     geoPolygon: (field, options) => createQueryBuilder({
         ...state,
-        query: {
-            geo_polygon: {
-                [String(field)]: options
-            }
-        }
+        query: { geo_polygon: { [String(field)]: options } }
     }),
-    // Pattern and scoring queries
     regexp: (field, value, options) => {
         if (!options || Object.keys(options).length === 0) {
             return createQueryBuilder({
@@ -358,7 +296,7 @@ export const createQueryBuilder = (state = {}) => ({
         });
     },
     constantScore: (fn, options) => {
-        const clause = fn(clauseBuilder);
+        const clause = fn(createClauseBuilder());
         return createQueryBuilder({
             ...state,
             query: {
@@ -369,19 +307,19 @@ export const createQueryBuilder = (state = {}) => ({
             }
         });
     },
-    // Aggregations
     aggs: (fn) => {
         const aggBuilder = createAggregationBuilder();
         const builtAggs = fn(aggBuilder).build();
         return createQueryBuilder({ ...state, aggs: builtAggs });
     },
-    // Suggestions
     suggest: (fn) => {
         const suggesterBuilder = createSuggesterBuilder();
         const builtSuggestions = fn(suggesterBuilder).build();
-        return createQueryBuilder({ ...state, suggest: builtSuggestions.suggest });
+        return createQueryBuilder({
+            ...state,
+            suggest: builtSuggestions.suggest
+        });
     },
-    // Build final query
     build: () => {
         const { _includeQuery, ...rest } = state;
         if (_includeQuery === false) {