elastiq-ts 0.1.0-beta

package/dist/query-builder.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * Query builder implementation
+ * Builds type-safe Elasticsearch queries with a fluent API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueryBuilder = void 0;
+const aggregation_builder_1 = require("./aggregation-builder");
+const suggester_1 = require("./suggester");
+/**
+ * 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) => {
+        if (!options || Object.keys(options).length === 0) {
+            return { match: { [field]: value } };
+        }
+        return { match: { [field]: { query: value, ...options } } };
+    },
+    multiMatch: (fields, query, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return { multi_match: { fields, query } };
+        }
+        return { multi_match: { fields, query, ...options } };
+    },
+    matchPhrase: (field, query) => ({ match_phrase: { [field]: query } }),
+    matchPhrasePrefix: (field, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return { match_phrase_prefix: { [field]: value } };
+        }
+        return { match_phrase_prefix: { [field]: { query: value, ...options } } };
+    },
+    term: (field, value) => ({ term: { [field]: value } }),
+    terms: (field, value) => ({ terms: { [field]: value } }),
+    range: (field, conditions) => ({ range: { [field]: conditions } }),
+    exists: (field) => ({ exists: { field } }),
+    prefix: (field, value) => ({ prefix: { [field]: value } }),
+    wildcard: (field, value) => ({ wildcard: { [field]: value } }),
+    fuzzy: (field, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return { fuzzy: { [field]: { value } } };
+        }
+        return { fuzzy: { [field]: { value, ...options } } };
+    },
+    ids: (values) => ({ ids: { values } }),
+    knn: (field, queryVector, options) => {
+        const { k, num_candidates, filter, boost, similarity } = options;
+        return {
+            knn: {
+                field: String(field),
+                query_vector: queryVector,
+                k,
+                num_candidates,
+                ...(filter ? { filter } : {}),
+                ...(boost ? { boost } : {}),
+                ...(similarity !== undefined ? { similarity } : {})
+            }
+        };
+    },
+    script: (options) => {
+        const { source, lang = 'painless', params, boost } = options;
+        return {
+            script: {
+                script: {
+                    source,
+                    lang,
+                    ...(params ? { params } : {})
+                },
+                ...(boost ? { boost } : {})
+            }
+        };
+    },
+    when: (condition, thenFn, elseFn) => {
+        if (condition) {
+            return thenFn(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
+ */
+const createQueryBuilder = (state = {}) => ({
+    // Boolean query methods
+    bool: () => (0, exports.createQueryBuilder)({ ...state, query: { bool: {} } }),
+    must: (builderFn) => {
+        const clause = builderFn(clauseBuilder);
+        const existing = state.query?.bool?.must || [];
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { bool: { ...state.query.bool, must: [...existing, clause] } }
+        });
+    },
+    mustNot: (builderFn) => {
+        const clause = builderFn(clauseBuilder);
+        const existing = state.query?.bool?.must_not || [];
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { bool: { ...state.query.bool, must_not: [...existing, clause] } }
+        });
+    },
+    should: (builderFn) => {
+        const clause = builderFn(clauseBuilder);
+        const existing = state.query?.bool?.should || [];
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { bool: { ...state.query.bool, should: [...existing, clause] } }
+        });
+    },
+    filter: (builderFn) => {
+        const clause = builderFn(clauseBuilder);
+        const existing = state.query?.bool?.filter || [];
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { bool: { ...state.query.bool, filter: [...existing, clause] } }
+        });
+    },
+    minimumShouldMatch: (value) => {
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { bool: { ...state.query.bool, minimum_should_match: value } }
+        });
+    },
+    // Full-text query methods
+    matchAll: () => (0, exports.createQueryBuilder)({ ...state, query: { match_all: {} } }),
+    match: (field, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return (0, exports.createQueryBuilder)({
+                ...state,
+                query: { match: { [field]: value } }
+            });
+        }
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { match: { [field]: { query: value, ...options } } }
+        });
+    },
+    multiMatch: (fields, query, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return (0, exports.createQueryBuilder)({
+                ...state,
+                query: { multi_match: { fields, query } }
+            });
+        }
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { multi_match: { fields, query, ...options } }
+        });
+    },
+    // Term-level query methods
+    term: (field, value) => (0, exports.createQueryBuilder)({ ...state, query: { term: { [field]: value } } }),
+    matchPhrase: (field, value) => (0, exports.createQueryBuilder)({
+        ...state,
+        query: { match_phrase: { [field]: value } }
+    }),
+    matchPhrasePrefix: (field, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return (0, exports.createQueryBuilder)({
+                ...state,
+                query: { match_phrase_prefix: { [field]: value } }
+            });
+        }
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { match_phrase_prefix: { [field]: { query: value, ...options } } }
+        });
+    },
+    terms: (field, value) => (0, exports.createQueryBuilder)({ ...state, query: { terms: { [field]: value } } }),
+    exists: (field) => (0, exports.createQueryBuilder)({ ...state, query: { exists: { field } } }),
+    prefix: (field, value) => (0, exports.createQueryBuilder)({ ...state, query: { prefix: { [field]: value } } }),
+    wildcard: (field, value) => (0, exports.createQueryBuilder)({
+        ...state,
+        query: { wildcard: { [field]: value } }
+    }),
+    fuzzy: (field, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return (0, exports.createQueryBuilder)({
+                ...state,
+                query: { fuzzy: { [field]: { value } } }
+            });
+        }
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { fuzzy: { [field]: { value, ...options } } }
+        });
+    },
+    ids: (values) => (0, exports.createQueryBuilder)({
+        ...state,
+        query: { ids: { values } }
+    }),
+    // Nested query
+    nested: (path, fn, options) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const nestedQuery = fn(createClauseBuilder());
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: {
+                nested: {
+                    path,
+                    query: nestedQuery,
+                    ...(options && Object.keys(options).length > 0 ? options : {})
+                }
+            }
+        });
+    },
+    // Vector search
+    knn: (field, queryVector, options) => {
+        const { k, num_candidates, filter, boost, similarity } = options;
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            knn: {
+                field: String(field),
+                query_vector: queryVector,
+                k,
+                num_candidates,
+                ...(filter ? { filter } : {}),
+                ...(boost ? { boost } : {}),
+                ...(similarity !== undefined ? { similarity } : {})
+            }
+        });
+    },
+    // Script queries
+    script: (options) => {
+        const { source, lang = 'painless', params, boost } = options;
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: {
+                script: {
+                    script: {
+                        source,
+                        lang,
+                        ...(params ? { params } : {})
+                    },
+                    ...(boost ? { boost } : {})
+                }
+            }
+        });
+    },
+    scriptScore: (queryFn, script, options) => {
+        const innerQuery = queryFn(clauseBuilder);
+        const { source, lang = 'painless', params } = script;
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: {
+                script_score: {
+                    query: innerQuery,
+                    script: {
+                        source,
+                        lang,
+                        ...(params ? { params } : {})
+                    },
+                    ...(options?.min_score !== undefined
+                        ? { min_score: options.min_score }
+                        : {}),
+                    ...(options?.boost ? { boost: options.boost } : {})
+                }
+            }
+        });
+    },
+    percolate: (options) => {
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: {
+                percolate: {
+                    ...options
+                }
+            }
+        });
+    },
+    // Conditional building
+    when: (condition, thenFn, elseFn) => {
+        if (condition) {
+            return thenFn((0, exports.createQueryBuilder)(state));
+        }
+        return elseFn ? elseFn((0, exports.createQueryBuilder)(state)) : undefined;
+    },
+    range: (field, conditions) => (0, exports.createQueryBuilder)({ ...state, query: { range: { [field]: conditions } } }),
+    // Sorting
+    sort: (field, direction = 'asc') => {
+        const existing = state.sort || [];
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            sort: [
+                ...existing,
+                { [field]: direction }
+            ]
+        });
+    },
+    // Pagination and source filtering
+    from: (from) => (0, exports.createQueryBuilder)({ ...state, from }),
+    to: (to) => (0, exports.createQueryBuilder)({ ...state, to }),
+    size: (size) => (0, exports.createQueryBuilder)({ ...state, size }),
+    _source: (_source) => (0, exports.createQueryBuilder)({ ...state, _source }),
+    // Query parameters
+    timeout: (timeout) => (0, exports.createQueryBuilder)({ ...state, timeout }),
+    trackScores: (track_scores) => (0, exports.createQueryBuilder)({ ...state, track_scores }),
+    explain: (explain) => (0, exports.createQueryBuilder)({ ...state, explain }),
+    minScore: (min_score) => (0, exports.createQueryBuilder)({ ...state, min_score }),
+    version: (version) => (0, exports.createQueryBuilder)({ ...state, version }),
+    seqNoPrimaryTerm: (seq_no_primary_term) => (0, exports.createQueryBuilder)({ ...state, seq_no_primary_term }),
+    trackTotalHits: (track_total_hits) => (0, exports.createQueryBuilder)({ ...state, track_total_hits }),
+    highlight: (fields, options) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const highlightFields = {};
+        for (const field of fields) {
+            highlightFields[field] = options || {};
+        }
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            highlight: {
+                fields: highlightFields,
+                ...(options?.pre_tags && { pre_tags: options.pre_tags }),
+                ...(options?.post_tags && { post_tags: options.post_tags })
+            }
+        });
+    },
+    // Geo queries
+    geoDistance: (field, center, options) => (0, exports.createQueryBuilder)({
+        ...state,
+        query: {
+            geo_distance: {
+                [String(field)]: center,
+                ...options
+            }
+        }
+    }),
+    geoBoundingBox: (field, options) => (0, exports.createQueryBuilder)({
+        ...state,
+        query: {
+            geo_bounding_box: {
+                [String(field)]: options
+            }
+        }
+    }),
+    geoPolygon: (field, options) => (0, exports.createQueryBuilder)({
+        ...state,
+        query: {
+            geo_polygon: {
+                [String(field)]: options
+            }
+        }
+    }),
+    // Pattern and scoring queries
+    regexp: (field, value, options) => {
+        if (!options || Object.keys(options).length === 0) {
+            return (0, exports.createQueryBuilder)({
+                ...state,
+                query: { regexp: { [String(field)]: value } }
+            });
+        }
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: { regexp: { [String(field)]: { value, ...options } } }
+        });
+    },
+    constantScore: (fn, options) => {
+        const clause = fn(clauseBuilder);
+        return (0, exports.createQueryBuilder)({
+            ...state,
+            query: {
+                constant_score: {
+                    filter: clause,
+                    ...(options && Object.keys(options).length > 0 ? options : {})
+                }
+            }
+        });
+    },
+    // Aggregations
+    aggs: (fn) => {
+        const aggBuilder = (0, aggregation_builder_1.createAggregationBuilder)();
+        const builtAggs = fn(aggBuilder).build();
+        return (0, exports.createQueryBuilder)({ ...state, aggs: builtAggs });
+    },
+    // Suggestions
+    suggest: (fn) => {
+        const suggesterBuilder = (0, suggester_1.createSuggesterBuilder)();
+        const builtSuggestions = fn(suggesterBuilder).build();
+        return (0, exports.createQueryBuilder)({ ...state, suggest: builtSuggestions.suggest });
+    },
+    // Build final query
+    build: () => {
+        const { _includeQuery, ...rest } = state;
+        if (_includeQuery === false) {
+            const { query: _q, ...noQuery } = rest;
+            return noQuery;
+        }
+        return rest;
+    }
+});
+exports.createQueryBuilder = createQueryBuilder;

package/dist/suggester-types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Type definitions for Elasticsearch Suggesters
+ * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters.html
+ */
+/**
+ * Options for term suggester
+ */
+export type TermSuggesterOptions = {
+    /** The field to fetch candidate suggestions from */
+    field: string;
+    /** Text analyzer to use */
+    analyzer?: string;
+    /** Maximum number of suggestions to return */
+    size?: number;
+    /** Sort order for suggestions */
+    sort?: 'score' | 'frequency';
+    /** Suggest mode */
+    suggest_mode?: 'missing' | 'popular' | 'always';
+    /** String distance algorithm */
+    string_distance?: 'internal' | 'damerau_levenshtein' | 'levenshtein' | 'jaro_winkler' | 'ngram';
+    /** Maximum edit distance */
+    max_edits?: number;
+    /** Maximum number of inspected documents */
+    max_inspections?: number;
+    /** Maximum term frequency threshold */
+    max_term_freq?: number;
+    /** Prefix length */
+    prefix_length?: number;
+    /** Minimum word length */
+    min_word_length?: number;
+    /** Minimum document frequency */
+    min_doc_freq?: number;
+};
+/**
+ * Options for phrase suggester
+ */
+export type PhraseSuggesterOptions = {
+    /** The field to fetch candidate suggestions from */
+    field: string;
+    /** Text analyzer to use */
+    analyzer?: string;
+    /** Maximum number of suggestions to return */
+    size?: number;
+    /** Real word error likelihood */
+    real_word_error_likelihood?: number;
+    /** Confidence threshold */
+    confidence?: number;
+    /** Maximum errors per term */
+    max_errors?: number;
+    /** Separator between terms */
+    separator?: string;
+    /** Gram size for shingle generation */
+    gram_size?: number;
+    /** Direct generators for candidate terms */
+    direct_generator?: Array<{
+        field: string;
+        suggest_mode?: 'missing' | 'popular' | 'always';
+        min_word_length?: number;
+        max_edits?: number;
+        max_inspections?: number;
+        min_doc_freq?: number;
+        max_term_freq?: number;
+        prefix_length?: number;
+        size?: number;
+    }>;
+    /** Highlight pre-tag */
+    pre_tag?: string;
+    /** Highlight post-tag */
+    post_tag?: string;
+    /** Collate query to verify suggestions */
+    collate?: {
+        query: any;
+        params?: Record<string, any>;
+        prune?: boolean;
+    };
+};
+/**
+ * Options for completion suggester
+ */
+export type CompletionSuggesterOptions = {
+    /** The field to fetch completions from (must be type: completion) */
+    field: string;
+    /** Maximum number of suggestions to return */
+    size?: number;
+    /** Skip duplicates */
+    skip_duplicates?: boolean;
+    /** Fuzzy matching options */
+    fuzzy?: {
+        /** Enable fuzzy matching */
+        fuzziness?: string | number;
+        /** Whether transpositions should be treated as one change */
+        transpositions?: boolean;
+        /** Minimum length before fuzzy matching is used */
+        min_length?: number;
+        /** Prefix length */
+        prefix_length?: number;
+        /** Whether all measurements should be in Unicode code points */
+        unicode_aware?: boolean;
+    };
+    /** Context filtering */
+    contexts?: Record<string, string | string[]>;
+};
+/**
+ * Suggester state for build output
+ */
+export type SuggesterState = {
+    [suggesterName: string]: {
+        text?: string;
+        prefix?: string;
+        term?: TermSuggesterOptions;
+        phrase?: PhraseSuggesterOptions;
+        completion?: CompletionSuggesterOptions;
+    };
+};
+/**
+ * Suggester builder interface
+ */
+export type SuggesterBuilder<T> = {
+    /** Term suggester - suggests corrections for individual terms */
+    term: (name: string, text: string, options: TermSuggesterOptions) => SuggesterBuilder<T>;
+    /** Phrase suggester - suggests corrections for entire phrases */
+    phrase: (name: string, text: string, options: PhraseSuggesterOptions) => SuggesterBuilder<T>;
+    /** Completion suggester - autocomplete functionality */
+    completion: (name: string, prefix: string, options: CompletionSuggesterOptions) => SuggesterBuilder<T>;
+    /** Build suggester DSL */
+    build: () => {
+        suggest: SuggesterState;
+    };
+};
+//# sourceMappingURL=suggester-types.d.ts.map

package/dist/suggester-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggester-types.d.ts","sourceRoot":"","sources":["../src/suggester-types.ts"],"names":[],"mappings":"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"}

package/dist/suggester-types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for Elasticsearch Suggesters
+ * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters.html
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/suggester.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Suggester builder
+ * Provides query suggestions, phrase corrections, and autocomplete functionality
+ */
+import { SuggesterBuilder, SuggesterState } from './suggester-types';
+/**
+ * Creates a suggester builder
+ * @returns SuggesterBuilder instance
+ */
+export declare const createSuggesterBuilder: <T>(state?: SuggesterState) => SuggesterBuilder<T>;
+/**
+ * Factory function to create a new suggester builder
+ * @example
+ * ```typescript
+ * const suggestions = suggest<Product>()
+ *   .term('name-suggestions', 'laptop', { field: 'name', size: 5 })
+ *   .build();
+ * ```
+ */
+export declare const suggest: <T>() => SuggesterBuilder<T>;
+//# sourceMappingURL=suggester.d.ts.map

package/dist/suggester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggester.d.ts","sourceRoot":"","sources":["../src/suggester.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAErE;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,EACtC,QAAO,cAAmB,KACzB,gBAAgB,CAAC,CAAC,CAkCnB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,0BAAkC,CAAC"}

package/dist/suggester.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Suggester builder
+ * Provides query suggestions, phrase corrections, and autocomplete functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggest = exports.createSuggesterBuilder = void 0;
+/**
+ * Creates a suggester builder
+ * @returns SuggesterBuilder instance
+ */
+const createSuggesterBuilder = (state = {}) => ({
+    term: (name, text, options) => {
+        return (0, exports.createSuggesterBuilder)({
+            ...state,
+            [name]: {
+                text,
+                term: options
+            }
+        });
+    },
+    phrase: (name, text, options) => {
+        return (0, exports.createSuggesterBuilder)({
+            ...state,
+            [name]: {
+                text,
+                phrase: options
+            }
+        });
+    },
+    completion: (name, prefix, options) => {
+        return (0, exports.createSuggesterBuilder)({
+            ...state,
+            [name]: {
+                prefix,
+                completion: options
+            }
+        });
+    },
+    build: () => ({
+        suggest: state
+    })
+});
+exports.createSuggesterBuilder = createSuggesterBuilder;
+/**
+ * Factory function to create a new suggester builder
+ * @example
+ * ```typescript
+ * const suggestions = suggest<Product>()
+ *   .term('name-suggestions', 'laptop', { field: 'name', size: 5 })
+ *   .build();
+ * ```
+ */
+const suggest = () => (0, exports.createSuggesterBuilder)();
+exports.suggest = suggest;