@oneuptime/common 12.0.24 → 12.0.26

package/build/dist/Types/Telemetry/LlmMetricConventions.js.map

@@ -1 +1 @@
-{"version":3,"file":"LlmMetricConventions.js","sourceRoot":"","sources":["../../../../Types/Telemetry/LlmMetricConventions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAkB;IACrD,2BAA2B;IAC3B,2BAA2B;IAC3B,iBAAiB;IACjB,kBAAkB;CACnB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAkB;IAC/C,oBAAoB;IACpB,wBAAwB;IACxB,mBAAmB;IACnB,iBAAiB;IACjB,sBAAsB;IACtB,oBAAoB;CACrB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAkB;IACtD,mBAAmB;IACnB,gBAAgB;CACjB,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;AAE1E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAkB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;AAahF,MAAM,UAAU,oBAAoB,CAClC,cAAyC;IAEzC,IAAI,OAAO,cAAc,KAAK,QAAQ,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,UAAU,GAAW,cAAc,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAE/D,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,uBAAuB,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QACjD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,IAAI,wBAAwB,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QAClD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAA4B;IAE5B,OAAO,SAAS,KAAK,OAAO;QAC1B,CAAC,CAAC,uBAAuB;QACzB,CAAC,CAAC,wBAAwB,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"LlmMetricConventions.js","sourceRoot":"","sources":["../../../../Types/Telemetry/LlmMetricConventions.ts"],"names":[],"mappings":"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"}

package/build/dist/Types/Telemetry/SourceMap.js

@@ -0,0 +1,9 @@
+/**
+ * Shared types for source map resolution of exception stack traces.
+ *
+ * These live in Common/Types (not Common/Server) because the Dashboard UI
+ * consumes the resolved frames returned by the resolve-stack-trace API and
+ * must not import server-side modules.
+ */
+export {};
+//# sourceMappingURL=SourceMap.js.map

package/build/dist/Types/Telemetry/SourceMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceMap.js","sourceRoot":"","sources":["../../../../Types/Telemetry/SourceMap.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/build/dist/Types/Telemetry/TelemetrySearchQuery.js

@@ -0,0 +1,661 @@
+import EndsWith from "../BaseDatabase/EndsWith";
+import GreaterThan from "../BaseDatabase/GreaterThan";
+import GreaterThanOrEqual from "../BaseDatabase/GreaterThanOrEqual";
+import Includes from "../BaseDatabase/Includes";
+import IncludesNone from "../BaseDatabase/IncludesNone";
+import IsNull from "../BaseDatabase/IsNull";
+import LessThan from "../BaseDatabase/LessThan";
+import LessThanOrEqual from "../BaseDatabase/LessThanOrEqual";
+import NotContains from "../BaseDatabase/NotContains";
+import NotEqual from "../BaseDatabase/NotEqual";
+import NotNull from "../BaseDatabase/NotNull";
+import NotWildcard from "../BaseDatabase/NotWildcard";
+import Search from "../BaseDatabase/Search";
+import StartsWith from "../BaseDatabase/StartsWith";
+import Wildcard from "../BaseDatabase/Wildcard";
+import { escapeWildcards, hasWildcard, unescapeWildcards, } from "../BaseDatabase/WildcardPattern";
+/*
+ * The OneUptime telemetry search language — one grammar for logs, traces,
+ * metrics, exceptions and every other signal with an attributes map.
+ *
+ * Before this module each explorer carried its own tokenizer and its own idea
+ * of what a value meant: logs stripped `*` and searched for a substring,
+ * traces needed a bespoke `~` marker for "contains" and read `*` literally,
+ * metrics and exceptions supported nothing but equality. The same keystrokes
+ * produced three different queries, and `@platform.team:a*` — the shape every
+ * search UI in the industry teaches — matched nothing anywhere.
+ *
+ *   free text            connection refused     message contains the phrase
+ *   "quoted phrase"      "out of memory"        keeps spaces together
+ *   field:value          severity:error         a top-level column
+ *   @attribute:value     @http.status_code:500  an attributes map entry
+ *   -<filter>            -severity:debug        negate any filter
+ *
+ * and, as the value of either a field or an attribute:
+ *
+ *   abc                  exact match (case-sensitive, like the stored value)
+ *   a*   *a   a*b        glob — `*` is any run of characters
+ *   a?c                  glob — `?` is exactly one character
+ *   \*                   a literal asterisk (also \? and \\)
+ *   *                    the key exists with a non-empty value
+ *   ~abc                 contains
+ *   !abc                 not equal
+ *   >10  >=10  <10  <=10 numeric comparison
+ *   (a OR b)   [a, b]    any of these
+ *   "a b*"               quotes protect spaces, NOT wildcards
+ *
+ * Negation composes with all of them: `-@k:a*` is "does not match a*",
+ * `-@k:>10` is "<= 10", `-@k:(a OR b)` is "none of these", `-@k:*` is "the
+ * key is absent or empty".
+ */
+export var SearchTokenType;
+(function (SearchTokenType) {
+    SearchTokenType["FreeText"] = "FreeText";
+    SearchTokenType["Field"] = "Field";
+    SearchTokenType["Attribute"] = "Attribute";
+})(SearchTokenType || (SearchTokenType = {}));
+export var SearchValueOperator;
+(function (SearchValueOperator) {
+    SearchValueOperator["Equals"] = "Equals";
+    SearchValueOperator["NotEquals"] = "NotEquals";
+    SearchValueOperator["Contains"] = "Contains";
+    SearchValueOperator["NotContains"] = "NotContains";
+    SearchValueOperator["StartsWith"] = "StartsWith";
+    SearchValueOperator["EndsWith"] = "EndsWith";
+    SearchValueOperator["Wildcard"] = "Wildcard";
+    SearchValueOperator["NotWildcard"] = "NotWildcard";
+    SearchValueOperator["GreaterThan"] = "GreaterThan";
+    SearchValueOperator["GreaterThanOrEqual"] = "GreaterThanOrEqual";
+    SearchValueOperator["LessThan"] = "LessThan";
+    SearchValueOperator["LessThanOrEqual"] = "LessThanOrEqual";
+    SearchValueOperator["In"] = "In";
+    SearchValueOperator["NotIn"] = "NotIn";
+    SearchValueOperator["Exists"] = "Exists";
+    SearchValueOperator["NotExists"] = "NotExists";
+})(SearchValueOperator || (SearchValueOperator = {}));
+const BOOLEAN_KEYWORDS = new Set(["AND", "OR", "NOT"]);
+const LIST_SEPARATOR_REGEX = /\s+OR\s+|,/i;
+const NUMERIC_REGEX = /^-?\d+(\.\d+)?$/;
+const WHITESPACE_REGEX = /\s/;
+/*
+ * A quote is escaped wherever it appears: the tokenizer toggles on any of
+ * them, so an unescaped one mid-value would swallow the following space and
+ * silently merge two tokens.
+ */
+const QUOTE_REGEX = /(")/g;
+/*
+ * `~ ! > <` are operators ONLY as the first character of a value, and a
+ * bracket pair only when it wraps the whole value. Escaping them everywhere
+ * would be safe but noisy — a service name like `svc~canary` would round-trip
+ * through a shared URL as `svc\~canary`, which is what the reader sees.
+ */
+const LEADING_OPERATOR_REGEX = /^([-~!<>])/;
+const WRAPPED_LIST_REGEX = /^(\()(.*)(\))$|^(\[)(.*)(\])$/;
+/*
+ * What a bare (unprefixed) key has to look like before `key:value` is read as
+ * a filter rather than as prose. Without it every colon in a message became a
+ * filter on an invented field that matched nothing: `12:30` filtered a field
+ * called "12", and `https://example.com` one called "https". An explicit
+ * `@key:` bypasses this — the user has said what they mean.
+ */
+const BARE_FIELD_KEY_REGEX = /^[A-Za-z_][A-Za-z0-9._\-/]*$/;
+/** A `//` after the colon is a URL scheme, never a filter value. */
+const URL_SCHEME_VALUE_REGEX = /^\/\//;
+/** Remove one layer of surrounding double quotes, if present. */
+export const stripQuotes = (value) => {
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    return value;
+};
+/**
+ * Split a search string into raw tokens.
+ *
+ * A character scanner rather than a regex, because the three things that have
+ * to survive splitting all nest: double quotes (`name:"SELECT wp_options"`),
+ * bracketed value lists (`@k:(a OR b)`), and backslash escapes (`@k:a\ b`).
+ * The regex tokenizers this replaces each handled one of the three and
+ * silently mangled the others.
+ */
+export const tokenizeSearchQuery = (raw, options) => {
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let depth = 0;
+    /*
+     * True when `current` is a field prefix still waiting for its value —
+     * `severity:` or `@http.method:`. Only then does a space get absorbed
+     * instead of ending the token, which is what makes `name: POST` and
+     * `@k: "a b"` work without turning every colon in prose into a filter.
+     */
+    const isAwaitingValue = () => {
+        var _a;
+        if (!current.endsWith(":")) {
+            return false;
+        }
+        const prefix = current.slice(0, -1).replace(/^-/, "");
+        if (prefix.startsWith("@")) {
+            return prefix.length > 1;
+        }
+        return Boolean((_a = options === null || options === void 0 ? void 0 : options.knownFieldKeys) === null || _a === void 0 ? void 0 : _a.has(prefix.toLowerCase()));
+    };
+    for (let index = 0; index < raw.length; index++) {
+        const character = raw[index];
+        if (character === "\\") {
+            // Escapes are preserved verbatim; the value grammar resolves them.
+            current += character;
+            if (index + 1 < raw.length) {
+                current += raw[index + 1];
+                index++;
+            }
+            continue;
+        }
+        if (character === '"') {
+            inQuotes = !inQuotes;
+            current += character;
+            continue;
+        }
+        if (!inQuotes && (character === "(" || character === "[")) {
+            depth++;
+            current += character;
+            continue;
+        }
+        if (!inQuotes && (character === ")" || character === "]")) {
+            depth = Math.max(0, depth - 1);
+            current += character;
+            continue;
+        }
+        if (character === " " && !inQuotes && depth === 0) {
+            if (isAwaitingValue()) {
+                // Absorb the space: the next word is this field's value.
+                continue;
+            }
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += character;
+    }
+    if (current.length > 0) {
+        tokens.push(current);
+    }
+    return tokens;
+};
+/*
+ * Every operator has an exact opposite, so `-` composes with all of them
+ * instead of being silently dropped on the ones the old log parser could not
+ * express (its `-@k:a*` produced a POSITIVE contains — the complement of what
+ * was asked for).
+ */
+const negateOperator = (operator) => {
+    switch (operator) {
+        case SearchValueOperator.Equals:
+            return SearchValueOperator.NotEquals;
+        case SearchValueOperator.NotEquals:
+            return SearchValueOperator.Equals;
+        case SearchValueOperator.Contains:
+            return SearchValueOperator.NotContains;
+        case SearchValueOperator.NotContains:
+            return SearchValueOperator.Contains;
+        case SearchValueOperator.Wildcard:
+            return SearchValueOperator.NotWildcard;
+        case SearchValueOperator.NotWildcard:
+            return SearchValueOperator.Wildcard;
+        case SearchValueOperator.In:
+            return SearchValueOperator.NotIn;
+        case SearchValueOperator.NotIn:
+            return SearchValueOperator.In;
+        case SearchValueOperator.Exists:
+            return SearchValueOperator.NotExists;
+        case SearchValueOperator.NotExists:
+            return SearchValueOperator.Exists;
+        case SearchValueOperator.GreaterThan:
+            return SearchValueOperator.LessThanOrEqual;
+        case SearchValueOperator.GreaterThanOrEqual:
+            return SearchValueOperator.LessThan;
+        case SearchValueOperator.LessThan:
+            return SearchValueOperator.GreaterThanOrEqual;
+        case SearchValueOperator.LessThanOrEqual:
+            return SearchValueOperator.GreaterThan;
+        case SearchValueOperator.StartsWith:
+        case SearchValueOperator.EndsWith:
+        default:
+            /*
+             * StartsWith / EndsWith are never produced by the parser (a glob covers
+             * both); they exist so a caller can hand-build a predicate. Negating one
+             * is expressed as the equivalent negated glob by the caller.
+             */
+            return operator;
+    }
+};
+/*
+ * Split `(a OR b)` / `[a, b]` into its entries, quotes stripped but ESCAPES
+ * INTACT — whether an entry is a glob is decided per entry afterwards, so
+ * `(a* OR bravo)` keeps the star that makes the first entry a pattern.
+ */
+const splitList = (inner) => {
+    return inner
+        .split(LIST_SEPARATOR_REGEX)
+        .map((entry) => {
+        return stripQuotes(entry.trim());
+    })
+        .filter((entry) => {
+        return entry.length > 0;
+    });
+};
+/**
+ * Parse the value half of a `key:value` token into a predicate.
+ *
+ * This is the single definition of what a typed value means, shared by the
+ * search bar, the facet chips and every viewer, so a value cannot mean
+ * "contains" in one place and "equals" in another.
+ */
+export const parseSearchValue = (rawValue, negated) => {
+    const build = (operator, value, values) => {
+        return {
+            operator: negated ? negateOperator(operator) : operator,
+            value,
+            values: values || [],
+        };
+    };
+    const trimmed = rawValue.trim();
+    // `@k:*` — the key exists with a non-empty value.
+    if (trimmed === "*") {
+        return build(SearchValueOperator.Exists, "");
+    }
+    if (trimmed.startsWith("~")) {
+        return build(SearchValueOperator.Contains, unescapeWildcards(stripQuotes(trimmed.slice(1))));
+    }
+    if (trimmed.startsWith("!")) {
+        return build(SearchValueOperator.NotEquals, unescapeWildcards(stripQuotes(trimmed.slice(1))));
+    }
+    if (trimmed.startsWith(">=")) {
+        return build(SearchValueOperator.GreaterThanOrEqual, stripQuotes(trimmed.slice(2)));
+    }
+    if (trimmed.startsWith("<=")) {
+        return build(SearchValueOperator.LessThanOrEqual, stripQuotes(trimmed.slice(2)));
+    }
+    if (trimmed.startsWith(">")) {
+        return build(SearchValueOperator.GreaterThan, stripQuotes(trimmed.slice(1)));
+    }
+    if (trimmed.startsWith("<")) {
+        return build(SearchValueOperator.LessThan, stripQuotes(trimmed.slice(1)));
+    }
+    const isBracketedList = (trimmed.startsWith("(") && trimmed.endsWith(")")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"));
+    if (isBracketedList && trimmed.length >= 2) {
+        const entries = splitList(trimmed.slice(1, -1));
+        /*
+         * An empty list constrains nothing. Falling through to equality on the
+         * literal "()" would match no row at all, which reads to the user as
+         * "your filter is broken" rather than "you typed nothing".
+         */
+        if (entries.length === 0) {
+            return build(SearchValueOperator.Contains, "");
+        }
+        /*
+         * A list of plain literals compiles to `IN (...)`, which the database can
+         * satisfy with a hash lookup. Only a list that actually carries a glob
+         * pays for the OR-of-ILIKEs form.
+         */
+        const anyGlob = entries.some((entry) => {
+            return hasWildcard(entry);
+        });
+        if (anyGlob) {
+            return build(SearchValueOperator.Wildcard, entries[0], entries);
+        }
+        const literals = entries.map((entry) => {
+            return unescapeWildcards(entry);
+        });
+        if (literals.length === 1) {
+            return build(SearchValueOperator.Equals, literals[0]);
+        }
+        return build(SearchValueOperator.In, literals[0], literals);
+    }
+    const unquoted = stripQuotes(trimmed);
+    if (hasWildcard(unquoted)) {
+        // Keep the escapes: the glob is compiled, and re-rendered, from this.
+        return build(SearchValueOperator.Wildcard, unquoted, [unquoted]);
+    }
+    return build(SearchValueOperator.Equals, unescapeWildcards(unquoted));
+};
+/**
+ * Parse a whole search string into tokens.
+ *
+ * Consecutive free-text words are combined into one phrase token; a field
+ * filter between them ends the phrase, so `foo severity:error bar` searches
+ * for "foo" and for "bar", never for the phrase "foo bar" that never occurred
+ * in any log line.
+ */
+export const parseSearchQuery = (raw, options) => {
+    var _a;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    const rawTokens = tokenizeSearchQuery(trimmed, options);
+    const tokens = [];
+    let freeTextParts = [];
+    const flushFreeText = () => {
+        if (freeTextParts.length === 0) {
+            return;
+        }
+        const combined = freeTextParts.join(" ");
+        tokens.push({
+            type: SearchTokenType.FreeText,
+            key: "",
+            predicate: {
+                operator: SearchValueOperator.Contains,
+                value: combined,
+                values: [],
+            },
+            negated: false,
+            raw: combined,
+        });
+        freeTextParts = [];
+    };
+    for (const rawToken of rawTokens) {
+        if (BOOLEAN_KEYWORDS.has(rawToken)) {
+            /*
+             * Tokens are ANDed. `AND` is therefore a no-op, and a bare `OR` cannot
+             * be honoured between two different filters — it is skipped rather than
+             * silently reinterpreted. Use `@k:(a OR b)` for an OR over one key.
+             */
+            continue;
+        }
+        let working = rawToken;
+        let negated = false;
+        if (working.startsWith("-") && working.length > 1) {
+            negated = true;
+            working = working.slice(1);
+        }
+        const isAttribute = working.startsWith("@");
+        if (isAttribute) {
+            working = working.slice(1);
+        }
+        /*
+         * A quoted token is free text even if it contains a colon — quoting is
+         * how a user searches for a literal `foo:bar` in a message.
+         */
+        const colonIndex = working.startsWith('"')
+            ? -1
+            : working.indexOf(":");
+        if (colonIndex <= 0) {
+            if (isAttribute) {
+                // `@key` with no value: a bare mention, not a filter. Ignore it.
+                continue;
+            }
+            freeTextParts.push(unescapeWildcards(stripQuotes(working)));
+            continue;
+        }
+        const rawKey = working.slice(0, colonIndex);
+        const rawValue = working.slice(colonIndex + 1);
+        if (rawValue.length === 0) {
+            // `severity:` with nothing after it — the user is still typing.
+            continue;
+        }
+        /*
+         * Prose that happens to contain a colon stays prose. Only a bare key is
+         * held to this; `@12:30` is an explicit instruction and is honoured.
+         */
+        if (!isAttribute &&
+            (!BARE_FIELD_KEY_REGEX.test(rawKey) ||
+                URL_SCHEME_VALUE_REGEX.test(rawValue))) {
+            freeTextParts.push(unescapeWildcards(stripQuotes(rawToken)));
+            continue;
+        }
+        flushFreeText();
+        const key = isAttribute
+            ? rawKey
+            : ((_a = options === null || options === void 0 ? void 0 : options.fieldAliases) === null || _a === void 0 ? void 0 : _a[rawKey.toLowerCase()]) || rawKey;
+        tokens.push({
+            type: isAttribute ? SearchTokenType.Attribute : SearchTokenType.Field,
+            key,
+            predicate: parseSearchValue(rawValue, negated),
+            negated,
+            raw: rawToken,
+        });
+    }
+    flushFreeText();
+    return tokens;
+};
+const parseNumericOrString = (value) => {
+    return NUMERIC_REGEX.test(value.trim()) ? Number(value.trim()) : value;
+};
+/** The glob list of a wildcard predicate; a single glob is a list of one. */
+const globsOf = (predicate) => {
+    return predicate.values.length > 0 ? predicate.values : [predicate.value];
+};
+/**
+ * Compile a predicate into the query-operator vocabulary the analytics and
+ * Postgres compilers already speak. A bare string is returned for equality so
+ * the fast `attributes['k'] = 'v'` map-subscript path is preserved.
+ */
+export const predicateToQueryValue = (predicate) => {
+    switch (predicate.operator) {
+        case SearchValueOperator.NotEquals:
+            return new NotEqual(predicate.value);
+        case SearchValueOperator.Contains:
+            return new Search(predicate.value);
+        case SearchValueOperator.NotContains:
+            return new NotContains(predicate.value);
+        case SearchValueOperator.StartsWith:
+            return new StartsWith(predicate.value);
+        case SearchValueOperator.EndsWith:
+            return new EndsWith(predicate.value);
+        case SearchValueOperator.Wildcard:
+            return new Wildcard(globsOf(predicate));
+        case SearchValueOperator.NotWildcard:
+            return new NotWildcard(globsOf(predicate));
+        case SearchValueOperator.GreaterThan:
+            return new GreaterThan(parseNumericOrString(predicate.value));
+        case SearchValueOperator.GreaterThanOrEqual:
+            return new GreaterThanOrEqual(parseNumericOrString(predicate.value));
+        case SearchValueOperator.LessThan:
+            return new LessThan(parseNumericOrString(predicate.value));
+        case SearchValueOperator.LessThanOrEqual:
+            return new LessThanOrEqual(parseNumericOrString(predicate.value));
+        case SearchValueOperator.In:
+            return new Includes(predicate.values);
+        case SearchValueOperator.NotIn:
+            return new IncludesNone(predicate.values);
+        case SearchValueOperator.Exists:
+            return new NotNull();
+        case SearchValueOperator.NotExists:
+            return new IsNull();
+        case SearchValueOperator.Equals:
+        default:
+            return predicate.value;
+    }
+};
+/**
+ * The same compilation, in the `{_type, value}` wire shape the histogram /
+ * facet / analytics endpoints accept. Going through one function is what
+ * keeps the chart and the table showing the same filter.
+ */
+export const predicateToSerializedValue = (predicate) => {
+    const queryValue = predicateToQueryValue(predicate);
+    if (typeof queryValue === "string") {
+        return queryValue;
+    }
+    return queryValue.toJSON();
+};
+/**
+ * Render a value that came from the DATA into a search token that means
+ * exactly that value.
+ *
+ * A facet value the user clicked, or an attribute copied off a log row, may
+ * legitimately contain `*`, `?`, a space or a quote — a Kubernetes arg like
+ * `--foo=*`, a URL pattern `/api/*`. Without escaping, clicking such a value
+ * would build a filter that matches far more than the row it came from.
+ */
+export const buildSearchTokenValue = (literal) => {
+    const escaped = escapeWildcards(literal)
+        .replace(QUOTE_REGEX, "\\$1")
+        .replace(LEADING_OPERATOR_REGEX, "\\$1")
+        .replace(WRAPPED_LIST_REGEX, "\\$&");
+    return WHITESPACE_REGEX.test(escaped) ? `"${escaped}"` : escaped;
+};
+/**
+ * Compile the values of one `attributes.<key>` chip group into a query value.
+ *
+ * A chip carries the value exactly as the user typed it, so the same grammar
+ * that governs the search bar governs the chip — this is what makes
+ * `@platform.team:a*` work whether it is submitted as text or applied as a
+ * chip, and what stops the two paths compiling to different SQL.
+ *
+ *  - one value        → that predicate
+ *  - several literals → `IN (...)`, which the database resolves by hash
+ *  - several globs    → one Wildcard carrying all of them (an OR of ILIKEs)
+ *  - anything mixed   → the predicates AND-ed, the only reading a flat map
+ *                       slot can express for unlike operators
+ */
+export const compileAttributeChipValues = (values) => {
+    const meaningful = values.filter((value) => {
+        return value.length > 0;
+    });
+    if (meaningful.length === 0) {
+        return undefined;
+    }
+    const predicates = meaningful.map((value) => {
+        return parseSearchValue(value);
+    });
+    if (predicates.length === 1) {
+        return predicateToQueryValue(predicates[0]);
+    }
+    const everyEquals = predicates.every((predicate) => {
+        return predicate.operator === SearchValueOperator.Equals;
+    });
+    if (everyEquals) {
+        return new Includes(predicates.map((predicate) => {
+            return predicate.value;
+        }));
+    }
+    const everyEqualsOrGlob = predicates.every((predicate) => {
+        return (predicate.operator === SearchValueOperator.Equals ||
+            predicate.operator === SearchValueOperator.Wildcard);
+    });
+    if (everyEqualsOrGlob) {
+        return new Wildcard(predicates.flatMap((predicate) => {
+            /*
+             * A literal joins the glob list as an inert glob, so an OR that mixes
+             * `abc` with `a*` still evaluates as one disjunction.
+             */
+            return predicate.operator === SearchValueOperator.Wildcard
+                ? globsOf(predicate)
+                : [escapeWildcards(predicate.value)];
+        }));
+    }
+    return predicates.map((predicate) => {
+        return predicateToQueryValue(predicate);
+    });
+};
+/**
+ * How a chip value should read to a person: escapes resolved, operator
+ * markers kept (`~foo` still says "contains foo").
+ */
+export const describeSearchValue = (value) => {
+    const predicate = parseSearchValue(value);
+    switch (predicate.operator) {
+        case SearchValueOperator.Equals:
+            return predicate.value;
+        case SearchValueOperator.Wildcard:
+            return globsOf(predicate).join(" OR ");
+        case SearchValueOperator.In:
+            return predicate.values.join(" OR ");
+        case SearchValueOperator.Exists:
+            return "any value";
+        case SearchValueOperator.NotExists:
+            return "no value";
+        default:
+            return value;
+    }
+};
+/**
+ * The inverse of {@link compileAttributeChipValues}: turn a stored attribute
+ * predicate back into the chip values that would produce it.
+ *
+ * A saved view stores the compiled query, not the chips, so without this an
+ * attribute filter comes back applied but invisible — and the next chip edit,
+ * which recompiles the query from the chips it can see, silently drops it.
+ */
+export const queryValueToChipValues = (value) => {
+    var _a, _b, _c, _d, _e;
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => {
+            return queryValueToChipValues(entry);
+        });
+    }
+    if (typeof value === "string") {
+        return value.length > 0 ? [buildSearchTokenValue(value)] : [];
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return [String(value)];
+    }
+    if (value instanceof Wildcard || value instanceof NotWildcard) {
+        const prefix = value instanceof NotWildcard ? "-" : "";
+        return value.values.map((glob) => {
+            return `${prefix}${glob}`;
+        });
+    }
+    if (value instanceof Includes) {
+        return value.values.map((entry) => {
+            return buildSearchTokenValue(entry.toString());
+        });
+    }
+    if (value instanceof IncludesNone) {
+        return [
+            `-(${value.values
+                .map((entry) => {
+                return buildSearchTokenValue(entry.toString());
+            })
+                .join(" OR ")})`,
+        ];
+    }
+    if (value instanceof NotNull) {
+        return ["*"];
+    }
+    if (value instanceof IsNull) {
+        return ["-*"];
+    }
+    if (value instanceof Search) {
+        return [`~${value.toString()}`];
+    }
+    if (value instanceof NotContains) {
+        return [`-~${value.toString()}`];
+    }
+    if (value instanceof StartsWith) {
+        return [`${escapeWildcards(value.toString())}*`];
+    }
+    if (value instanceof EndsWith) {
+        return [`*${escapeWildcards(value.toString())}`];
+    }
+    if (value instanceof NotEqual) {
+        return [`!${String((_a = value.value) !== null && _a !== void 0 ? _a : "")}`];
+    }
+    if (value instanceof GreaterThanOrEqual) {
+        return [`>=${String((_b = value.value) !== null && _b !== void 0 ? _b : "")}`];
+    }
+    if (value instanceof GreaterThan) {
+        return [`>${String((_c = value.value) !== null && _c !== void 0 ? _c : "")}`];
+    }
+    if (value instanceof LessThanOrEqual) {
+        return [`<=${String((_d = value.value) !== null && _d !== void 0 ? _d : "")}`];
+    }
+    if (value instanceof LessThan) {
+        return [`<${String((_e = value.value) !== null && _e !== void 0 ? _e : "")}`];
+    }
+    /*
+     * An operator with no chip rendering would come back as "[object Object]"
+     * on a chip. Returning nothing leaves the filter applied but unchipped,
+     * which is the lesser of the two evils and matches how the viewer already
+     * treats a base-query filter it cannot edit.
+     */
+    return [];
+};
+//# sourceMappingURL=TelemetrySearchQuery.js.map