elasticlink 1.0.0-beta.1 → 1.0.0

package/dist/query.builder.js

@@ -1,329 +0,0 @@
-import { createAggregationBuilder } from './aggregation.builder.js';
-import { createSuggesterBuilder } from './suggester.builder.js';
-// prettier-ignore
-const resolveCondition = (c) => typeof c === 'function'
-    ? resolveCondition(c())
-    : typeof c === 'boolean'
-        ? c
-        : c != null;
-// wrap accepts `any` because this factory is shared: ClauseBuilder callers pass a wrap that returns raw DSL
-// objects, while QueryBuilder callers pass a wrap that returns a new QueryBuilder<M>. The generic R captures
-// the difference at each call site — `any` avoids a union type that would make every method's return type unreadable.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const createClauseMethods = (wrap, qualifyField = (f) => f) => ({
-    // eslint-disable-next-line functional/functional-parameters
-    matchAll: () => wrap({ match_all: {} }),
-    // eslint-disable-next-line functional/functional-parameters
-    matchNone: () => wrap({ match_none: {} }),
-    match: (field, value, options) => wrap({ match: { [qualifyField(field)]: options ? { query: value, ...options } : value } }),
-    multiMatch: (fields, query, options) => wrap({ multi_match: { fields: fields.map(qualifyField), query, ...options } }),
-    matchPhrase: (field, query) => wrap({ match_phrase: { [qualifyField(field)]: query } }),
-    matchPhrasePrefix: (field, value, options) => wrap({ match_phrase_prefix: { [qualifyField(field)]: options ? { query: value, ...options } : value } }),
-    term: (field, value) => wrap({ term: { [qualifyField(field)]: value } }),
-    terms: (field, value) => wrap({ terms: { [qualifyField(field)]: value } }),
-    range: (field, conditions) => wrap({ range: { [qualifyField(field)]: conditions } }),
-    exists: (field) => wrap({ exists: { field: qualifyField(field) } }),
-    prefix: (field, value) => wrap({ prefix: { [qualifyField(field)]: value } }),
-    wildcard: (field, value) => wrap({ wildcard: { [qualifyField(field)]: value } }),
-    fuzzy: (field, value, options) => wrap({ fuzzy: { [qualifyField(field)]: options ? { value, ...options } : { value } } }),
-    ids: (values) => wrap({ ids: { values } }),
-    script: (options) => {
-        const { source, lang = 'painless', params, boost } = options;
-        return wrap({
-            script: {
-                script: { source, lang, ...(params !== undefined && { params }) },
-                ...(boost !== undefined && { boost })
-            }
-        });
-    },
-    combinedFields: (fields, query, options) => wrap({ combined_fields: { fields: fields.map(qualifyField), query, ...options } }),
-    queryString: (query, options) => wrap({ query_string: { query, ...options } }),
-    simpleQueryString: (query, options) => wrap({ simple_query_string: { query, ...options } }),
-    moreLikeThis: (fields, like, options) => wrap({
-        more_like_this: {
-            fields: fields.map(qualifyField),
-            like: Array.isArray(like) ? like : [like],
-            ...options
-        }
-    }),
-    matchBoolPrefix: (field, value, options) => wrap({ match_bool_prefix: { [qualifyField(field)]: options ? { query: value, ...options } : value } }),
-    regexp: (field, value, options) => wrap({ regexp: { [qualifyField(field)]: options ? { value, ...options } : value } }),
-    geoDistance: (field, center, options) => wrap({ geo_distance: { [qualifyField(field)]: center, ...options } }),
-    geoBoundingBox: (field, options) => wrap({ geo_bounding_box: { [qualifyField(field)]: options } }),
-    geoPolygon: (field, options) => wrap({ geo_polygon: { [qualifyField(field)]: options } }),
-    geoShape: (field, shape, options) => wrap({ geo_shape: { [qualifyField(field)]: { shape, ...options } } }),
-    distanceFeature: (field, options) => wrap({ distance_feature: { field: qualifyField(field), ...options } }),
-    rankFeature: (field, options) => wrap({ rank_feature: { field: qualifyField(field), ...options } }),
-    sparseVector: (field, options) => wrap({ sparse_vector: { field: qualifyField(field), ...options } }),
-    intervals: (field, options) => wrap({ intervals: { [qualifyField(field)]: options } }),
-    spanTerm: (field, value) => wrap({ span_term: { [qualifyField(field)]: { value } } }),
-    spanNear: (clauses, options) => wrap({ span_near: { clauses: [...clauses], ...options } }),
-    spanOr: (clauses) => wrap({ span_or: { clauses: [...clauses] } }),
-    spanNot: (include, exclude, options) => wrap({ span_not: { include, exclude, ...options } }),
-    spanFirst: (match, end) => wrap({ span_first: { match, end } }),
-    spanContaining: (big, little) => wrap({ span_containing: { big, little } }),
-    spanWithin: (big, little) => wrap({ span_within: { big, little } }),
-    spanMultiTerm: (query) => wrap({ span_multi: { match: query } }),
-    spanFieldMasking: (field, query) => wrap({ span_field_masking: { field: qualifyField(field), query } })
-});
-const createClauseBuilder = (prefix) => {
-    const qualifyField = prefix ? (f) => `${prefix}.${f}` : (f) => f;
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ...createClauseMethods((dsl) => dsl, qualifyField),
-        knn: (field, queryVector, options) => {
-            const { k, num_candidates, ...restOptions } = options;
-            return {
-                knn: {
-                    field: qualifyField(field),
-                    query_vector: queryVector,
-                    k,
-                    num_candidates,
-                    ...restOptions
-                }
-            };
-        },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        nested: (path, fn, options) => {
-            const nestedPath = prefix ? `${prefix}.${path}` : path;
-            const nestedQuery = fn(createClauseBuilder(nestedPath));
-            return nestedQuery === undefined ? undefined : { nested: { path: nestedPath, query: nestedQuery, ...options } };
-        },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        functionScore: (queryFn, options) => {
-            const innerQuery = queryFn(createClauseBuilder(prefix)) ?? { match_all: {} };
-            return { function_score: { query: innerQuery, ...options } };
-        },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        hasChild: (type, queryFn, options) => {
-            const childQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
-            return { has_child: { type, query: childQuery, ...options } };
-        },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        hasParent: (type, queryFn, options) => {
-            const parentQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
-            return { has_parent: { parent_type: type, query: parentQuery, ...options } };
-        },
-        parentId: (type, id, options) => ({
-            parent_id: { type, id, ...options }
-        }),
-        when: (condition, thenFn) => (resolveCondition(condition) ? thenFn(createClauseBuilder(prefix)) : undefined)
-    };
-};
-export const createQueryBuilder = (state = {}) => {
-    const q = (state.query ?? {});
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ...createClauseMethods((dsl) => createQueryBuilder({ ...state, query: dsl })),
-        // eslint-disable-next-line functional/functional-parameters
-        bool: () => createQueryBuilder({ ...state, query: { bool: {} } }),
-        must: (builderFn) => {
-            const clause = builderFn(createClauseBuilder());
-            const existing = q.bool?.must ?? [];
-            return clause === undefined
-                ? createQueryBuilder(state)
-                : createQueryBuilder({
-                    ...state,
-                    query: { bool: { ...q.bool, must: [...existing, clause] } }
-                });
-        },
-        mustNot: (builderFn) => {
-            const clause = builderFn(createClauseBuilder());
-            const existing = q.bool?.must_not ?? [];
-            return clause === undefined
-                ? createQueryBuilder(state)
-                : createQueryBuilder({
-                    ...state,
-                    query: { bool: { ...q.bool, must_not: [...existing, clause] } }
-                });
-        },
-        should: (builderFn) => {
-            const clause = builderFn(createClauseBuilder());
-            const existing = q.bool?.should ?? [];
-            return clause === undefined
-                ? createQueryBuilder(state)
-                : createQueryBuilder({
-                    ...state,
-                    query: { bool: { ...q.bool, should: [...existing, clause] } }
-                });
-        },
-        filter: (builderFn) => {
-            const clause = builderFn(createClauseBuilder());
-            const existing = q.bool?.filter ?? [];
-            return clause === undefined
-                ? createQueryBuilder(state)
-                : createQueryBuilder({
-                    ...state,
-                    query: { bool: { ...q.bool, filter: [...existing, clause] } }
-                });
-        },
-        minimumShouldMatch: (value) => createQueryBuilder({
-            ...state,
-            query: { bool: { ...q.bool, minimum_should_match: value } }
-        }),
-        knn: (field, queryVector, options) => {
-            const { k, num_candidates, ...restOptions } = options;
-            return createQueryBuilder({
-                ...state,
-                knn: {
-                    field,
-                    query_vector: queryVector,
-                    k,
-                    num_candidates,
-                    ...restOptions
-                }
-            });
-        },
-        nested: (path, fn, options) => {
-            const nestedQuery = fn(createClauseBuilder(path));
-            return nestedQuery === undefined
-                ? createQueryBuilder(state)
-                : createQueryBuilder({
-                    ...state,
-                    query: { nested: { path, query: nestedQuery, ...options } }
-                });
-        },
-        scriptScore: (queryFn, script, options) => {
-            const innerQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
-            const { source, lang = 'painless', params } = script;
-            return createQueryBuilder({
-                ...state,
-                query: {
-                    script_score: {
-                        query: innerQuery,
-                        script: { source, lang, ...(params !== undefined && { params }) },
-                        ...(options?.min_score !== undefined && { min_score: options.min_score }),
-                        ...(options?.boost !== undefined && { boost: options.boost })
-                    }
-                }
-            });
-        },
-        percolate: (options) => createQueryBuilder({ ...state, query: { percolate: { ...options } } }),
-        functionScore: (queryFn, options) => {
-            const innerQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
-            return createQueryBuilder({
-                ...state,
-                query: { function_score: { query: innerQuery, ...options } }
-            });
-        },
-        hasChild: (type, queryFn, options) => {
-            const childQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
-            return createQueryBuilder({
-                ...state,
-                query: { has_child: { type, query: childQuery, ...options } }
-            });
-        },
-        hasParent: (type, queryFn, options) => {
-            const parentQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
-            return createQueryBuilder({
-                ...state,
-                query: { has_parent: { parent_type: type, query: parentQuery, ...options } }
-            });
-        },
-        parentId: (type, id, options) => createQueryBuilder({ ...state, query: { parent_id: { type, id, ...options } } }),
-        when: (condition, thenFn) => resolveCondition(condition) ? thenFn(createQueryBuilder(state)) : createQueryBuilder(state),
-        sort: (field, direction = 'asc') => {
-            const existing = state.sort || [];
-            return createQueryBuilder({
-                ...state,
-                sort: [...existing, { [field]: direction }]
-            });
-        },
-        from: (from) => createQueryBuilder({ ...state, from }),
-        size: (size) => createQueryBuilder({ ...state, size }),
-        _source: (_source) => createQueryBuilder({ ...state, _source }),
-        sourceIncludes: (paths) => createQueryBuilder({ ...state, _source_includes: paths }),
-        sourceExcludes: (paths) => createQueryBuilder({ ...state, _source_excludes: paths }),
-        runtimeMappings: (runtime_mappings) => createQueryBuilder({ ...state, runtime_mappings }),
-        docValueFields: (docvalue_fields) => createQueryBuilder({ ...state, docvalue_fields }),
-        fields: (fields) => createQueryBuilder({ ...state, fields }),
-        postFilter: (fn) => {
-            const clause = fn(createClauseBuilder());
-            return clause === undefined
-                ? createQueryBuilder(state)
-                : createQueryBuilder({ ...state, post_filter: clause });
-        },
-        scriptFields: (script_fields) => createQueryBuilder({ ...state, script_fields }),
-        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 = true) => createQueryBuilder({ ...state, track_total_hits }),
-        highlight: (fields, options) => {
-            const { pre_tags, post_tags, ...fieldOptions } = options || {};
-            const fieldValue = Object.keys(fieldOptions).length > 0 ? fieldOptions : {};
-            const highlightFields = Object.fromEntries(fields.map((field) => [field, fieldValue]));
-            return createQueryBuilder({
-                ...state,
-                highlight: {
-                    fields: highlightFields,
-                    ...(pre_tags && { pre_tags }),
-                    ...(post_tags && { post_tags })
-                }
-            });
-        },
-        constantScore: (fn, options) => {
-            const clause = fn(createClauseBuilder());
-            return createQueryBuilder({
-                ...state,
-                query: {
-                    constant_score: {
-                        filter: clause,
-                        ...options
-                    }
-                }
-            });
-        },
-        searchAfter: (values) => createQueryBuilder({ ...state, search_after: values }),
-        preference: (value) => createQueryBuilder({ ...state, preference: value }),
-        collapse: (field, options) => createQueryBuilder({
-            ...state,
-            collapse: {
-                field,
-                ...options
-            }
-        }),
-        rescore: (queryFn, windowSize, options) => {
-            const rescoreQuery = queryFn(createClauseBuilder());
-            return createQueryBuilder({
-                ...state,
-                rescore: {
-                    window_size: windowSize,
-                    query: {
-                        rescore_query: rescoreQuery,
-                        ...options
-                    }
-                }
-            });
-        },
-        storedFields: (fields) => createQueryBuilder({ ...state, stored_fields: fields }),
-        terminateAfter: (count) => createQueryBuilder({ ...state, terminate_after: count }),
-        pit: (id, keepAlive) => createQueryBuilder({ ...state, pit: { id, keep_alive: keepAlive } }),
-        indicesBoost: (boosts) => createQueryBuilder({ ...state, indices_boost: boosts }),
-        aggs: (fn) => {
-            const aggBuilder = createAggregationBuilder();
-            const builtAggs = fn(aggBuilder).build();
-            return createQueryBuilder({ ...state, aggs: builtAggs });
-        },
-        suggest: (fn) => {
-            const suggesterBuilder = createSuggesterBuilder();
-            const builtSuggestions = fn(suggesterBuilder).build();
-            return createQueryBuilder({
-                ...state,
-                suggest: builtSuggestions.suggest
-            });
-        },
-        // eslint-disable-next-line functional/functional-parameters
-        build: () => {
-            const { _includeQuery, ...rest } = state;
-            // eslint-disable-next-line functional/no-conditional-statements
-            if (_includeQuery === false) {
-                const { query: _q, ...noQuery } = rest;
-                return noQuery;
-            }
-            return rest;
-        }
-    };
-};