@oneuptime/common 12.0.25 → 12.0.27

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -45,6 +45,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 GenericObject from "../../../Types/GenericObject";
@@ -123,6 +126,40 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
    * 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.
+   */
+  private static buildIlikeDisjunction(input: {
+    patterns: Array<string>;
+    subject: Statement;
+  }): Statement {
+    if (input.patterns.length > MAX_WILDCARD_PATTERNS) {
+      throw new BadDataException(
+        `A wildcard filter cannot carry more than ${MAX_WILDCARD_PATTERNS} patterns`,
+      );
+    }
+
+    const disjunction: Statement = SQL`(`;
+
+    input.patterns.forEach((pattern: string, index: number) => {
+      if (index > 0) {
+        disjunction.append(SQL` OR `);
+      }
+
+      disjunction.append(input.subject).append(
+        SQL` ILIKE ${{
+          value: pattern,
+          type: TableColumnType.Text,
+        }}`,
+      );
+    });
+
+    return disjunction.append(SQL`)`);
+  }
+
   private throwIfMapOrJsonColumn(input: {
     operator: QueryOperator<GenericObject | number | string>;
     tableColumn: AnalyticsTableColumn;
@@ -1146,6 +1183,63 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             }}) 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: Array<string> = value.toPatterns();
+        const isNegated: boolean = 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: Statement =
+              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: Statement =
+              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
@@ -1213,6 +1307,38 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
            * 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: unknown) => {
+              return element instanceof QueryOperator;
+            })
+          ) {
+            for (const operator of mapEntry) {
+              const fragment: Statement = this.toWhereStatement(
+                { [key]: { [mapKey]: operator } } as Query<TBaseModel>,
+                options,
+              );
+
+              if (!fragment.query) {
+                continue;
+              }
+
+              whereStatement.append(fragment);
+            }
+
+            continue;
+          }
+
           if (mapEntry instanceof IsNull) {
             whereStatement.append(
               SQL`AND ((NOT mapContains(${columnRef(key)}, ${{
@@ -1258,6 +1384,56 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             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: Array<string> = mapEntry.toPatterns();
+
+            if (wildcardPatterns.length === 0) {
+              // Empty means "All" — see the Includes branch below.
+              continue;
+            }
+
+            const negated: boolean = mapEntry instanceof NotWildcard;
+
+            const valueDisjunction: Statement =
+              StatementGenerator.buildIlikeDisjunction({
+                patterns: wildcardPatterns,
+                subject: SQL`v`,
+              });
+
+            const wildcardPredicate: Statement =
+              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: string = `%${escapeIlikePattern(
               (mapEntry.value as string) || "",

package/Server/Utils/DataSource/HttpFetch.ts

@@ -47,6 +47,13 @@ export interface DataSourceHttpResponse {
   bodyText: string;
   // Parsed JSON body, or undefined when the body is not valid JSON.
   bodyJson: unknown;
+  /*
+   * Response headers with lowercased names. Some protocols carry
+   * pagination state in headers rather than the body (TAXII 2.1's
+   * X-TAXII-Date-Added-Last cursor), so the transport surfaces them.
+   * Optional so hand-built responses (test fixtures) stay minimal.
+   */
+  headers?: Dictionary<string> | undefined;
 }
 
 export default class DataSourceHttpFetch {
@@ -148,10 +155,21 @@ export default class DataSourceHttpFetch {
         bodyJson = undefined;
       }
 
+      const responseHeaders: Dictionary<string> = {};
+      for (const key of Object.keys(response.headers || {})) {
+        const value: unknown = (response.headers as Record<string, unknown>)[
+          key
+        ];
+        if (value !== undefined && value !== null) {
+          responseHeaders[key.toLowerCase()] = String(value);
+        }
+      }
+
       return {
         statusCode: response.status,
         bodyText: bodyText,
         bodyJson: bodyJson,
+        headers: responseHeaders,
       };
     } catch (error) {
       if (axios.isAxiosError(error) && error.response) {

package/Server/Utils/Database/RelationIdUtil.ts

@@ -1,4 +1,5 @@
 import ObjectID from "../../../Types/ObjectID";
+import BadDataException from "../../../Types/Exception/BadDataException";
 
 /*
  * A many-to-one reference reaches a service hook under TWO different keys.
@@ -65,4 +66,45 @@ export default class RelationIdUtil {
 
     return null;
   }
+
+  /**
+   * Read one logical relation while rejecting payloads that point its scalar
+   * FK and relation-object spellings at different rows. TypeORM's precedence
+   * for two writes to the same join column is not a security boundary: a hook
+   * must validate the exact ID that can be persisted.
+   */
+  public static readConsistent(
+    data: Record<string, unknown> | undefined | null,
+    keys: Array<string>,
+    relationTitle: string,
+  ): ObjectID | null {
+    const ids: Array<ObjectID> = [];
+    const distinctIds: Set<string> = new Set();
+    let hasExplicitNull: boolean = false;
+
+    for (const key of keys) {
+      const value: unknown = (data || {})[key];
+
+      // Undefined is an omitted model property; null is an explicit clear.
+      if (value === undefined) {
+        continue;
+      }
+
+      const id: ObjectID | null = this.read(data, [key]);
+      if (id) {
+        ids.push(id);
+        distinctIds.add(id.toString());
+      } else {
+        hasExplicitNull = true;
+      }
+    }
+
+    if (distinctIds.size > 1 || (hasExplicitNull && distinctIds.size > 0)) {
+      throw new BadDataException(
+        `Conflicting ${relationTitle} references were provided.`,
+      );
+    }
+
+    return ids[0] || null;
+  }
 }

package/Server/Utils/Marketing/MarketingEventUtil.ts

@@ -163,21 +163,50 @@ export default class MarketingEventUtil {
    *
    * Guarantees it neither throws nor rejects. Every caller is inside a
    * commercial transaction that has already succeeded by the time it gets
-   * here — a user is created, a plan is changed, a booking is verified — so
-   * the one thing this must never do is turn a completed action into a failed
-   * one. The rejection path is covered by .catch and the synchronous path by
-   * the try, because an argument expression that throws (buildEvent on a
-   * malformed row) would otherwise propagate straight into the caller.
+   * here — a user is created, a plan is changed, a licence is issued — so the
+   * one thing this must never do is turn a completed action into a failed one.
+   *
+   * PASS A BUILDER, NOT AN EVENT. `emitInBackground(buildEvent({...}))`
+   * evaluates the argument at the CALL SITE, outside this try, so anything
+   * that throws while assembling the event propagates straight into the caller
+   * and this wrapper never runs at all. That is not hypothetical: reading
+   * `createdItem.expiresAt.toISOString()` off a licence whose date column held
+   * a string threw a TypeError after the INSERT had committed, and the admin
+   * dashboard reported "Server Error" for a licence it had just created. The
+   * `() => MarketingEvent` form moves that work inside the try, which is what
+   * makes the guarantee above true rather than merely intended.
+   *
+   * A plain event is still accepted for callers that already hold one.
    */
-  public static emitInBackground(event: MarketingEvent): void {
+  public static emitInBackground(
+    event: MarketingEvent | (() => MarketingEvent),
+  ): void {
+    let builtEvent: MarketingEvent | null = null;
+
     try {
-      this.emit(event).catch((err: Error) => {
+      builtEvent = typeof event === "function" ? event() : event;
+
+      const eventToEmit: MarketingEvent = builtEvent;
+
+      this.emit(eventToEmit).catch((err: Error) => {
+        /*
+         * Optional, because the point of this method is that nothing it
+         * touches may throw: a builder that returned something malformed must
+         * still end as a log line, not as an unhandled rejection raised from
+         * inside the handler that exists to prevent one.
+         */
         logger.error(
-          `MarketingEvent: failed to emit ${event.eventType}: ${err}`,
+          `MarketingEvent: failed to emit ${
+            eventToEmit?.eventType || "event"
+          }: ${err}`,
         );
       });
     } catch (err) {
-      logger.error(`MarketingEvent: failed to emit ${event.eventType}: ${err}`);
+      logger.error(
+        `MarketingEvent: failed to emit ${
+          builtEvent?.eventType || "event"
+        }: ${err}`,
+      );
     }
   }
 }

package/Server/Utils/Monitor/Criteria/ServerMonitorCriteria.ts

@@ -1,5 +1,6 @@
 import DataToProcess from "../DataToProcess";
 import CompareCriteria from "./CompareCriteria";
+import PerEntityCriteriaFanOut from "../PerEntityCriteriaFanOut";
 import EvaluateOverTime, { OverTimeCriteriaValue } from "./EvaluateOverTime";
 import OneUptimeDate from "../../../../Types/Date";
 import { BasicDiskMetrics } from "../../../../Types/Infrastructure/BasicMetrics";
@@ -211,9 +212,39 @@ export default class ServerMonitorCriteria {
 
       const normalizedDiskPath: string = normalizeDiskPath(diskPath);
 
-      const diskMetric: BasicDiskMetrics | undefined = (
-        input.dataToProcess as ServerMonitorResponse
-      ).basicInfrastructureMetrics?.diskMetrics?.find(
+      const allDiskMetrics: Array<BasicDiskMetrics> =
+        (input.dataToProcess as ServerMonitorResponse)
+          .basicInfrastructureMetrics?.diskMetrics || [];
+
+      /*
+       * "*" means every disk the agent reported. The criteria is met
+       * when ANY of them breaches, mirroring how a grouped metric
+       * monitor's criteria is met when any series breaches. The
+       * per-entity pass then re-runs this filter once per disk to work
+       * out which ones, so each full mount gets its own alert instead
+       * of the first one silencing the rest.
+       */
+      if (PerEntityCriteriaFanOut.isWildcard(diskPath)) {
+        for (const candidateDisk of allDiskMetrics) {
+          const candidateUsage: number =
+            candidateDisk.percentUsed ?? candidateDisk.percentFree ?? 0;
+
+          const candidateResult: string | null =
+            CompareCriteria.compareCriteriaNumbers({
+              value: candidateUsage,
+              threshold: threshold as number,
+              criteriaFilter: input.criteriaFilter,
+            });
+
+          if (candidateResult) {
+            return `Disk ${candidateDisk.diskPath} - ${candidateResult}`;
+          }
+        }
+
+        return null;
+      }
+
+      const diskMetric: BasicDiskMetrics | undefined = allDiskMetrics.find(
         (item: BasicDiskMetrics) => {
           return normalizeDiskPath(item.diskPath) === normalizedDiskPath;
         },

package/Server/Utils/Monitor/Criteria/SnmpMonitorCriteria.ts

@@ -1,5 +1,6 @@
 import DataToProcess from "../DataToProcess";
 import CompareCriteria from "./CompareCriteria";
+import PerEntityCriteriaFanOut from "../PerEntityCriteriaFanOut";
 import {
   AnomalyDetectionSensitivity,
   CheckOn,
@@ -43,7 +44,14 @@ export default class SnmpMonitorCriteria {
       .trim()
       .toLowerCase();
 
-    if (!scope) {
+    /*
+     * Empty has always meant "every interface". "*" means the same
+     * thing, and additionally opts the criteria into raising one alert
+     * per interface — see PerEntityCriteriaFanOut. Scoping treats them
+     * identically; only the fan-out tells them apart, so existing
+     * monitors that leave this blank keep their single combined alert.
+     */
+    if (!scope || PerEntityCriteriaFanOut.isWildcard(scope)) {
       return interfaces;
     }
 

package/Server/Utils/Monitor/Criteria/SyntheticMonitor.ts

@@ -30,20 +30,38 @@ export default class SyntheticMonitoringCriteria {
 
       // check browser type and screen type.
 
+      /*
+       * A synthetic monitor run produces one response per browser / screen size
+       * combination. Each branch below must only return when it actually found a
+       * match, otherwise the loop has to keep going so the remaining responses
+       * are compared too. Returning the (possibly null) comparison result
+       * directly would mean only the first response is ever evaluated.
+       */
+
       if (CheckOn.ScreenSizeType === input.criteriaFilter.checkOn) {
-        return CompareCriteria.checkEqualToOrNotEqualTo({
-          value: syntheticMonitorResponse.screenSizeType,
-          threshold: threshold as number,
-          criteriaFilter: input.criteriaFilter,
-        });
+        const screenSizeResult: string | null =
+          CompareCriteria.checkEqualToOrNotEqualTo({
+            value: syntheticMonitorResponse.screenSizeType,
+            threshold: threshold as number,
+            criteriaFilter: input.criteriaFilter,
+          });
+
+        if (screenSizeResult) {
+          return screenSizeResult;
+        }
       }
 
       if (CheckOn.BrowserType === input.criteriaFilter.checkOn) {
-        return CompareCriteria.checkEqualToOrNotEqualTo({
-          value: syntheticMonitorResponse.browserType,
-          threshold: threshold as number,
-          criteriaFilter: input.criteriaFilter,
-        });
+        const browserTypeResult: string | null =
+          CompareCriteria.checkEqualToOrNotEqualTo({
+            value: syntheticMonitorResponse.browserType,
+            threshold: threshold as number,
+            criteriaFilter: input.criteriaFilter,
+          });
+
+        if (browserTypeResult) {
+          return browserTypeResult;
+        }
       }
     }