@oneuptime/common 12.0.3 → 12.0.5

package/Utils/StatusPage/ResourceUptime.ts

@@ -6,7 +6,7 @@ import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
 import Dictionary from "../../Types/Dictionary";
 import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
 import StatusPageGroup from "../../Models/DatabaseModels/StatusPageGroup";
-import StatusPageGroupTreeUtil from "./GroupTree";
+import StatusPageGroupTreeUtil, { StatusPageGroupTreeIndex } from "./GroupTree";
 import UptimeUtil, { UptimeWindow } from "../Uptime/UptimeUtil";
 
 export default class StatusPageResourceUptimeUtil {
@@ -81,6 +81,12 @@ export default class StatusPageResourceUptimeUtil {
      * (or pass only this group) to look at the group's own resources.
      */
     allStatusPageGroups?: Array<StatusPageGroup> | undefined;
+    /*
+     * A prebuilt parent -> children index over allStatusPageGroups. Optional,
+     * and worth passing from any caller that asks this per group: without it
+     * every call re-buckets the whole group list.
+     */
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
   }): MonitorStatus {
     let currentStatus: MonitorStatus = new MonitorStatus();
     currentStatus.name = "Operational";
@@ -91,6 +97,7 @@ export default class StatusPageResourceUptimeUtil {
         statusPageGroup: data.statusPageGroup,
         statusPageResources: data.statusPageResources,
         allStatusPageGroups: data.allStatusPageGroups,
+        statusPageGroupTreeIndex: data.statusPageGroupTreeIndex,
       });
 
     for (const resource of resourcesInGroup) {
@@ -187,6 +194,8 @@ export default class StatusPageResourceUptimeUtil {
      * makes each level of the hierarchy show a rolled up availability.
      */
     allStatusPageGroups?: Array<StatusPageGroup> | undefined;
+    /* See getCurrentStatusPageGroupStatus. */
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
   }): number | null {
     if (!data.statusPageGroup.showUptimePercent) {
       return null;
@@ -197,6 +206,7 @@ export default class StatusPageResourceUptimeUtil {
         statusPageGroup: data.statusPageGroup,
         statusPageResources: data.statusPageResources,
         allStatusPageGroups: data.allStatusPageGroups,
+        statusPageGroupTreeIndex: data.statusPageGroupTreeIndex,
       });
 
     if (resourcesInGroup.length === 0) {
@@ -276,11 +286,24 @@ export default class StatusPageResourceUptimeUtil {
     statusPageGroup: StatusPageGroup;
     statusPageResources: Array<StatusPageResource>;
     allStatusPageGroups?: Array<StatusPageGroup> | undefined;
+    /* See getCurrentStatusPageGroupStatus. */
+    statusPageGroupTreeIndex?: StatusPageGroupTreeIndex | undefined;
   }): Array<StatusPageResource> {
+    const statusPageGroups: Array<StatusPageGroup> =
+      data.allStatusPageGroups || [data.statusPageGroup];
+
     const groupsToInclude: Array<StatusPageGroup> =
       StatusPageGroupTreeUtil.getGroupAndDescendants({
         statusPageGroup: data.statusPageGroup,
-        statusPageGroups: data.allStatusPageGroups || [data.statusPageGroup],
+        statusPageGroups: statusPageGroups,
+        /*
+         * An index built over a different list than the one in play would
+         * answer for the wrong hierarchy, and allStatusPageGroups is what the
+         * caller's index is built from.
+         */
+        index: data.allStatusPageGroups
+          ? data.statusPageGroupTreeIndex
+          : undefined,
       });
 
     const groupIds: Set<string> = new Set<string>(
@@ -319,6 +342,15 @@ export default class StatusPageResourceUptimeUtil {
 
     const allUptimePercent: Array<number> = [];
 
+    /*
+     * One index for the whole descent below, rather than one re-bucketing of
+     * the group list per level and per reporting group.
+     */
+    const groupTreeIndex: StatusPageGroupTreeIndex =
+      StatusPageGroupTreeUtil.buildIndex({
+        statusPageGroups: data.resourceGroups,
+      });
+
     /*
      * Calculate for groups first. Groups nest, and a group that reports uptime
      * already averages its whole subtree - so descend only until the first
@@ -341,6 +373,7 @@ export default class StatusPageResourceUptimeUtil {
               monitorsInGroup: data.monitorsInGroup,
               uptimeWindow: data.uptimeWindow,
               allStatusPageGroups: data.resourceGroups,
+              statusPageGroupTreeIndex: groupTreeIndex,
             });
 
           if (groupUptimePercent !== null) {
@@ -354,6 +387,7 @@ export default class StatusPageResourceUptimeUtil {
           StatusPageGroupTreeUtil.getChildGroups({
             statusPageGroupId: group._id?.toString() || "",
             statusPageGroups: data.resourceGroups,
+            index: groupTreeIndex,
           }),
         );
       }
@@ -362,6 +396,7 @@ export default class StatusPageResourceUptimeUtil {
     collectGroupUptime(
       StatusPageGroupTreeUtil.getRootGroups({
         statusPageGroups: data.resourceGroups,
+        index: groupTreeIndex,
       }),
     );
 

package/Utils/TeamMembersByProject.ts

@@ -0,0 +1,237 @@
+import Project from "../Models/DatabaseModels/Project";
+import Team from "../Models/DatabaseModels/Team";
+import TeamMember from "../Models/DatabaseModels/TeamMember";
+import ObjectID from "../Types/ObjectID";
+
+/*
+ * TeamMember is a (user, team) pair, so "every membership this user has" is not
+ * the same list as "every project this user belongs to": someone on three teams
+ * of the same project has three memberships but is in one project.
+ *
+ * These helpers collapse a user's memberships into one row per project, carrying
+ * every team they belong to in that project. The Admin Dashboard's
+ * User > Projects page is the list this exists for, and the master-admin
+ * `POST /user/:userId/projects` endpoint is what runs it.
+ *
+ * This is the project-side mirror of TeamMembersByUser (which collapses a
+ * project's memberships into one row per user). They are kept apart rather than
+ * generalised into one grouper because the aggregate each side needs is
+ * different - one carries teams, the other carries teams *and* the project - and
+ * a shared abstraction would be read by neither caller.
+ */
+export interface UserProjectMembership {
+  /*
+   * Identity of the row. The lowest of the user's membership ids in this
+   * project, so the row carries the same id whatever order the memberships came
+   * back in - a first-seen id would change between two reads sorted differently
+   * and break every id-keyed thing on top of it (row selection, delete).
+   */
+  id: string | undefined;
+  projectId: ObjectID | undefined;
+  project: Project | undefined;
+  // Every team this user belongs to in this project, sorted by name.
+  teams: Array<Team>;
+  // The ids of every membership folded into this row.
+  teamMemberIds: Array<string>;
+  /*
+   * True as soon as ONE of the memberships has been accepted: a person who has
+   * accepted their invitation to any team of the project is in the project.
+   */
+  hasAcceptedInvitation: boolean;
+  // How many of the memberships are still unaccepted invitations.
+  pendingTeamCount: number;
+  // When the user was first invited to this project (earliest membership).
+  joinedAt: Date | undefined;
+}
+
+export default class TeamMembersByProject {
+  /**
+   * The project a membership is grouped under. Null when the membership carries
+   * no project at all - those rows are never merged, because merging them would
+   * put memberships of unrelated projects on one line.
+   */
+  public static getGroupKey(teamMember: TeamMember): string | null {
+    const projectId: string =
+      teamMember.projectId?.toString() ||
+      teamMember.project?._id?.toString() ||
+      "";
+
+    return projectId || null;
+  }
+
+  /**
+   * The name this row reads and sorts under. Falls back to the project id so a
+   * row whose project could not be joined still lands somewhere deterministic
+   * rather than sorting as a blank.
+   */
+  public static getProjectName(row: UserProjectMembership): string {
+    return (
+      row.project?.name?.toString() ||
+      row.projectId?.toString() ||
+      row.project?._id?.toString() ||
+      ""
+    );
+  }
+
+  /**
+   * One row per project, in the order each project was first seen. The input
+   * order is whatever the caller sorted the memberships by, so first-seen order
+   * keeps that sort intact.
+   */
+  public static groupByProject(
+    teamMembers: Array<TeamMember>,
+  ): Array<UserProjectMembership> {
+    const rowsByGroupKey: Map<string, UserProjectMembership> = new Map<
+      string,
+      UserProjectMembership
+    >();
+    const rows: Array<UserProjectMembership> = [];
+
+    /*
+     * Which teams are already on a row. Tracked separately rather than
+     * re-derived from `teams`, because a membership identifies its team by
+     * `teamId` while the team object it carries identifies itself by `_id`, and
+     * either one can be missing from a given select.
+     */
+    const teamKeysByRow: Map<UserProjectMembership, Set<string>> = new Map<
+      UserProjectMembership,
+      Set<string>
+    >();
+
+    for (const teamMember of teamMembers) {
+      const groupKey: string | null = this.getGroupKey(teamMember);
+
+      let row: UserProjectMembership | undefined = groupKey
+        ? rowsByGroupKey.get(groupKey)
+        : undefined;
+
+      if (!row) {
+        row = {
+          id: undefined,
+          projectId: teamMember.projectId || undefined,
+          project: teamMember.project || undefined,
+          teams: [],
+          teamMemberIds: [],
+          hasAcceptedInvitation: false,
+          pendingTeamCount: 0,
+          joinedAt: undefined,
+        };
+
+        teamKeysByRow.set(row, new Set<string>());
+
+        if (groupKey) {
+          rowsByGroupKey.set(groupKey, row);
+        }
+
+        rows.push(row);
+      }
+
+      this.addMembershipToRow(row, teamMember, teamKeysByRow.get(row)!);
+    }
+
+    for (const row of rows) {
+      this.finalizeRow(row);
+    }
+
+    return rows;
+  }
+
+  /**
+   * Alphabetical by project name, case-insensitively. Rows with no name at all
+   * sort last so the list does not open on a run of blanks.
+   *
+   * Returns a new array; the input is left alone.
+   */
+  public static sortByProjectName(
+    rows: Array<UserProjectMembership>,
+  ): Array<UserProjectMembership> {
+    return [...rows].sort(
+      (a: UserProjectMembership, b: UserProjectMembership) => {
+        const nameA: string = this.getProjectName(a).toLowerCase();
+        const nameB: string = this.getProjectName(b).toLowerCase();
+
+        if (!nameA && !nameB) {
+          return 0;
+        }
+
+        if (!nameA) {
+          return 1;
+        }
+
+        if (!nameB) {
+          return -1;
+        }
+
+        return nameA.localeCompare(nameB);
+      },
+    );
+  }
+
+  private static addMembershipToRow(
+    row: UserProjectMembership,
+    teamMember: TeamMember,
+    teamKeys: Set<string>,
+  ): void {
+    if (teamMember.hasAcceptedInvitation) {
+      row.hasAcceptedInvitation = true;
+    } else {
+      row.pendingTeamCount = row.pendingTeamCount + 1;
+    }
+
+    /*
+     * A later membership can carry the joined project when the first one did
+     * not (different selects, or a nullified relation), so fill in whatever is
+     * still missing rather than trusting the first membership seen.
+     */
+    if (!row.project && teamMember.project) {
+      row.project = teamMember.project;
+    }
+
+    if (!row.projectId && teamMember.projectId) {
+      row.projectId = teamMember.projectId;
+    }
+
+    const membershipId: string = teamMember._id?.toString() || "";
+
+    if (membershipId) {
+      row.teamMemberIds.push(membershipId);
+    }
+
+    const createdAt: Date | undefined = teamMember.createdAt;
+
+    if (createdAt && (!row.joinedAt || createdAt < row.joinedAt)) {
+      row.joinedAt = createdAt;
+    }
+
+    const team: Team | undefined = teamMember.team;
+
+    if (!team) {
+      return;
+    }
+
+    const teamKey: string =
+      teamMember.teamId?.toString() ||
+      team._id?.toString() ||
+      team.name?.toString() ||
+      "";
+
+    if (!teamKey || teamKeys.has(teamKey)) {
+      return;
+    }
+
+    teamKeys.add(teamKey);
+    row.teams.push(team);
+  }
+
+  private static finalizeRow(row: UserProjectMembership): void {
+    row.teams.sort((a: Team, b: Team) => {
+      return (a.name?.toString() || "")
+        .toLowerCase()
+        .localeCompare((b.name?.toString() || "").toLowerCase());
+    });
+
+    if (row.teamMemberIds.length > 0) {
+      row.id = [...row.teamMemberIds].sort()[0]!;
+    }
+  }
+}

package/Utils/Telemetry/SavedViewTimeRange.ts

@@ -0,0 +1,114 @@
+import InBetween from "../../Types/BaseDatabase/InBetween";
+import { TelemetrySavedViewTimeRange } from "../../Types/Telemetry/TelemetrySavedViewState";
+import RangeStartAndEndDateTime from "../../Types/Time/RangeStartAndEndDateTime";
+import TimeRange from "../../Types/Time/TimeRange";
+
+/*
+ * Saved views (logs, metrics, traces) must remember the time *selection*, not
+ * the window that selection happened to resolve to when the view was saved.
+ * "Past 1 Hour" saved today has to still mean the last hour next week, so only
+ * a Custom range carries absolute timestamps; every rolling range is stored as
+ * its token alone and re-resolved against the clock each time it is applied.
+ */
+
+export const DEFAULT_SAVED_VIEW_TIME_RANGE: TimeRange = TimeRange.PAST_ONE_HOUR;
+
+export function serializeSavedViewTimeRange(
+  timeRange: RangeStartAndEndDateTime,
+): TelemetrySavedViewTimeRange {
+  const serialized: TelemetrySavedViewTimeRange = { range: timeRange.range };
+
+  if (timeRange.range === TimeRange.CUSTOM && timeRange.startAndEndDate) {
+    serialized.startValue = toIsoString(timeRange.startAndEndDate.startValue);
+    serialized.endValue = toIsoString(timeRange.startAndEndDate.endValue);
+  }
+
+  return serialized;
+}
+
+/*
+ * Read a stored time selection, or undefined when there is nothing usable
+ * there. The input is whatever came back out of a JSON column, so nothing
+ * about its shape is guaranteed. Callers that have another source to fall
+ * back on (e.g. a legacy absolute window) use this; callers that do not use
+ * deserializeSavedViewTimeRange below, which substitutes the default.
+ */
+export function readSavedViewTimeRange(
+  saved: TelemetrySavedViewTimeRange | unknown,
+): RangeStartAndEndDateTime | undefined {
+  if (!saved || typeof saved !== "object") {
+    return undefined;
+  }
+
+  const rawRange: unknown = (saved as Record<string, unknown>)["range"];
+
+  if (typeof rawRange !== "string") {
+    return undefined;
+  }
+
+  const knownRanges: Array<string> = Object.values(TimeRange);
+
+  if (!knownRanges.includes(rawRange)) {
+    return undefined;
+  }
+
+  const range: TimeRange = rawRange as TimeRange;
+
+  if (range !== TimeRange.CUSTOM) {
+    return { range: range };
+  }
+
+  const start: Date | null = toDate(
+    (saved as Record<string, unknown>)["startValue"],
+  );
+  const end: Date | null = toDate(
+    (saved as Record<string, unknown>)["endValue"],
+  );
+
+  if (!start || !end) {
+    // A Custom range without a usable window says nothing about when to look.
+    return undefined;
+  }
+
+  return {
+    range: TimeRange.CUSTOM,
+    startAndEndDate: new InBetween<Date>(start, end),
+  };
+}
+
+/*
+ * Rebuild a RangeStartAndEndDateTime from saved state. Unknown or malformed
+ * values fall back to the default (past one hour) rather than throwing or
+ * producing a nonsensical window.
+ */
+export function deserializeSavedViewTimeRange(
+  saved: TelemetrySavedViewTimeRange | unknown,
+): RangeStartAndEndDateTime {
+  return (
+    readSavedViewTimeRange(saved) || { range: DEFAULT_SAVED_VIEW_TIME_RANGE }
+  );
+}
+
+function toIsoString(value: Date | string): string {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  // Dates round-tripped through JSON come back as strings.
+  const parsed: Date = new Date(value);
+  return isNaN(parsed.getTime()) ? String(value) : parsed.toISOString();
+}
+
+function toDate(value: unknown): Date | null {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? null : value;
+  }
+
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+
+  const parsed: Date = new Date(value);
+
+  return isNaN(parsed.getTime()) ? null : parsed;
+}