@oneuptime/common 12.0.25 → 12.0.27

package/build/dist/Server/Utils/AnalyticsDatabase/AttributeFilterStatement.js

@@ -0,0 +1,266 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+import { ObjectType } from "../../../Types/JSON";
+import { MAX_WILDCARD_PATTERNS, toLikePattern, } from "../../../Types/BaseDatabase/WildcardPattern";
+import { SQL, escapeIlikePattern } from "./Statement";
+/**
+ * Compile one serialized attribute operator into a predicate and append it.
+ *
+ * Throws BadDataException (a 400, not a 500) for an operator this builder
+ * cannot honour or a value it cannot bind — refusing is the only answer that
+ * keeps the chart and the list agreeing.
+ */
+export const appendAttributeOperatorFilter = (options) => {
+    const { statement, attributeKey, operator } = options;
+    const operatorType = operator["_type"];
+    const rawValue = operator["value"];
+    // `<key> matches case-insensitively AND <predicate>` over the map pairs.
+    const matches = (predicate) => {
+        return SQL `arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
+            type: TableColumnType.Text,
+            value: attributeKey,
+        }}) AND `
+            .append(predicate)
+            .append(SQL `, mapKeys(attributes), mapValues(attributes))`);
+    };
+    /*
+     * `value` is unvalidated JSON off the wire. `String()` and `Number()` do
+     * not merely produce a bad result on an object — ToPrimitive THROWS a
+     * TypeError when the object shadows toString/valueOf with non-callables
+     * (`{"toString": 1}`), and that escapes the BadDataException the default
+     * branch raises, answering with a 500 instead of a 400. Narrow to
+     * primitives first so every rejection goes out the same door.
+     */
+    const requirePrimitive = (value) => {
+        if (value === undefined || value === null) {
+            return null;
+        }
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            return value;
+        }
+        throw new BadDataException(`Invalid value in the attribute filter for "${attributeKey}"`);
+    };
+    const textValue = () => {
+        const primitive = requirePrimitive(rawValue);
+        return primitive === null ? "" : String(primitive);
+    };
+    const like = (pattern) => {
+        return SQL `v ILIKE ${{
+            type: TableColumnType.Text,
+            value: pattern,
+        }}`;
+    };
+    /*
+     * Map values are stored as text; toFloat64OrNull yields NULL for
+     * non-numeric values (including the empty default for a missing key),
+     * which compares false against any threshold and drops those rows.
+     */
+    const numeric = (comparison) => {
+        const primitive = requirePrimitive(rawValue);
+        const threshold = Number(primitive);
+        /*
+         * Reject rather than bind. `Number(null)` is 0, so a filter with no
+         * value would silently become "> 0", and a non-numeric one binds as the
+         * literal `nan`, which ClickHouse cannot parse — a 500 where the user
+         * should get a 400 naming the filter.
+         */
+        if (primitive === null ||
+            primitive === "" ||
+            !Number.isFinite(threshold)) {
+            throw new BadDataException(`The attribute filter for "${attributeKey}" needs a numeric value`);
+        }
+        /*
+         * Decimal (ClickHouse Double), not Number (Int32): the left-hand side is
+         * a Float64 and thresholds are free text, so `> 1.5` bound as Int32 is a
+         * parse error at the database rather than a comparison.
+         *
+         * The comparison itself is appended as raw SQL — an interpolation in the
+         * SQL tag becomes a bound Identifier, which is not what `>` is. Every
+         * caller passes a literal from the switch below, never user input.
+         */
+        return SQL `toFloat64OrNull(v) `.append(comparison).append(SQL ` ${{
+            type: TableColumnType.Decimal,
+            value: threshold,
+        }}`);
+    };
+    /*
+     * A Wildcard payload is an array of globs (a single glob is an array of
+     * one), and the wire shape is whatever JSON arrived — accept both so a
+     * client that sends the scalar form still works.
+     */
+    const globPatterns = () => {
+        const globs = Array.isArray(rawValue)
+            ? rawValue
+            : [rawValue];
+        return globs
+            .map((entry) => {
+            const primitive = requirePrimitive(entry);
+            return primitive === null ? "" : String(primitive);
+        })
+            .filter((glob) => {
+            return glob.length > 0;
+        })
+            .map((glob) => {
+            return toLikePattern(glob);
+        });
+    };
+    const membershipValues = () => {
+        return Array.isArray(rawValue)
+            ? rawValue.map((entry) => {
+                const primitive = requirePrimitive(entry);
+                return primitive === null ? "" : String(primitive);
+            })
+            : [];
+    };
+    /*
+     * "the key is present with a non-empty value".
+     *
+     * A ClickHouse Map subscript returns the value type's default for a
+     * missing key, so the list query's `attributes['k']` reads as '' for a row
+     * that has no such attribute at all. That makes an EMPTY comparison value
+     * mean something different from every other value, in both directions:
+     * `attributes['k'] = ''` matches rows that lack the key, and
+     * `attributes['k'] != ''` drops them. Naively negating the existence test
+     * gets both backwards — an "is not equal to <blank>" filter counted every
+     * row in the project while the list beside it counted only the handful
+     * that carried the attribute.
+     */
+    const hasNonEmptyValue = () => {
+        return matches(SQL `v != ''`);
+    };
+    switch (operatorType) {
+        case ObjectType.EqualTo:
+            if (textValue() === "") {
+                // `attributes['k'] = ''` — missing or empty. Same set as "is empty".
+                statement.append(SQL ` AND NOT `.append(hasNonEmptyValue()));
+                return;
+            }
+            statement.append(SQL ` AND `.append(matches(SQL `v = ${{
+                type: TableColumnType.Text,
+                value: textValue(),
+            }}`)));
+            return;
+        case ObjectType.NotEqual:
+            if (textValue() === "") {
+                /*
+                 * `attributes['k'] != ''` — present AND non-empty. Same set as
+                 * "is not empty"; see hasNonEmptyValue above for why blank is
+                 * special.
+                 */
+                statement.append(SQL ` AND `.append(hasNonEmptyValue()));
+                return;
+            }
+            /*
+             * Negating the whole existence test is what makes rows that lack the
+             * attribute pass, matching the map-subscript form's semantics (a
+             * missing key reads as '' and so is != a non-empty value).
+             */
+            statement.append(SQL ` AND NOT `.append(matches(SQL `v = ${{
+                type: TableColumnType.Text,
+                value: textValue(),
+            }}`)));
+            return;
+        /*
+         * Every ILIKE pattern below escapes the user's `%` and `_` so they match
+         * literally. Without it a value like `100%` or `req_id` silently widens
+         * the match here while the list query (which escapes centrally, in
+         * Statement.serializseValue) matches it literally — the chart and the
+         * table disagreeing on the same filter.
+         */
+        case ObjectType.Search:
+            statement.append(SQL ` AND `.append(matches(like(`%${escapeIlikePattern(textValue())}%`))));
+            return;
+        case ObjectType.NotContains:
+            statement.append(SQL ` AND NOT `.append(matches(like(`%${escapeIlikePattern(textValue())}%`))));
+            return;
+        case ObjectType.StartsWith:
+            statement.append(SQL ` AND `.append(matches(like(`${escapeIlikePattern(textValue())}%`))));
+            return;
+        case ObjectType.EndsWith:
+            statement.append(SQL ` AND `.append(matches(like(`%${escapeIlikePattern(textValue())}`))));
+            return;
+        /*
+         * Globs, one ILIKE per glob OR-ed together so an any-of list can mix
+         * patterns with literals. `toLikePattern` decides which `%`/`_` are
+         * wildcards and which are literal characters the user typed, so
+         * escaping on top of it would escape the wildcards it just produced.
+         *
+         * The negated form is NOT arrayExists, so a row that does not carry the
+         * attribute passes — it trivially fails to match the glob.
+         */
+        case ObjectType.Wildcard:
+        case ObjectType.NotWildcard: {
+            const patterns = globPatterns();
+            // An empty pattern list constrains nothing — the "All" reading.
+            if (patterns.length === 0) {
+                return;
+            }
+            if (patterns.length > MAX_WILDCARD_PATTERNS) {
+                throw new BadDataException(`The attribute filter for "${attributeKey}" has more than ${MAX_WILDCARD_PATTERNS} patterns`);
+            }
+            const disjunction = SQL `(`;
+            patterns.forEach((pattern, index) => {
+                if (index > 0) {
+                    disjunction.append(SQL ` OR `);
+                }
+                disjunction.append(like(pattern));
+            });
+            disjunction.append(SQL `)`);
+            statement.append((operatorType === ObjectType.Wildcard
+                ? SQL ` AND `
+                : SQL ` AND NOT `).append(matches(disjunction)));
+            return;
+        }
+        case ObjectType.GreaterThan:
+            statement.append(SQL ` AND `.append(matches(numeric(">"))));
+            return;
+        case ObjectType.GreaterThanOrEqual:
+            statement.append(SQL ` AND `.append(matches(numeric(">="))));
+            return;
+        case ObjectType.LessThan:
+            statement.append(SQL ` AND `.append(matches(numeric("<"))));
+            return;
+        case ObjectType.LessThanOrEqual:
+            statement.append(SQL ` AND `.append(matches(numeric("<="))));
+            return;
+        case ObjectType.IsNull:
+            // "is empty" — no non-empty value stored under that key.
+            statement.append(SQL ` AND NOT `.append(hasNonEmptyValue()));
+            return;
+        case ObjectType.NotNull:
+            statement.append(SQL ` AND `.append(hasNonEmptyValue()));
+            return;
+        case ObjectType.Includes:
+        case ObjectType.IncludesNone: {
+            const values = membershipValues();
+            /*
+             * An empty membership list means "All", not "nothing" — skipping the
+             * predicate matches how StatementGenerator and the form treat it, and
+             * avoids emitting `IN ()`.
+             */
+            if (values.length === 0) {
+                return;
+            }
+            const membership = matches(SQL `v IN (${{
+                type: TableColumnType.Text,
+                value: new Includes(values),
+            }})`);
+            statement.append((operatorType === ObjectType.Includes
+                ? SQL ` AND `
+                : SQL ` AND NOT `).append(membership));
+            return;
+        }
+        default:
+            /*
+             * An unrecognized shape is a filter this builder cannot honour.
+             * Refuse it rather than binding an object as text and quietly
+             * returning counts that disagree with the list.
+             */
+            throw new BadDataException(`Unsupported attribute filter for "${attributeKey}"`);
+    }
+};
+export default appendAttributeOperatorFilter;
+//# sourceMappingURL=AttributeFilterStatement.js.map

package/build/dist/Server/Utils/AnalyticsDatabase/AttributeFilterStatement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeFilterStatement.js","sourceRoot":"","sources":["../../../../../Server/Utils/AnalyticsDatabase/AttributeFilterStatement.ts"],"names":[],"mappings":"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"}

package/build/dist/Server/Utils/AnalyticsDatabase/StatementGenerator.js

@@ -27,6 +27,9 @@ import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
 import NotEqual from "../../../Types/BaseDatabase/NotEqual";
 import NotContains from "../../../Types/BaseDatabase/NotContains";
+import Wildcard from "../../../Types/BaseDatabase/Wildcard";
+import { MAX_WILDCARD_PATTERNS } from "../../../Types/BaseDatabase/WildcardPattern";
+import NotWildcard from "../../../Types/BaseDatabase/NotWildcard";
 import NotNull from "../../../Types/BaseDatabase/NotNull";
 import QueryOperator from "../../../Types/BaseDatabase/QueryOperator";
 import Search from "../../../Types/BaseDatabase/Search";
@@ -53,6 +56,28 @@ export default class StatementGenerator {
      * would compile to SQL ClickHouse rejects with a cryptic type error.
      * Fail with the same loud BadDataException the fallback uses.
      */
+    /*
+     * `(<subject> ILIKE {p0} OR <subject> ILIKE {p1} ...)` — the disjunction a
+     * multi-glob Wildcard compiles to. Always parenthesised, so a caller can
+     * wrap it in `NOT` or AND it into a lambda body without the OR escaping
+     * its intended scope.
+     */
+    static buildIlikeDisjunction(input) {
+        if (input.patterns.length > MAX_WILDCARD_PATTERNS) {
+            throw new BadDataException(`A wildcard filter cannot carry more than ${MAX_WILDCARD_PATTERNS} patterns`);
+        }
+        const disjunction = SQL `(`;
+        input.patterns.forEach((pattern, index) => {
+            if (index > 0) {
+                disjunction.append(SQL ` OR `);
+            }
+            disjunction.append(input.subject).append(SQL ` ILIKE ${{
+                value: pattern,
+                type: TableColumnType.Text,
+            }}`);
+        });
+        return disjunction.append(SQL `)`);
+    }
     throwIfMapOrJsonColumn(input) {
         if (input.tableColumn.type === TableColumnType.MapStringString ||
             input.tableColumn.type === TableColumnType.JSON ||
@@ -855,6 +880,56 @@ export default class StatementGenerator {
                     }}) OR ${columnRef(key)} IS NULL)`);
                 }
             }
+            else if (value instanceof Wildcard || value instanceof NotWildcard) {
+                /*
+                 * Glob matching (`api-*`, `*.internal`, `svc-?`), one ILIKE per glob
+                 * OR-ed together so an any-of list can mix patterns with literals.
+                 * The patterns come from `toLikePattern`, which is the only place
+                 * that decides which `%`/`_` are wildcards and which are literal
+                 * characters the user typed — escaping here as well would escape the
+                 * wildcards it just produced.
+                 *
+                 * The negated form mirrors NotContains rather than simply wrapping
+                 * the positive one in NOT: on a nullable scalar `NOT (NULL ILIKE
+                 * ...)` is NULL, and a row with no value at all trivially fails to
+                 * match a glob, so NULL rows are let through explicitly.
+                 */
+                this.throwIfMapOrJsonColumn({ operator: value, tableColumn, key });
+                const wildcardPatterns = value.toPatterns();
+                const isNegated = value instanceof NotWildcard;
+                /*
+                 * An empty pattern list constrains nothing — "All", the same reading
+                 * the empty Includes branch below takes. Emitting `()` would be a
+                 * parse error and dropping to a bare NOT would match everything.
+                 */
+                if (wildcardPatterns.length > 0) {
+                    if (tableColumn.type === TableColumnType.ArrayText) {
+                        const elementDisjunction = StatementGenerator.buildIlikeDisjunction({
+                            patterns: wildcardPatterns,
+                            subject: SQL `x`,
+                        });
+                        whereStatement.append((isNegated
+                            ? SQL `AND NOT arrayExists(x -> `
+                            : SQL `AND arrayExists(x -> `)
+                            .append(elementDisjunction)
+                            .append(SQL `, ${columnRef(key)})`));
+                    }
+                    else {
+                        const columnDisjunction = StatementGenerator.buildIlikeDisjunction({
+                            patterns: wildcardPatterns,
+                            subject: SQL `${columnRef(key)}`,
+                        });
+                        if (isNegated) {
+                            whereStatement.append(SQL `AND (NOT `
+                                .append(columnDisjunction)
+                                .append(SQL ` OR ${columnRef(key)} IS NULL)`));
+                        }
+                        else {
+                            whereStatement.append(SQL `AND `.append(columnDisjunction));
+                        }
+                    }
+                }
+            }
             else if (value instanceof IncludesAll &&
                 tableColumn.type === TableColumnType.ArrayText) {
                 /*
@@ -912,6 +987,29 @@ export default class StatementGenerator {
                      * is what the IsNull / NotNull / NotEqual branches below
                      * mirror to preserve the previous semantics.
                      */
+                    /*
+                     * Several operators AND-ed onto ONE attribute — `@k:a* @k:*b`, or
+                     * a chip plus a typed filter on the same key. The attributes map
+                     * has a single slot per key, so without this the second predicate
+                     * either overwrote the first or (worse) an array reached the
+                     * bare-value branch below and bound as `String(array)`, a silent
+                     * match-nothing. Each element compiles through a single-key
+                     * recursive call, so every branch below applies unchanged.
+                     */
+                    if (Array.isArray(mapEntry) &&
+                        mapEntry.length > 0 &&
+                        mapEntry.every((element) => {
+                            return element instanceof QueryOperator;
+                        })) {
+                        for (const operator of mapEntry) {
+                            const fragment = this.toWhereStatement({ [key]: { [mapKey]: operator } }, options);
+                            if (!fragment.query) {
+                                continue;
+                            }
+                            whereStatement.append(fragment);
+                        }
+                        continue;
+                    }
                     if (mapEntry instanceof IsNull) {
                         whereStatement.append(SQL `AND ((NOT mapContains(${columnRef(key)}, ${{
                             value: mapKey,
@@ -948,6 +1046,42 @@ export default class StatementGenerator {
                         }}, mapKeys(${columnRef(key)}), mapValues(${columnRef(key)}))`);
                         continue;
                     }
+                    if (mapEntry instanceof Wildcard || mapEntry instanceof NotWildcard) {
+                        /*
+                         * Glob matching on an attribute value — `@platform.team:a*`.
+                         *
+                         * Case-insensitive key match (the arrayExists form) for the same
+                         * reason Search / StartsWith / EndsWith use it: the key was typed
+                         * by a person, not read off a column list, so `requestId` and
+                         * `requestid` have to be the same filter. That also rules out
+                         * `appendMapKeyPresenceFilter`, whose `hasAny` prunes on an
+                         * EXACT key and would drop rows whose stored key differs only in
+                         * case.
+                         *
+                         * The negated form is `NOT arrayExists(...)`, so a row that does
+                         * not carry the attribute at all passes — it trivially does not
+                         * match the glob. That mirrors the NotContains branch below and
+                         * the missing-key semantics of the scalar map subscript.
+                         */
+                        const wildcardPatterns = mapEntry.toPatterns();
+                        if (wildcardPatterns.length === 0) {
+                            // Empty means "All" — see the Includes branch below.
+                            continue;
+                        }
+                        const negated = mapEntry instanceof NotWildcard;
+                        const valueDisjunction = StatementGenerator.buildIlikeDisjunction({
+                            patterns: wildcardPatterns,
+                            subject: SQL `v`,
+                        });
+                        const wildcardPredicate = SQL `arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
+                            value: mapKey,
+                            type: TableColumnType.Text,
+                        }}) AND `
+                            .append(valueDisjunction)
+                            .append(SQL `, mapKeys(${columnRef(key)}), mapValues(${columnRef(key)}))`);
+                        whereStatement.append((negated ? SQL `AND NOT ` : SQL `AND `).append(wildcardPredicate));
+                        continue;
+                    }
                     if (mapEntry instanceof NotContains) {
                         const literalValue = `%${escapeIlikePattern(mapEntry.value || "")}%`;
                         whereStatement.append(SQL `AND NOT arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{