@oneuptime/common 12.0.4 → 12.0.5

package/Utils/Metrics/RecordingRuleExpression.ts

@@ -6,7 +6,7 @@
  *   expr    := term (('+' | '-') term)*
  *   term    := factor (('*' | '/') factor)*
  *   factor  := number | identifier | '(' expr ')' | '-' factor
- *   number  := digits ('.' digits)?
+ *   number  := digit+ ('.' digit*)?
  *   identifier := [A-Za-z_][A-Za-z0-9_]*
  *
  * Evaluation returns `null` when the result is not a finite real number —
@@ -123,7 +123,7 @@ export function parse(input: string): ParseResult | ParseError {
   }
 
   const tokens: Array<Token> = tokenized;
-  const state: { i: number; depth: number } = { i: 0, depth: 0 };
+  const state: { i: number } = { i: 0 };
   const identifiers: Set<string> = new Set();
 
   function peek(): Token | undefined {
@@ -134,23 +134,20 @@ export function parse(input: string): ParseResult | ParseError {
     return tokens[state.i++];
   }
 
-  function parseExpr(): Node | ParseError {
-    if (state.depth > MAX_DEPTH) {
+  function parseExpr(depth: number): Node | ParseError {
+    if (depth > MAX_DEPTH) {
       return { ok: false, error: "Expression nesting too deep" };
     }
-    state.depth++;
-    let left: Node | ParseError = parseTerm();
+    let left: Node | ParseError = parseTerm(depth);
     if ("ok" in left && left.ok === false) {
-      state.depth--;
       return left;
     }
     while (true) {
       const next: Token | undefined = peek();
       if (next?.type === "op" && (next.value === "+" || next.value === "-")) {
         advance();
-        const right: Node | ParseError = parseTerm();
+        const right: Node | ParseError = parseTerm(depth);
         if ("ok" in right && right.ok === false) {
-          state.depth--;
           return right;
         }
         left = {
@@ -163,12 +160,11 @@ export function parse(input: string): ParseResult | ParseError {
       }
       break;
     }
-    state.depth--;
     return left as Node;
   }
 
-  function parseTerm(): Node | ParseError {
-    let left: Node | ParseError = parseFactor();
+  function parseTerm(depth: number): Node | ParseError {
+    let left: Node | ParseError = parseFactor(depth);
     if ("ok" in left && left.ok === false) {
       return left;
     }
@@ -176,7 +172,7 @@ export function parse(input: string): ParseResult | ParseError {
       const next: Token | undefined = peek();
       if (next?.type === "op" && (next.value === "*" || next.value === "/")) {
         advance();
-        const right: Node | ParseError = parseFactor();
+        const right: Node | ParseError = parseFactor(depth);
         if ("ok" in right && right.ok === false) {
           return right;
         }
@@ -193,7 +189,10 @@ export function parse(input: string): ParseResult | ParseError {
     return left as Node;
   }
 
-  function parseFactor(): Node | ParseError {
+  function parseFactor(depth: number): Node | ParseError {
+    if (depth > MAX_DEPTH) {
+      return { ok: false, error: "Expression nesting too deep" };
+    }
     const tok: Token | undefined = peek();
     if (!tok) {
       return {
@@ -203,7 +202,7 @@ export function parse(input: string): ParseResult | ParseError {
     }
     if (tok.type === "op" && tok.value === "-") {
       advance();
-      const operand: Node | ParseError = parseFactor();
+      const operand: Node | ParseError = parseFactor(depth + 1);
       if ("ok" in operand && operand.ok === false) {
         return operand;
       }
@@ -228,7 +227,7 @@ export function parse(input: string): ParseResult | ParseError {
     }
     if (tok.type === "lparen") {
       advance();
-      const inner: Node | ParseError = parseExpr();
+      const inner: Node | ParseError = parseExpr(depth + 1);
       if ("ok" in inner && inner.ok === false) {
         return inner;
       }
@@ -249,7 +248,7 @@ export function parse(input: string): ParseResult | ParseError {
     };
   }
 
-  const ast: Node | ParseError = parseExpr();
+  const ast: Node | ParseError = parseExpr(0);
   if ("ok" in ast && ast.ok === false) {
     return ast;
   }
@@ -281,6 +280,9 @@ export function evaluate(
     case "num":
       return Number.isFinite(node.value) ? node.value : null;
     case "ident": {
+      if (!Object.prototype.hasOwnProperty.call(bindings, node.name)) {
+        return null;
+      }
       const v: number | undefined = bindings[node.name];
       if (typeof v !== "number" || !Number.isFinite(v)) {
         return null;

package/Utils/Monitor/MonitorMetricType.ts

@@ -42,6 +42,8 @@ class MonitorMetricTypeUtil {
       case MonitorMetricType.TlsHandshakeTime:
       case MonitorMetricType.TimeToFirstByte:
       case MonitorMetricType.DownloadTime:
+      case MonitorMetricType.PortDnsLookupTime:
+      case MonitorMetricType.PortTcpConnectTime:
         return AggregationType.Avg;
       case MonitorMetricType.SnmpInterfaceOperStatus:
         return AggregationType.Min;
@@ -101,6 +103,10 @@ class MonitorMetricTypeUtil {
         return MonitorMetricType.PacketLossPercent;
       case CheckOn.Jitter:
         return MonitorMetricType.Jitter;
+      case CheckOn.PortDnsLookupTime:
+        return MonitorMetricType.PortDnsLookupTime;
+      case CheckOn.PortTcpConnectTime:
+        return MonitorMetricType.PortTcpConnectTime;
       case CheckOn.ResponseStatusCode:
         return MonitorMetricType.ResponseStatusCode;
       case CheckOn.IsOnline:
@@ -205,6 +211,16 @@ class MonitorMetricTypeUtil {
       ];
     }
 
+    if (monitorType === MonitorType.Port) {
+      return [
+        MonitorMetricType.IsOnline,
+        // Kept as the backwards-compatible total connection duration.
+        MonitorMetricType.ResponseTime,
+        MonitorMetricType.PortDnsLookupTime,
+        MonitorMetricType.PortTcpConnectTime,
+      ];
+    }
+
     if (monitorType === MonitorType.NetworkDevice) {
       return [
         MonitorMetricType.IsOnline,
@@ -218,7 +234,6 @@ class MonitorMetricTypeUtil {
     }
 
     if (
-      monitorType === MonitorType.Port ||
       monitorType === MonitorType.DNS ||
       monitorType === MonitorType.DNSSEC ||
       monitorType === MonitorType.Domain ||
@@ -344,7 +359,15 @@ class MonitorMetricTypeUtil {
 
   public static getTitleByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
+    monitorType?: MonitorType | undefined,
   ): string {
+    if (
+      monitorType === MonitorType.Port &&
+      monitorMetricType === MonitorMetricType.ResponseTime
+    ) {
+      return "Total Connection Time (DNS + TCP)";
+    }
+
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "Response Time";
@@ -374,6 +397,10 @@ class MonitorMetricTypeUtil {
         return "Time to First Byte";
       case MonitorMetricType.DownloadTime:
         return "Download Time";
+      case MonitorMetricType.PortDnsLookupTime:
+        return "Port DNS Lookup Time";
+      case MonitorMetricType.PortTcpConnectTime:
+        return "Port TCP Connect Time";
       case MonitorMetricType.SnmpInterfaceOperStatus:
         return "Interface Status";
       case MonitorMetricType.SnmpInterfaceInBitsPerSecond:
@@ -439,13 +466,14 @@ class MonitorMetricTypeUtil {
 
   public static getLegendByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
+    monitorType?: MonitorType | undefined,
   ): string {
     /*
      * Legend labels default to the title, which also matches the existing behavior
      * for every metric type. Keeping this as a separate function preserves the
      * option to diverge later (e.g. shorter legend labels for dense charts).
      */
-    return this.getTitleByMonitorMetricType(monitorMetricType);
+    return this.getTitleByMonitorMetricType(monitorMetricType, monitorType);
   }
 
   public static getLegendUnitByMonitorMetricType(
@@ -475,6 +503,8 @@ class MonitorMetricTypeUtil {
       case MonitorMetricType.TlsHandshakeTime:
       case MonitorMetricType.TimeToFirstByte:
       case MonitorMetricType.DownloadTime:
+      case MonitorMetricType.PortDnsLookupTime:
+      case MonitorMetricType.PortTcpConnectTime:
         return "ms";
       case MonitorMetricType.SnmpInterfaceOperStatus:
         return "";
@@ -525,7 +555,15 @@ class MonitorMetricTypeUtil {
 
   public static getDescriptionByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
+    monitorType?: MonitorType | undefined,
   ): string {
+    if (
+      monitorType === MonitorType.Port &&
+      monitorMetricType === MonitorMetricType.ResponseTime
+    ) {
+      return "Total time spent resolving the hostname (when needed) and establishing the TCP connection.";
+    }
+
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "Response time is the time taken for a server to respond to a request. It is the sum of the time spent waiting to establish the connection, the time spent waiting for the request to be processed, and the time spent waiting for the response to be sent.";
@@ -555,6 +593,10 @@ class MonitorMetricTypeUtil {
         return "Time from the end of connection setup until the first byte of the response arrived — the server-side processing time.";
       case MonitorMetricType.DownloadTime:
         return "Time spent receiving the response body after the first byte arrived.";
+      case MonitorMetricType.PortDnsLookupTime:
+        return "Time from starting a Port check until its first TCP connection attempt. It is absent when the destination is already an IP address.";
+      case MonitorMetricType.PortTcpConnectTime:
+        return "Time from the first TCP connection attempt until a connection succeeds, including any automatic IPv6/IPv4 fallback attempts.";
       case MonitorMetricType.SnmpInterfaceOperStatus:
         return "Operational status of each interface: 1 when up, 0 when down. Interfaces that are administratively disabled also report 0.";
       case MonitorMetricType.SnmpInterfaceInBitsPerSecond:

package/Utils/StatusPage/GroupNestingLayout.ts

@@ -271,6 +271,57 @@ export default class StatusPageGroupNestingLayoutUtil {
     return data.ownResourceCount > 0 || data.subGroupCount === 0;
   }
 
+  /*
+   * Whether the overview page draws its resources-and-groups block at all.
+   *
+   * This was `statusPageResources.length > 0` written inline on the page, and
+   * it meant a status page carrying a fully built group hierarchy but no
+   * monitors yet rendered nothing at all: an operator who had just created
+   * their whole hierarchy saw an empty overview until the first monitor was
+   * attached to one of the groups. A group is content in its own right - the
+   * hierarchy is what a large status page is organised around, and it has to
+   * be visible while it is being filled in - so either resources or groups are
+   * enough to draw the block.
+   */
+  public static shouldRenderResourcesSection(data: {
+    statusPageResourceCount: number;
+    statusPageGroupCount: number;
+  }): boolean {
+    return data.statusPageResourceCount > 0 || data.statusPageGroupCount > 0;
+  }
+
+  /*
+   * The "all clear" empty state is the page's fallback for when there is
+   * nothing whatsoever to draw, so it has to agree with
+   * shouldRenderResourcesSection: a page with groups and no monitors renders
+   * its hierarchy, and an empty state stacked above that hierarchy would be
+   * telling the visitor the opposite of what is on the screen underneath it.
+   */
+  public static shouldRenderOverviewEmptyState(data: {
+    statusPageResourceCount: number;
+    statusPageGroupCount: number;
+    activeIncidentCount: number;
+    activeEpisodeCount: number;
+    activeScheduledMaintenanceCount: number;
+    activeAnnouncementCount: number;
+  }): boolean {
+    if (
+      this.shouldRenderResourcesSection({
+        statusPageResourceCount: data.statusPageResourceCount,
+        statusPageGroupCount: data.statusPageGroupCount,
+      })
+    ) {
+      return false;
+    }
+
+    return (
+      data.activeIncidentCount === 0 &&
+      data.activeEpisodeCount === 0 &&
+      data.activeScheduledMaintenanceCount === 0 &&
+      data.activeAnnouncementCount === 0
+    );
+  }
+
   /*
    * Whether a group draws the time axis under its own resource list.
    *
@@ -329,7 +380,25 @@ export default class StatusPageGroupNestingLayoutUtil {
     showCurrentStatus: boolean;
     isCurrentlyDown: boolean;
     uptimePercent: number | null;
+    /*
+     * How many resources the group's whole subtree contains. Zero means there
+     * is nothing under this group to report on.
+     */
+    resourceCountInSubtree: number;
   }): StatusPageGroupRollupKind {
+    /*
+     * A group with nothing under it has no reading to give - not an uptime
+     * percent and not a status. This did not use to come up, because a page
+     * with no resources rendered no groups at all; now that a hierarchy is
+     * drawn while it is still being filled in, it does. The rolled up status
+     * defaults to Operational when it finds nothing to look at, and a green
+     * "Operational" against a group that contains no monitors is a claim about
+     * availability the page has no basis for.
+     */
+    if (data.resourceCountInSubtree <= 0) {
+      return StatusPageGroupRollupKind.None;
+    }
+
     if (data.showUptimePercent && !data.isCurrentlyDown) {
       return data.uptimePercent === null
         ? StatusPageGroupRollupKind.None

package/Utils/StatusPage/GroupTree.ts

@@ -6,6 +6,34 @@ export interface StatusPageGroupTreeNode {
   children: Array<StatusPageGroupTreeNode>;
 }
 
+/*
+ * A parent -> children index over one list of groups, plus the id lookup that
+ * goes with it.
+ *
+ * Every helper here used to answer "who are this group's children?" by
+ * filtering the whole list, which made one walk of the tree cost O(groups) per
+ * node it touched. That is invisible at a dozen groups and is not invisible at
+ * fifteen hundred: a status page that size renders the same subtree walk once
+ * per group per render. Building the buckets once turns each of those lookups
+ * into a map read.
+ *
+ * Callers that walk the same list more than once (the status page overview
+ * renders a rollup per group; the uptime endpoint rolls up per group) should
+ * build one of these with buildIndex and hand it to every call. Callers that
+ * only ask one question can leave it out - each method builds its own, which
+ * still costs one pass over the list rather than one pass per node.
+ */
+export interface StatusPageGroupTreeIndex {
+  /*
+   * Keyed by StatusPageGroupTreeUtil.getParentId, so `null` is the bucket of
+   * groups with no usable parent pointer. A plain string key would collide
+   * with groups that carry no id of their own, which read as "" everywhere
+   * else in this class.
+   */
+  childrenByParentId: Map<string | null, Array<StatusPageGroup>>;
+  byId: Map<string, StatusPageGroup>;
+}
+
 /*
  * Status page groups form a tree: a group may be nested under another group
  * (Corporate Unit -> Region -> Market -> Site), and each level rolls up the
@@ -42,17 +70,69 @@ export default class StatusPageGroupTreeUtil {
     return parentId;
   }
 
+  /*
+   * One pass over the list. Siblings come out of each bucket in `order`, which
+   * is the same order filtering the whole list and sorting it produced -
+   * bucketing keeps the incoming order and the sort below is stable, so groups
+   * that share an order (or have none) keep their incoming position.
+   */
+  public static buildIndex(data: {
+    statusPageGroups: Array<StatusPageGroup>;
+  }): StatusPageGroupTreeIndex {
+    const childrenByParentId: Map<
+      string | null,
+      Array<StatusPageGroup>
+    > = new Map<string | null, Array<StatusPageGroup>>();
+
+    const byId: Map<string, StatusPageGroup> = new Map<
+      string,
+      StatusPageGroup
+    >();
+
+    for (const group of data.statusPageGroups) {
+      const groupId: string | undefined = group._id?.toString();
+
+      if (groupId) {
+        byId.set(groupId, group);
+      }
+
+      const parentId: string | null = this.getParentId(group);
+      const siblings: Array<StatusPageGroup> | undefined =
+        childrenByParentId.get(parentId);
+
+      if (siblings) {
+        siblings.push(group);
+      } else {
+        childrenByParentId.set(parentId, [group]);
+      }
+    }
+
+    for (const siblings of childrenByParentId.values()) {
+      this.sortByOrderInPlace(siblings);
+    }
+
+    return {
+      childrenByParentId: childrenByParentId,
+      byId: byId,
+    };
+  }
+
   public static getChildGroups(data: {
     statusPageGroupId: string | null;
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageGroup> {
-    const children: Array<StatusPageGroup> = data.statusPageGroups.filter(
-      (group: StatusPageGroup) => {
-        return this.getParentId(group) === data.statusPageGroupId;
-      },
-    );
-
-    return this.sortByOrder(children);
+    /*
+     * A copy rather than the index's own bucket: this is public, and handing a
+     * caller the array the index is built on invites a mutation that would
+     * quietly corrupt every later lookup.
+     */
+    return [
+      ...this.getChildGroupsFromIndex({
+        statusPageGroupId: data.statusPageGroupId,
+        index: this.resolveIndex(data),
+      }),
+    ];
   }
 
   /*
@@ -61,13 +141,19 @@ export default class StatusPageGroupTreeUtil {
    */
   public static getRootGroups(data: {
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageGroup> {
-    const idsInList: Set<string> = this.getIdSet(data.statusPageGroups);
+    const index: StatusPageGroupTreeIndex = this.resolveIndex(data);
 
+    /*
+     * A scan of the whole list rather than a concatenation of the orphan
+     * buckets, so roots that share an order (or have none) keep the relative
+     * position they arrived in.
+     */
     const roots: Array<StatusPageGroup> = data.statusPageGroups.filter(
       (group: StatusPageGroup) => {
         const parentId: string | null = this.getParentId(group);
-        return !parentId || !idsInList.has(parentId);
+        return !parentId || !index.byId.has(parentId);
       },
     );
 
@@ -81,7 +167,9 @@ export default class StatusPageGroupTreeUtil {
    */
   public static buildTree(data: {
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageGroupTreeNode> {
+    const index: StatusPageGroupTreeIndex = this.resolveIndex(data);
     const visited: Set<string> = new Set<string>();
 
     const buildNode: (
@@ -94,16 +182,17 @@ export default class StatusPageGroupTreeUtil {
       const groupId: string = group._id?.toString() || "";
       visited.add(groupId);
 
-      const children: Array<StatusPageGroupTreeNode> = this.getChildGroups({
-        statusPageGroupId: groupId,
-        statusPageGroups: data.statusPageGroups,
-      })
-        .filter((child: StatusPageGroup) => {
-          return !visited.has(child._id?.toString() || "");
+      const children: Array<StatusPageGroupTreeNode> =
+        this.getChildGroupsFromIndex({
+          statusPageGroupId: groupId,
+          index: index,
         })
-        .map((child: StatusPageGroup) => {
-          return buildNode(child, depth + 1);
-        });
+          .filter((child: StatusPageGroup) => {
+            return !visited.has(child._id?.toString() || "");
+          })
+          .map((child: StatusPageGroup) => {
+            return buildNode(child, depth + 1);
+          });
 
       return {
         group: group,
@@ -114,6 +203,7 @@ export default class StatusPageGroupTreeUtil {
 
     const tree: Array<StatusPageGroupTreeNode> = this.getRootGroups({
       statusPageGroups: data.statusPageGroups,
+      index: index,
     }).map((root: StatusPageGroup) => {
       return buildNode(root, 0);
     });
@@ -137,15 +227,18 @@ export default class StatusPageGroupTreeUtil {
   public static getDescendantGroups(data: {
     statusPageGroup: StatusPageGroup;
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageGroup> {
+    const index: StatusPageGroupTreeIndex = this.resolveIndex(data);
+
     const descendants: Array<StatusPageGroup> = [];
     const visited: Set<string> = new Set<string>([
       data.statusPageGroup._id?.toString() || "",
     ]);
 
-    let frontier: Array<StatusPageGroup> = this.getChildGroups({
+    let frontier: Array<StatusPageGroup> = this.getChildGroupsFromIndex({
       statusPageGroupId: data.statusPageGroup._id?.toString() || "",
-      statusPageGroups: data.statusPageGroups,
+      index: index,
     });
 
     while (frontier.length > 0) {
@@ -162,9 +255,9 @@ export default class StatusPageGroupTreeUtil {
         descendants.push(group);
 
         nextFrontier.push(
-          ...this.getChildGroups({
+          ...this.getChildGroupsFromIndex({
             statusPageGroupId: groupId,
-            statusPageGroups: data.statusPageGroups,
+            index: index,
           }),
         );
       }
@@ -182,12 +275,14 @@ export default class StatusPageGroupTreeUtil {
   public static getGroupAndDescendants(data: {
     statusPageGroup: StatusPageGroup;
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageGroup> {
     return [
       data.statusPageGroup,
       ...this.getDescendantGroups({
         statusPageGroup: data.statusPageGroup,
         statusPageGroups: data.statusPageGroups,
+        index: data.index,
       }),
     ];
   }
@@ -198,10 +293,9 @@ export default class StatusPageGroupTreeUtil {
   public static getAncestorGroups(data: {
     statusPageGroup: StatusPageGroup;
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageGroup> {
-    const byId: Map<string, StatusPageGroup> = this.getGroupsById(
-      data.statusPageGroups,
-    );
+    const byId: Map<string, StatusPageGroup> = this.resolveIndex(data).byId;
 
     const ancestors: Array<StatusPageGroup> = [];
     const visited: Set<string> = new Set<string>([
@@ -231,10 +325,12 @@ export default class StatusPageGroupTreeUtil {
   public static getDepth(data: {
     statusPageGroup: StatusPageGroup;
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): number {
     return this.getAncestorGroups({
       statusPageGroup: data.statusPageGroup,
       statusPageGroups: data.statusPageGroups,
+      index: data.index,
     }).length;
   }
 
@@ -242,48 +338,39 @@ export default class StatusPageGroupTreeUtil {
     statusPageGroup: StatusPageGroup;
     possibleAncestorId: string;
     statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
   }): boolean {
     return this.getAncestorGroups({
       statusPageGroup: data.statusPageGroup,
       statusPageGroups: data.statusPageGroups,
+      index: data.index,
     }).some((ancestor: StatusPageGroup) => {
       return ancestor._id?.toString() === data.possibleAncestorId;
     });
   }
 
-  private static getGroupsById(
-    statusPageGroups: Array<StatusPageGroup>,
-  ): Map<string, StatusPageGroup> {
-    const byId: Map<string, StatusPageGroup> = new Map<
-      string,
-      StatusPageGroup
-    >();
-
-    for (const group of statusPageGroups) {
-      const groupId: string | undefined = group._id?.toString();
-
-      if (groupId) {
-        byId.set(groupId, group);
-      }
-    }
-
-    return byId;
+  private static resolveIndex(data: {
+    statusPageGroups: Array<StatusPageGroup>;
+    index?: StatusPageGroupTreeIndex | undefined;
+  }): StatusPageGroupTreeIndex {
+    return (
+      data.index ||
+      this.buildIndex({
+        statusPageGroups: data.statusPageGroups,
+      })
+    );
   }
 
-  private static getIdSet(
-    statusPageGroups: Array<StatusPageGroup>,
-  ): Set<string> {
-    const ids: Set<string> = new Set<string>();
-
-    for (const group of statusPageGroups) {
-      const groupId: string | undefined = group._id?.toString();
-
-      if (groupId) {
-        ids.add(groupId);
-      }
-    }
-
-    return ids;
+  /*
+   * The index's own bucket, not a copy. Internal callers below only ever read
+   * it or spread it, and a tree walk that copies every sibling list at every
+   * node is most of what this index exists to avoid.
+   */
+  private static getChildGroupsFromIndex(data: {
+    statusPageGroupId: string | null;
+    index: StatusPageGroupTreeIndex;
+  }): Array<StatusPageGroup> {
+    return data.index.childrenByParentId.get(data.statusPageGroupId) || [];
   }
 
   /*
@@ -293,15 +380,19 @@ export default class StatusPageGroupTreeUtil {
   private static sortByOrder(
     statusPageGroups: Array<StatusPageGroup>,
   ): Array<StatusPageGroup> {
-    return [...statusPageGroups].sort(
-      (a: StatusPageGroup, b: StatusPageGroup) => {
-        const orderA: number =
-          typeof a.order === "number" ? a.order : Number.MAX_SAFE_INTEGER;
-        const orderB: number =
-          typeof b.order === "number" ? b.order : Number.MAX_SAFE_INTEGER;
-
-        return orderA - orderB;
-      },
-    );
+    return this.sortByOrderInPlace([...statusPageGroups]);
+  }
+
+  private static sortByOrderInPlace(
+    statusPageGroups: Array<StatusPageGroup>,
+  ): Array<StatusPageGroup> {
+    return statusPageGroups.sort((a: StatusPageGroup, b: StatusPageGroup) => {
+      const orderA: number =
+        typeof a.order === "number" ? a.order : Number.MAX_SAFE_INTEGER;
+      const orderB: number =
+        typeof b.order === "number" ? b.order : Number.MAX_SAFE_INTEGER;
+
+      return orderA - orderB;
+    });
   }
 }