@oneuptime/common 12.0.33 → 13.0.0

package/Utils/Rum/SessionReplayStringMap.ts

@@ -0,0 +1,226 @@
+/*
+ * Sanitising of the small string maps a host page hands the recorder:
+ * identify() traits, setTags()/addTag() tags and track() properties.
+ *
+ * Isomorphic on purpose. The recorder bundle imports this file through
+ * esbuild and runs it on third-party pages, and the ingest worker runs the
+ * SAME function over the same bytes at the same caps. One implementation
+ * on both sides is what makes "the server keeps exactly what the client
+ * sent" true rather than hoped for, so nothing here may touch Node, the
+ * DOM, or anything outside plain ECMAScript.
+ *
+ * Two rules the whole file serves:
+ *   1. Never throw. This runs inside a customer's page on values the page
+ *      author typed; a recorder that takes the host page down over a bad
+ *      tag is a worse bug than any tag.
+ *   2. Be deterministic. Insertion order is preserved and every cap is
+ *      applied the same way every time, so the recorder's copy, the
+ *      header row and the list cell all show the same map.
+ */
+
+export interface SessionReplayStringMapLimits {
+  /* Distinct keys kept; later keys are dropped once this is reached. */
+  maxKeys: number;
+  /* Keys longer than this are truncated (never dropped) to this length. */
+  maxKeyLength: number;
+  /* Values longer than this are truncated to this length. */
+  maxValueLength: number;
+}
+
+/*
+ * Assigning through this key on a plain object rewrites its prototype
+ * instead of adding a property, so a page calling
+ * setTags({ __proto__: ... }) would otherwise hand us an object whose
+ * later reads fall through to attacker-chosen defaults.
+ */
+const PROTOTYPE_KEY: string = "__proto__";
+
+function truncate(value: string, maxLength: number): string {
+  if (maxLength <= 0) {
+    return "";
+  }
+
+  return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+
+/*
+ * The only value types accepted, stringified the way a page author would
+ * expect. Anything else (objects, arrays, functions, symbols, null,
+ * undefined, NaN and the infinities) is dropped rather than rendered as
+ * "[object Object]" or "NaN": a value nobody can search for is not a tag.
+ */
+function stringifyValue(value: unknown): string | null {
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : null;
+  }
+
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+
+  return null;
+}
+
+/*
+ * Own, enumerable string keys in insertion order, or null when the input
+ * is not a usable object. Wrapped because Object.keys can throw on an
+ * exotic object (a revoked Proxy), and rule 1 says we do not.
+ */
+function readOwnKeys(input: unknown): Array<string> | null {
+  if (input === null || typeof input !== "object") {
+    return null;
+  }
+
+  /*
+   * Array.isArray itself throws on a revoked Proxy ("Cannot perform
+   * 'IsArray' on a proxy that has been revoked"), so it sits inside the
+   * guard too.
+   */
+  try {
+    if (Array.isArray(input)) {
+      return null;
+    }
+
+    return Object.keys(input as Record<string, unknown>);
+  } catch {
+    return null;
+  }
+}
+
+/*
+ * True when the value already has the shape this module produces: a plain
+ * object whose every value is a string. Used as the type guard for the
+ * tags / traits / properties fields on custom-event payloads that cross
+ * the wire, where "shaped like a map" is the minimum worth trusting.
+ */
+export function isSessionReplayStringMap(
+  value: unknown,
+): value is Record<string, string> {
+  const keys: Array<string> | null = readOwnKeys(value);
+
+  if (keys === null) {
+    return false;
+  }
+
+  const record: Record<string, unknown> = value as Record<string, unknown>;
+
+  return keys.every((key: string): boolean => {
+    return typeof record[key] === "string";
+  });
+}
+
+/*
+ * Coerce an untrusted value into a bounded Record<string, string>.
+ *
+ * - Non-objects, arrays and null yield {}.
+ * - Keys are truncated to maxKeyLength; a key that is empty (before or
+ *   after truncation) is dropped, and a truncated key that collides with
+ *   an earlier one overwrites it, which is what a plain object would do.
+ * - Values are accepted when string, finite number or boolean and are
+ *   stringified then truncated to maxValueLength. Anything else is dropped
+ *   with its key.
+ * - Once maxKeys distinct keys are kept, further NEW keys are dropped;
+ *   a repeated key still overwrites, so the count never exceeds the cap.
+ * - Insertion order is the input's own key order.
+ */
+export function sanitizeSessionReplayStringMap(
+  input: unknown,
+  limits: SessionReplayStringMapLimits,
+): Record<string, string> {
+  const result: Record<string, string> = {};
+  const keys: Array<string> | null = readOwnKeys(input);
+
+  if (keys === null) {
+    return result;
+  }
+
+  const record: Record<string, unknown> = input as Record<string, unknown>;
+  let keptCount: number = 0;
+
+  for (const rawKey of keys) {
+    const key: string = truncate(rawKey, limits.maxKeyLength);
+
+    if (key.length === 0 || key === PROTOTYPE_KEY) {
+      continue;
+    }
+
+    let stringValue: string | null;
+
+    try {
+      stringValue = stringifyValue(record[rawKey]);
+    } catch {
+      /* A throwing getter is the page's problem, not the recorder's. */
+      continue;
+    }
+
+    if (stringValue === null) {
+      continue;
+    }
+
+    const isNewKey: boolean = !Object.prototype.hasOwnProperty.call(
+      result,
+      key,
+    );
+
+    if (isNewKey && keptCount >= limits.maxKeys) {
+      continue;
+    }
+
+    result[key] = truncate(stringValue, limits.maxValueLength);
+
+    if (isNewKey) {
+      keptCount++;
+    }
+  }
+
+  return result;
+}
+
+/*
+ * The addTag()/setTags() merge: entries in `patch` overwrite entries in
+ * `base`; both sides are sanitised first so a stale or oversized base can
+ * never leak past the caps. When the union would exceed maxKeys, the
+ * EXISTING keys win and the patch's surplus new keys are dropped: a page
+ * that keeps adding tags past the cap gets a stable map rather than one
+ * whose oldest entries silently rotate away, and the same rule on the
+ * server keeps the header identical to what the recorder held.
+ */
+export function mergeSessionReplayStringMaps(
+  base: unknown,
+  patch: unknown,
+  limits: SessionReplayStringMapLimits,
+): Record<string, string> {
+  const merged: Record<string, string> = sanitizeSessionReplayStringMap(
+    base,
+    limits,
+  );
+  const sanitizedPatch: Record<string, string> = sanitizeSessionReplayStringMap(
+    patch,
+    limits,
+  );
+
+  let keptCount: number = Object.keys(merged).length;
+
+  for (const key of Object.keys(sanitizedPatch)) {
+    const isNewKey: boolean = !Object.prototype.hasOwnProperty.call(
+      merged,
+      key,
+    );
+
+    if (isNewKey && keptCount >= limits.maxKeys) {
+      continue;
+    }
+
+    merged[key] = sanitizedPatch[key] as string;
+
+    if (isNewKey) {
+      keptCount++;
+    }
+  }
+
+  return merged;
+}

package/Utils/Schema/ModelSchema.ts

@@ -1760,6 +1760,7 @@ export class ModelSchema extends BaseSchema {
         return this.getShortTextExample();
 
       case TableColumnType.LongText:
+      case TableColumnType.VeryLongText:
         return this.getLongTextExample();
 
       case TableColumnType.Email:

package/Utils/StatusPage/ResourceSearch.ts

@@ -0,0 +1,290 @@
+import StatusPageGroup from "../../Models/DatabaseModels/StatusPageGroup";
+import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
+import StatusPageGroupTreeUtil, { StatusPageGroupTreeIndex } from "./GroupTree";
+
+export interface StatusPageResourceSearchResult {
+  /* False when there is nothing to filter by; the page renders untouched. */
+  isActive: boolean;
+  /* Resource ids to render. Empty with isActive true means "no matches". */
+  matchedResourceIds: Set<string>;
+  matchedResourceCount: number;
+  totalResourceCount: number;
+  /*
+   * Groups that must still be drawn: the ones holding a match, plus every
+   * ancestor of those, so a match four levels down is reachable rather than
+   * orphaned.
+   */
+  visibleGroupIds: Set<string>;
+  /* Whether any resource that belongs to no group matched. */
+  hasUngroupedMatches: boolean;
+}
+
+/*
+ * Finding one service on a status page.
+ *
+ * A page with a few hundred resources spread over a nested group hierarchy has
+ * no way to answer "is the thing I use up?" other than opening groups one at a
+ * time and reading. This filters the page down to what a visitor typed.
+ *
+ * Two rules make it behave the way people expect rather than the way a naive
+ * substring filter would:
+ *
+ *   - Typing a group's name keeps that whole group, including everything
+ *     nested under it. Searching "Europe" is asking about a region, not about
+ *     a service that happens to have Europe in its name.
+ *   - A group is kept when anything in its subtree matched, and so is every
+ *     group above it. Otherwise a match nested three levels deep would have
+ *     nowhere to render.
+ *
+ * Pure and index-driven: one pass to match, one walk up per matched group. The
+ * overview calls this on every keystroke against lists that reach four figures.
+ */
+export default class StatusPageResourceSearchUtil {
+  /*
+   * Below this the box is clutter - you can see the whole page at once, and a
+   * search field over three rows reads as a mistake.
+   */
+  public static readonly MinimumResourcesForSearch: number = 8;
+  public static readonly MinimumGroupsForSearch: number = 3;
+
+  public static shouldShowSearch(data: {
+    resourceCount: number;
+    groupCount: number;
+  }): boolean {
+    return (
+      data.resourceCount >= this.MinimumResourcesForSearch ||
+      data.groupCount >= this.MinimumGroupsForSearch
+    );
+  }
+
+  public static normalizeQuery(query: string | null | undefined): string {
+    return (query || "").trim().toLowerCase();
+  }
+
+  private static matches(data: {
+    haystack: string | null | undefined;
+    needle: string;
+  }): boolean {
+    if (!data.haystack) {
+      return false;
+    }
+
+    return data.haystack.toLowerCase().includes(data.needle);
+  }
+
+  private static getResourceText(
+    resource: StatusPageResource,
+  ): Array<string | null | undefined> {
+    return [
+      resource.displayName,
+      resource.displayDescription,
+      resource.monitor?.name,
+    ];
+  }
+
+  public static search(data: {
+    query: string | null | undefined;
+    statusPageResources: Array<StatusPageResource>;
+    statusPageGroups: Array<StatusPageGroup>;
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
+  }): StatusPageResourceSearchResult {
+    const needle: string = this.normalizeQuery(data.query);
+
+    const totalResourceCount: number = data.statusPageResources.length;
+
+    if (!needle) {
+      return {
+        isActive: false,
+        matchedResourceIds: new Set<string>(),
+        matchedResourceCount: totalResourceCount,
+        totalResourceCount: totalResourceCount,
+        visibleGroupIds: new Set<string>(),
+        hasUngroupedMatches: true,
+      };
+    }
+
+    const index: StatusPageGroupTreeIndex =
+      data.statusPageGroupTreeIndex ||
+      StatusPageGroupTreeUtil.buildIndex({
+        statusPageGroups: data.statusPageGroups,
+      });
+
+    /*
+     * Groups whose own name or description matched. Everything below one of
+     * these is kept wholesale.
+     */
+    const directlyMatchedGroupIds: Set<string> = new Set<string>();
+
+    for (const group of data.statusPageGroups) {
+      const groupId: string | undefined = group._id?.toString();
+
+      if (!groupId) {
+        continue;
+      }
+
+      if (
+        this.matches({ haystack: group.name, needle: needle }) ||
+        this.matches({ haystack: group.description, needle: needle })
+      ) {
+        directlyMatchedGroupIds.add(groupId);
+      }
+    }
+
+    /*
+     * A group is "inside a matched group" when it or any ancestor matched by
+     * name. Walking up is bounded by a visited set - a parent pointer written
+     * straight to the database can form a cycle, and this must not hang the
+     * page (see GroupTree, which is defensive about exactly this).
+     */
+    const isInsideMatchedGroup: (groupId: string | null) => boolean = (
+      groupId: string | null,
+    ): boolean => {
+      let currentId: string | null = groupId;
+      const seen: Set<string> = new Set<string>();
+
+      while (currentId) {
+        if (seen.has(currentId)) {
+          return false;
+        }
+        seen.add(currentId);
+
+        if (directlyMatchedGroupIds.has(currentId)) {
+          return true;
+        }
+
+        const group: StatusPageGroup | undefined = index.byId.get(currentId);
+
+        if (!group) {
+          return false;
+        }
+
+        currentId = StatusPageGroupTreeUtil.getParentId(group);
+      }
+
+      return false;
+    };
+
+    const matchedResourceIds: Set<string> = new Set<string>();
+    const groupIdsHoldingMatches: Set<string> = new Set<string>();
+    let hasUngroupedMatches: boolean = false;
+
+    for (const resource of data.statusPageResources) {
+      const resourceId: string | undefined = resource._id?.toString();
+      const groupId: string | null =
+        resource.statusPageGroupId?.toString() || null;
+
+      const matchedByOwnText: boolean = this.getResourceText(resource).some(
+        (text: string | null | undefined) => {
+          return this.matches({ haystack: text, needle: needle });
+        },
+      );
+
+      const isMatch: boolean =
+        matchedByOwnText || isInsideMatchedGroup(groupId);
+
+      if (!isMatch) {
+        continue;
+      }
+
+      if (resourceId) {
+        matchedResourceIds.add(resourceId);
+      }
+
+      if (groupId) {
+        groupIdsHoldingMatches.add(groupId);
+      } else {
+        hasUngroupedMatches = true;
+      }
+    }
+
+    /*
+     * Every group holding a match, plus its ancestors. A group that matched by
+     * name is kept even when it turns out to hold nothing - it is a real
+     * answer to what was typed, and hiding it would read as "no such group".
+     */
+    const visibleGroupIds: Set<string> = new Set<string>();
+
+    const keepWithAncestors: (groupId: string) => void = (
+      groupId: string,
+    ): void => {
+      let currentId: string | null = groupId;
+      const seen: Set<string> = new Set<string>();
+
+      while (currentId) {
+        if (seen.has(currentId)) {
+          return;
+        }
+        seen.add(currentId);
+
+        visibleGroupIds.add(currentId);
+
+        const group: StatusPageGroup | undefined = index.byId.get(currentId);
+
+        if (!group) {
+          return;
+        }
+
+        currentId = StatusPageGroupTreeUtil.getParentId(group);
+      }
+    };
+
+    for (const groupId of groupIdsHoldingMatches) {
+      keepWithAncestors(groupId);
+    }
+
+    for (const groupId of directlyMatchedGroupIds) {
+      keepWithAncestors(groupId);
+    }
+
+    return {
+      isActive: true,
+      matchedResourceIds: matchedResourceIds,
+      matchedResourceCount: matchedResourceIds.size,
+      totalResourceCount: totalResourceCount,
+      visibleGroupIds: visibleGroupIds,
+      hasUngroupedMatches: hasUngroupedMatches,
+    };
+  }
+
+  /* Whether one resource survives a result. */
+  public static isResourceVisible(data: {
+    resource: StatusPageResource;
+    result: StatusPageResourceSearchResult;
+  }): boolean {
+    if (!data.result.isActive) {
+      return true;
+    }
+
+    const resourceId: string | undefined = data.resource._id?.toString();
+
+    if (!resourceId) {
+      /*
+       * A resource with no id of its own cannot be in the matched set, and
+       * showing it under every query would be worse than dropping it from a
+       * filtered view - the visitor asked a question and this is not an
+       * answer to it.
+       */
+      return false;
+    }
+
+    return data.result.matchedResourceIds.has(resourceId);
+  }
+
+  /* Whether one group is still drawn under a result. */
+  public static isGroupVisible(data: {
+    statusPageGroup: StatusPageGroup;
+    result: StatusPageResourceSearchResult;
+  }): boolean {
+    if (!data.result.isActive) {
+      return true;
+    }
+
+    const groupId: string | undefined = data.statusPageGroup._id?.toString();
+
+    if (!groupId) {
+      return false;
+    }
+
+    return data.result.visibleGroupIds.has(groupId);
+  }
+}