opensearch-ts 1.2.2

package/dist/filters.d.ts

@@ -0,0 +1,174 @@
+import { BooleanAtt } from ".";
+import { NumberAtt, DateAtt, KeyWord, StringAtt, AnyAttribute, TextOrKeywordAtt } from "./attributes";
+import * as att from "./attributes";
+import { BooleanStatement } from "./search";
+import type { RequireExactlyOne } from 'type-fest';
+export type RangeDefaults<A> = {
+    gte?: A;
+    lte?: A;
+    gt?: A;
+    lt?: A;
+};
+export type Range<T, B extends string, R extends RangeDefaults<T>> = RequireExactlyOne<{
+    [key in B]: R;
+}>;
+export type NumberRange<T> = Range<number, NumberAtt<T>, RangeDefaults<number>>;
+export type DateRangeStatement = {
+    gte?: Date | string;
+    lte?: Date | string;
+    gt?: Date | string;
+    lt?: Date | string;
+    time_zone?: string;
+    format?: string;
+    execution?: string;
+};
+export type DateRange<T> = RequireExactlyOne<{
+    [key in DateAtt<T>]: DateRangeStatement;
+}>;
+export type RangeStatement<T> = {
+    "range": NumberRange<T> | DateRange<T>;
+};
+export type ExistsStatement<T> = {
+    "exists": {
+        "field": AnyAttribute<T>;
+    };
+};
+export type PrefixStatement<T> = {
+    "prefix": RequireExactlyOne<{
+        [key in TextOrKeywordAtt<T>]: {
+            value: string;
+            boost?: number;
+        };
+    }>;
+};
+export type WildCardStatement<T> = {
+    "wildcard": RequireExactlyOne<{
+        [key in TextOrKeywordAtt<T>]: {
+            value: string;
+            boost?: number;
+        };
+    }>;
+};
+export type RegexpStatement<T> = {
+    "regexp": RequireExactlyOne<{
+        [key in TextOrKeywordAtt<T>]: {
+            value: string;
+            flags?: number;
+            max_determinized_states?: number;
+        };
+    }>;
+};
+export type GeoBoundingBox = {
+    geo_bounding_box: {
+        point: {
+            top_left: {
+                lat: number;
+                lon: number;
+            };
+            bottom_right: {
+                lat: number;
+                lon: number;
+            };
+        };
+    };
+};
+export type XYShape<T> = {
+    xy_shape: {
+        geometry: {
+            shape: {
+                type: "envelope";
+                coordinates: [number, number][];
+            };
+            relation: "INTERSECTS" | "DISJOINT" | "WITHIN" | "CONTAINS";
+        };
+    };
+};
+export type FuzzyStatement<T> = {
+    fuzzy: RequireExactlyOne<{
+        [a in att.StringAtt<T>]: {
+            value: string;
+            boost?: number;
+            fuzziness?: number;
+            max_expansions?: number;
+            prefix_length?: number;
+            rewrite?: string;
+            transpositions: boolean;
+        };
+    }>;
+};
+export type Match<A extends string, V> = {
+    "match": {
+        [k in keyof RequireExactlyOne<{
+            [key in A]: V;
+        }>]: {
+            query: string;
+            auto_generate_synonyms_phrase_query?: boolean;
+            analyzer?: string;
+            boost?: number;
+            enable_position_increments?: boolean;
+            fuzziness?: string;
+            fuzzy_rewrite?: string;
+            fuzzy_transpositions?: boolean;
+            lenient?: boolean;
+            max_expansions?: number;
+            minimum_should_match?: number;
+            operator?: string;
+            prefix_length?: number;
+            zero_terms_query?: string;
+        } | string;
+    };
+};
+export type MatchKeyword<T> = Match<KeyWord<T>, string>;
+export type MatchString<T> = Match<StringAtt<T>, string>;
+export type MatchStatement<T> = MatchKeyword<T> | MatchString<T>;
+export type Term<A extends string, V> = {
+    "term": RequireExactlyOne<{
+        [key in A]: V;
+    }>;
+};
+export type TermKeyword<T> = Term<KeyWord<T>, string>;
+export type TermString<T> = Term<StringAtt<T>, string>;
+export type TermNumber<T> = Term<NumberAtt<T>, number>;
+export type TermBoolean<T> = Term<BooleanAtt<T>, boolean>;
+export type TermDate<T> = Term<DateAtt<T>, Date>;
+export type TermStatement<T> = TermKeyword<T> | TermString<T> | TermDate<T> | TermNumber<T> | TermBoolean<T>;
+export type Terms<A extends string, V> = {
+    "terms": RequireExactlyOne<{
+        [key in A]: V[];
+    }>;
+};
+export type TermsKeyword<T> = Terms<KeyWord<T>, string>;
+export type TermsString<T> = Terms<StringAtt<T>, string>;
+export type TermsNumber<T> = Terms<NumberAtt<T>, number>;
+export type TermsDate<T> = Terms<DateAtt<T>, Date>;
+export type TermsBoolean<T> = Terms<BooleanAtt<T>, boolean>;
+export type MoreLikeThisStatement<T> = {
+    /** Specify the fields to compare */
+    "fields"?: TermsString<T>[];
+    "like"?: string;
+    /** Minimum term frequency in the source document */
+    "min_term_freq"?: number;
+    /** Maximum number of query terms to use */
+    "max_query_terms"?: number;
+    /** Minimum number of documents in which a term should appear to be considered. */
+    min_doc_freq: number;
+    /** Maximum number of documents in which a term may appear. */
+    max_doc_freq: number;
+    /** Minimum word length below which terms will be ignored. */
+    min_word_length: number;
+    /** Maximum word length above which terms will be ignored. */
+    max_word_length: number;
+};
+export type MoreLikeThis<T> = {
+    "more_like_this": MoreLikeThisStatement<T>;
+};
+export type TermsStatement<T> = TermsKeyword<T> | TermsString<T> | TermsNumber<T> | TermsDate<T> | TermsBoolean<T>;
+export type FilterStatement<T> = WildCardStatement<T> | RegexpStatement<T> | PrefixStatement<T> | ExistsStatement<T> | RangeStatement<T> | TermStatement<T> | TermsStatement<T> | MatchStatement<T> | BoolStatement<T> | AndStatement<T> | GeoBoundingBox | XYShape<T> | FuzzyStatement<T> | MoreLikeThis<T>;
+export type BoolStatement<T> = {
+    bool: BooleanStatement<T>;
+};
+export type AndStatement<T> = {
+    and: {
+        filters: FilterStatement<T>;
+    };
+};

package/dist/filters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./typescriptOS";
+export * from "./search";
+export * from "./aggInput";
+export * from "./attributes";
+export * from "./attributes";
+export * from "./filters";
+export * as query from "./query";

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = void 0;
+__exportStar(require("./typescriptOS"), exports);
+__exportStar(require("./search"), exports);
+__exportStar(require("./aggInput"), exports);
+__exportStar(require("./attributes"), exports);
+__exportStar(require("./attributes"), exports);
+__exportStar(require("./filters"), exports);
+exports.query = require("./query");

package/dist/logger.d.ts

@@ -0,0 +1 @@
+export declare function info(m: any): void;

package/dist/logger.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = void 0;
+function info(m) {
+    console.log(JSON.stringify(m, null, 2));
+}
+exports.info = info;

package/dist/match.d.ts

@@ -0,0 +1,27 @@
+import { RequireExactlyOne } from "type-fest";
+import * as att from "./attributes";
+export type MatchRaw<T> = RequireExactlyOne<{
+    [key in att.AnyAttribute<T>]: string;
+}>;
+export type MatchQuery<T> = RequireExactlyOne<{
+    [key in att.AnyAttribute<T>]: {
+        query: string;
+        operator: string;
+        minimum_should_match?: number;
+        analyzer?: string;
+        zero_terms_query?: string;
+        fuzziness?: string;
+        prefix_length?: string;
+        fuzzy_transpositions?: boolean;
+        auto_generate_synonyms_phrase_query?: boolean;
+        boost?: number;
+        enable_position_increments?: boolean;
+        fuzzy_rewrite?: string;
+        lenient?: boolean;
+        max_expansions?: number;
+    };
+}>;
+export type Match<T> = MatchRaw<T> | MatchQuery<T>;
+export type MatchPhrase<T> = RequireExactlyOne<{
+    [key in att.TextOrKeywordAtt<T>]: string;
+}>;

package/dist/match.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/query.d.ts

@@ -0,0 +1,6 @@
+import { FilterStatement } from "./filters";
+export declare function negate<T>(filter: FilterStatement<T>): FilterStatement<T>;
+export declare function atLeast<T>(filters: FilterStatement<T>[], minShouldMatch: number): FilterStatement<T>;
+export declare const any: <T>(filters: FilterStatement<T>[]) => FilterStatement<T>;
+export declare const all: <T>(filters: FilterStatement<T>[]) => FilterStatement<T>;
+export declare const none: <T>(filters: FilterStatement<T>[]) => FilterStatement<T>;

package/dist/query.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.none = exports.all = exports.any = exports.atLeast = exports.negate = void 0;
+function negate(filter) {
+    return {
+        "bool": {
+            "must_not": [
+                filter
+            ]
+        }
+    };
+}
+exports.negate = negate;
+function atLeast(filters, minShouldMatch) {
+    const anyMatch = {
+        "bool": {
+            "should": filters,
+            "minimum_should_match": minShouldMatch
+        }
+    };
+    return anyMatch;
+}
+exports.atLeast = atLeast;
+const any = (filters) => atLeast(filters, 1);
+exports.any = any;
+const all = (filters) => ({
+    "bool": {
+        "filter": filters
+    }
+});
+exports.all = all;
+const none = (filters) => ({
+    "bool": {
+        "must_not": filters
+    }
+});
+exports.none = none;

package/dist/query.test.d.ts

@@ -0,0 +1,3 @@
+import { ServerLog } from "./tests/ServerLog";
+import * as q from "./search";
+export declare const queries: q.Search<ServerLog, {}>[];

package/dist/query.test.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queries = void 0;
+const typescriptOS_1 = require("./typescriptOS");
+const search_1 = require("./search");
+const testUtil_1 = require("./testUtil");
+const INDEX_LOGS = "opensearch_dashboards_sample_data_logs";
+var esClient;
+var tsClient;
+jest.setTimeout(20000);
+beforeAll(async () => {
+    esClient = await (0, testUtil_1.makeClientWithEndpoint)();
+    tsClient = new typescriptOS_1.TypescriptOSProxyClient(esClient);
+});
+const countAll = {
+    "query": {
+        "match_all": {}
+    },
+    "aggs": {
+        "total": {
+            "value_count": {
+                "field": "_id"
+            }
+        }
+    },
+    "size": 0
+};
+const exampleTopHitMax = {
+    "size": 0,
+    "aggs": {
+        "agents": {
+            "terms": {
+                "field": "agent.keyword",
+            },
+            "aggs": {
+                "maxValue": {
+                    "max": {
+                        "field": "@timestamp"
+                    }
+                },
+                "maxHits": {
+                    "top_hits": {
+                        "size": 1,
+                        "sort": [
+                            {
+                                "@timestamp": {
+                                    "order": "desc"
+                                }
+                            }
+                        ]
+                    }
+                },
+                "minValue": {
+                    "min": {
+                        "field": "@timestamp"
+                    }
+                },
+                "minHits": {
+                    "top_hits": {
+                        "size": 1,
+                        "sort": [
+                            {
+                                "@timestamp": {
+                                    "order": "asc"
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    },
+    query: {
+        "match_all": {}
+    }
+};
+const searchMatchAll = {
+    query: {
+        "match_all": {}
+    }
+};
+const searchExample = {
+    index: INDEX_LOGS,
+    _source: {
+        includes: [
+            "bytes",
+            "utc_time"
+        ]
+    },
+    query: {
+        bool: {
+            must: [
+                {
+                    "terms": {
+                        "agent.keyword": [
+                            "Mozilla/5.0 (X11; Linux x86_64; rv:6.0a1) Gecko/20110421 Firefox/6.0a1",
+                            "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)",
+                        ]
+                    }
+                },
+                {
+                    "range": {
+                        "@timestamp": {
+                            "lte": "2025-01-25T03:41:11.215Z",
+                            "gte": new Date("2005-01-25T03:41:11.215Z")
+                        }
+                    }
+                }
+            ],
+            "minimum_should_match": 2,
+            "should": [
+                {
+                    "term": {
+                        "tags.keyword": "login"
+                    }
+                },
+                {
+                    "term": {
+                        "tags.keyword": "success"
+                    }
+                }
+            ]
+        }
+    },
+    aggs: {
+        "exampleDateHist": {
+            "date_histogram": {
+                "interval": "3d",
+                "field": "timestamp"
+            },
+            "aggs": {
+                "agentTerms": {
+                    "terms": {
+                        "field": "agent.keyword",
+                    }
+                }
+            }
+        },
+        "adjacency": {
+            "adjacency_matrix": {
+                "filters": {
+                    "linux": {
+                        "match": {
+                            "agent.keyword": "Mozilla/5.0 (X11; Linux x86_64; rv:6.0a1) Gecko/20110421 Firefox/6.0a1",
+                        }
+                    },
+                    "windows": {
+                        "match": {
+                            "agent.keyword": "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)",
+                        }
+                    }
+                }
+            }
+        },
+        "test": {
+            "terms": {
+                "field": "agent.keyword"
+            },
+            "aggs": {
+                "innerTest": {
+                    "extended_stats": {
+                        "field": "bytes"
+                    }
+                },
+                "somethingMore": {
+                    "terms": {
+                        "field": "referer.keyword"
+                    },
+                    "aggs": {
+                        "maxValue": {
+                            "max": {
+                                "field": "@timestamp"
+                            }
+                        },
+                        "maxHits": {
+                            "top_hits": {
+                                "size": 2,
+                                "sort": [
+                                    {
+                                        "@timestamp": {
+                                            "order": "desc"
+                                        }
+                                    }
+                                ]
+                            }
+                        },
+                        "minValue": {
+                            "min": {
+                                "field": "@timestamp"
+                            }
+                        },
+                        "minHits": {
+                            "top_hits": {
+                                "size": 1,
+                                "sort": [
+                                    {
+                                        "@timestamp": {
+                                            "order": "asc"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "size": 10
+};
+exports.queries = [
+    {},
+    searchExample,
+    {},
+    searchMatchAll,
+];
+test("normal count", async () => {
+    const response = await tsClient.countTs({ body: {}, index: INDEX_LOGS });
+    response.count;
+    response._shards.total;
+    response._shards.failed;
+    response._shards.skipped;
+    response._shards.successful;
+    console.log(JSON.stringify(response, null, 2));
+});
+test("agg count all documents", async () => {
+    const response = await tsClient.searchTS({ body: countAll, index: INDEX_LOGS });
+    console.log(response.aggregations.total.value);
+    console.log(JSON.stringify(response, null, 2));
+});
+test("msearchTS", async () => {
+    const response = await tsClient.msearchTS([
+        searchExample,
+        searchMatchAll,
+    ], INDEX_LOGS);
+    const searchExampleResponse = new search_1.ResponseParser(searchExample).parseSearchResponse(response[0]);
+    console.log(JSON.stringify(searchExampleResponse.aggregations.adjacency.buckets, null, 2));
+    // console.log(JSON.stringify(response, null, 2))
+});
+const msearch = {
+    "searchExample": searchExample,
+    "searchMatchAll": searchMatchAll
+};
+test("testRawTypes", async () => {
+    await tsClient.msearchDictTS(msearch);
+    // console.log(JSON.stringify(msearch.searchExample.response.aggregations.test.buckets, null, 2))
+    console.log(JSON.stringify(msearch, null, 2));
+    console.log(JSON.stringify(msearch.searchExample.response.aggregations.test.buckets
+        .flatMap(b => b.innerTest), null, 2));
+});
+test("searchTS222", async () => {
+    const response = await tsClient.searchTS({ body: searchExample, index: INDEX_LOGS });
+    console.log(searchExample.response.aggregations.exampleDateHist.buckets.flatMap(b => b.agentTerms.buckets
+        .flatMap(t => ({
+        "t.key": t.key,
+        "t.doc_count": t.doc_count,
+        "b.key_as_string": b.key_as_string,
+        // "b.key_as_string" : b.key_as_string,
+    }))));
+    // console.log("OPENSEARCH")
+    // console.log(JSON.stringify(searchExample.response.aggregations.test.buckets.map(b => b.doc_count), null, 2))
+    // console.log(JSON.stringify(searchExample.response.aggregations.exampleDateHist
+    //         .buckets.flatMap(b => b.agentTerms
+    //         .buckets.flatMap(a => ({doc_count : a.doc_count, key : `${b.key}.${a.key}`}))), null, 2))
+});
+test("exampleTopHitMax", async () => {
+    const response = await tsClient.searchTS({ body: exampleTopHitMax, index: INDEX_LOGS });
+    console.log(JSON.stringify(response.aggregations.agents.buckets.flatMap(agent => ({
+        minFromMin: agent.minValue.value_as_string,
+        minFromDoc: agent.minHits.hits.hits[0]._source.timestamp,
+        minDoc: agent.minHits.hits.hits[0],
+        maxFromMin: agent.maxValue.value_as_string,
+        maxFromDoc: agent.maxHits.hits.hits[0]._source.timestamp,
+        maxDoc: agent.maxHits.hits.hits[0],
+    })), null, 2));
+});
+test("single example match and filter", async () => {
+    const matchAndFilter = {
+        query: {
+            "bool": {
+                "must": {
+                    "match": {
+                        "agent": {
+                            "query": "Chrome"
+                        }
+                    }
+                }
+            }
+        },
+        size: 5
+    };
+    const response = await tsClient.searchTS({ body: matchAndFilter, index: INDEX_LOGS });
+    console.log(JSON.stringify(response, null, 2));
+});
+test("Filter by IDs example", async () => {
+    const matchAndFilter = {
+        "query": {
+            "terms": {
+                "_id": ["hello", "abcd-1234"]
+            }
+        }
+    };
+    const response = await tsClient.searchTS({ body: matchAndFilter, index: INDEX_LOGS });
+    console.log(JSON.stringify(response, null, 2));
+});
+test("Filter by ID example", async () => {
+    const matchAndFilter = {
+        "query": {
+            "term": {
+                "_id": "2345"
+            }
+        }
+    };
+    const response = await tsClient.searchTS({ body: matchAndFilter, index: INDEX_LOGS });
+    console.log(JSON.stringify(response, null, 2));
+});
+test("multi example match and filter", async () => {
+    const matchAndFilter = {
+        query: {
+            "bool": {
+                "must": {
+                    "match": {
+                        "agent": {
+                            "query": "Chrome"
+                        }
+                    }
+                },
+                "filter": {
+                    "term": {
+                        "extension.keyword": "zip"
+                    }
+                }
+            }
+        },
+        size: 5
+    };
+    const response = await tsClient.searchTS({ body: matchAndFilter, index: INDEX_LOGS });
+    console.log(JSON.stringify(response, null, 2));
+});
+test("multi example match and filter", async () => {
+    const matchAndFilter = {
+        query: {
+            "bool": {
+                "must": {
+                    "match": {
+                        "agent": "Chrome"
+                    }
+                },
+                "filter": {
+                    "term": {
+                        "extension.keyword": "zip"
+                    }
+                }
+            }
+        },
+        size: 5
+    };
+    const response = await tsClient.searchTS({ body: matchAndFilter, index: INDEX_LOGS });
+    console.log(JSON.stringify(response, null, 2));
+});