@oneuptime/common 14.0.13 → 14.0.14

package/Server/Utils/ScrubRuleValidation.ts

@@ -0,0 +1,248 @@
+import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import {
+  checkScrubRuleCustomRegex,
+  SCRUB_RULE_CUSTOM_PATTERN_TYPE,
+  SCRUB_RULE_SENSITIVE_KEYS_PATTERN_TYPE,
+  ScrubRuleCustomRegexCheck,
+  ScrubRuleCustomRegexProblem,
+} from "../../Types/Telemetry/ScrubRule";
+import FindBy from "../Types/Database/FindBy";
+import Select from "../Types/Database/Select";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { isSqlExpressionValue } from "./DropFilterValidation";
+
+/*
+ * Save-time validation for log and trace scrub rules: a rule is refused
+ * unless ingest can scrub with it.
+ *
+ * A scrub rule exists to keep personal data out of storage, and three ways of
+ * saving one made it scrub nothing while it looked active in the rules table:
+ *
+ *   - a Custom Regex rule with an empty pattern, or one that does not
+ *     compile: ingest skips it (LogScrubRuleService / TraceScrubRuleService
+ *     getRegexForPattern returns null);
+ *   - a pattern type ingest does not know ("Email" for "email"): skipped the
+ *     same way;
+ *   - a fields-to-scrub value ingest does not know: the rule matches, but
+ *     scrubs none of the record's fields. (A sensitive-keys rule is the
+ *     exception: ingest runs it on attributes whatever its fields say, so
+ *     its fields are not judged.)
+ *
+ * The user believed the data was masked when it was not. The API boundary is
+ * the only place a person is there to read why, so it is refused there, on
+ * create and on an update that touches one of these columns (judged on the
+ * merged row, as the drop filters' check is). A custom pattern that matches
+ * empty text is refused too: a global replace would put the rule's
+ * replacement between every character of every record.
+ *
+ * Rules saved before this check are left exactly as they are - they keep
+ * scrubbing nothing until someone edits them, and the rules tables flag them
+ * (Types/Telemetry/ScrubRule doesScrubRuleScrubNothing). An update that does
+ * not touch these columns (a rename, switching the rule off, a drag to
+ * another place in the list) is not held up by them. An unknown scrub action
+ * is not refused: ingest redacts with it, which is safe.
+ */
+
+export interface ScrubRuleCandidate {
+  patternType?: unknown;
+  customRegex?: unknown;
+  fieldsToScrub?: unknown;
+}
+
+export interface ScrubRuleValidationOptions {
+  // "logs" or "spans", so the message reads like the page the user is on.
+  recordNoun: string;
+  // The pattern types ingest knows for these records.
+  patternTypes: ReadonlyArray<string>;
+  // The fields-to-scrub values ingest knows for these records.
+  fieldsToScrub: ReadonlyArray<string>;
+}
+
+// The columns that decide whether a rule scrubs anything.
+export const SCRUB_RULE_VALIDATED_COLUMNS: ReadonlyArray<
+  keyof ScrubRuleCandidate
+> = ["patternType", "customRegex", "fieldsToScrub"];
+
+export function getScrubRuleCustomRegexRefusal(
+  check: ScrubRuleCustomRegexCheck,
+  options: ScrubRuleValidationOptions,
+): string {
+  switch (check.problem) {
+    case ScrubRuleCustomRegexProblem.Missing:
+      return "A Custom Regex rule needs a regular expression to match. Without one it scrubs nothing. Enter the pattern, or pick another pattern type.";
+    case ScrubRuleCustomRegexProblem.Invalid:
+      return `The custom pattern is not a valid regular expression (${check.reason || "it does not compile"}), so the rule would scrub nothing. Fix the pattern, or pick another pattern type.`;
+    case ScrubRuleCustomRegexProblem.MatchesEmptyText:
+    default:
+      return `The custom pattern matches empty text, so it would put its replacement between every character of your ${options.recordNoun}. Make it match at least one character.`;
+  }
+}
+
+export function validateScrubRulePatternType(
+  patternType: unknown,
+  options: ScrubRuleValidationOptions,
+): void {
+  if (typeof patternType !== "string" || patternType.trim().length === 0) {
+    throw new BadDataException(
+      `Pattern type is required: one of ${options.patternTypes.join(", ")}.`,
+    );
+  }
+
+  if (!options.patternTypes.includes(patternType)) {
+    throw new BadDataException(
+      `Pattern type "${patternType}" is not one ingest can scrub with, so the rule would scrub nothing. Use one of ${options.patternTypes.join(", ")}.`,
+    );
+  }
+}
+
+export function validateScrubRuleFieldsToScrub(
+  fieldsToScrub: unknown,
+  options: ScrubRuleValidationOptions,
+): void {
+  // Left out of a create, the column's default applies: every field.
+  if (fieldsToScrub === undefined || fieldsToScrub === null) {
+    return;
+  }
+
+  if (
+    typeof fieldsToScrub !== "string" ||
+    !options.fieldsToScrub.includes(fieldsToScrub)
+  ) {
+    throw new BadDataException(
+      `Fields to scrub "${String(fieldsToScrub)}" is not one ingest knows, so the rule would scrub none of your ${options.recordNoun}' fields. Use one of ${options.fieldsToScrub.join(", ")}.`,
+    );
+  }
+}
+
+/*
+ * Validate a fully resolved rule. Callers building this from an update must
+ * merge the incoming partial over the stored row first, so a request that
+ * switches a rule to Custom Regex without sending a pattern is still caught
+ * (validateScrubRuleUpdate does).
+ */
+export function validateScrubRule(
+  candidate: ScrubRuleCandidate,
+  options: ScrubRuleValidationOptions,
+): void {
+  validateScrubRulePatternType(candidate.patternType, options);
+
+  /*
+   * A sensitive-keys rule reads attribute keys, so ingest runs it on
+   * attributes whatever its fields say - and the form does not ask for them.
+   */
+  if (candidate.patternType !== SCRUB_RULE_SENSITIVE_KEYS_PATTERN_TYPE) {
+    validateScrubRuleFieldsToScrub(candidate.fieldsToScrub, options);
+  }
+
+  if (candidate.patternType !== SCRUB_RULE_CUSTOM_PATTERN_TYPE) {
+    return;
+  }
+
+  const check: ScrubRuleCustomRegexCheck | null = checkScrubRuleCustomRegex(
+    candidate.customRegex,
+  );
+
+  if (check) {
+    throw new BadDataException(getScrubRuleCustomRegexRefusal(check, options));
+  }
+}
+
+// A rule as a create hands it to the service's onBeforeCreate.
+export function validateScrubRuleCreate(
+  data: ScrubRuleCandidate,
+  options: ScrubRuleValidationOptions,
+): void {
+  validateScrubRule(
+    {
+      patternType: data.patternType,
+      customRegex: data.customRegex,
+      fieldsToScrub: data.fieldsToScrub,
+    },
+    options,
+  );
+}
+
+/*
+ * An update: every row it matches, with the incoming values laid over what
+ * is stored.
+ *
+ * The services call this from onBeforeUpdateUniqueCheck, which runs once the
+ * caller has passed the permission checks, with the query already narrowed to
+ * the rows they may write - so the rows read here, as root, are never another
+ * project's, and a refusal never tells a caller about a rule they may not
+ * see. The rows are read only when the update touches a column that decides
+ * whether the rule scrubs anything, so renaming a rule, switching it off or
+ * dragging it to another place in the list costs no read - and is never held
+ * up by a rule that was saved broken before this check existed.
+ */
+export async function validateScrubRuleUpdate<
+  TModel extends BaseModel & ScrubRuleCandidate,
+>(data: {
+  updateBy: UpdateBy<TModel>;
+  // The service's own findBy.
+  findBy: (findBy: FindBy<TModel>) => Promise<Array<TModel>>;
+  options: ScrubRuleValidationOptions;
+}): Promise<void> {
+  const incoming: ScrubRuleCandidate = {
+    patternType: (data.updateBy.data as ScrubRuleCandidate).patternType,
+    customRegex: (data.updateBy.data as ScrubRuleCandidate).customRegex,
+    fieldsToScrub: (data.updateBy.data as ScrubRuleCandidate).fieldsToScrub,
+  };
+
+  const touchesValidatedColumns: boolean = SCRUB_RULE_VALIDATED_COLUMNS.some(
+    (column: keyof ScrubRuleCandidate): boolean => {
+      return incoming[column] !== undefined;
+    },
+  );
+
+  if (!touchesValidatedColumns) {
+    return;
+  }
+
+  // A raw SQL expression cannot be judged here. See isSqlExpressionValue.
+  if (
+    SCRUB_RULE_VALIDATED_COLUMNS.some(
+      (column: keyof ScrubRuleCandidate): boolean => {
+        return isSqlExpressionValue(incoming[column]);
+      },
+    )
+  ) {
+    return;
+  }
+
+  const storedRows: Array<TModel> = await data.findBy({
+    query: data.updateBy.query,
+    skip: 0,
+    limit: LIMIT_MAX,
+    select: {
+      _id: true,
+      patternType: true,
+      customRegex: true,
+      fieldsToScrub: true,
+    } as Select<TModel>,
+    props: {
+      isRoot: true,
+    },
+  });
+
+  for (const stored of storedRows) {
+    const merged: ScrubRuleCandidate = {
+      patternType:
+        incoming.patternType !== undefined
+          ? incoming.patternType
+          : stored.patternType,
+      customRegex:
+        incoming.customRegex !== undefined
+          ? incoming.customRegex
+          : stored.customRegex,
+      fieldsToScrub:
+        incoming.fieldsToScrub !== undefined
+          ? incoming.fieldsToScrub
+          : stored.fieldsToScrub,
+    };
+
+    validateScrubRule(merged, data.options);
+  }
+}

package/Server/Utils/StatusPage/AffectedStatusPageResources.ts

@@ -0,0 +1,138 @@
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import StatusPageResource from "../../../Models/DatabaseModels/StatusPageResource";
+import Dictionary from "../../../Types/Dictionary";
+import ObjectID from "../../../Types/ObjectID";
+import StatusPageResourceService from "../../Services/StatusPageResourceService";
+import Select from "../../Types/Database/Select";
+
+/*
+ * Which of each status page's resources an event on some monitors affects:
+ * what an announcement or a scheduled maintenance event lists as affected,
+ * and so which subscribers hear about it.
+ *
+ * On a status page that lets subscribers choose resources, a subscriber
+ * picks some of the page's resources, and a resource is either one monitor
+ * or a monitor group. StatusPageSubscriberService.shouldSendNotification
+ * tells such a subscriber about an event when it picked one of the
+ * resources the event affects on that page. So a resource is affected when
+ * it is one of the event's monitors, or a monitor group that holds one of
+ * them: the status page shows the event under that group, and someone who
+ * subscribed to the group expects to hear about every monitor in it.
+ *
+ * The resources come from StatusPageResourceService.findByMonitors, the one
+ * lookup from monitors to resources. Incidents and episodes reach it through
+ * IncidentStatusPageScope, which also applies an incident's status page
+ * scope; announcements and scheduled maintenance events - created,
+ * reminders, state changes and public notes - through this. A guard test
+ * (App/Tests/SubscriberNotificationResourceLookups.test.ts) fails on a
+ * sender that looks resources up any other way, such as by monitorId alone,
+ * which misses the monitor groups.
+ */
+export default class AffectedStatusPageResources {
+  /*
+   * The affected resources on the status pages the event is on, keyed by the
+   * page's id as the senders look a page up (statusPage._id). Only those
+   * pages' resources are read. A page that lists none of the monitors has no
+   * entry. An event that names no monitor, or is on no page, affects no
+   * resource, and nothing is looked up.
+   */
+  public static async findForMonitors(data: {
+    monitors?: Array<Monitor> | undefined;
+    monitorIds?: Array<ObjectID> | undefined;
+    // The status pages the event is shown on.
+    statusPages: Array<StatusPage>;
+    select: Select<StatusPageResource>;
+  }): Promise<Dictionary<Array<StatusPageResource>>> {
+    const monitorIds: Array<ObjectID> = this.distinctIds([
+      ...(data.monitorIds || []),
+      ...(data.monitors || []).map((monitor: Monitor): string | undefined => {
+        return monitor._id;
+      }),
+    ]);
+
+    const statusPageIds: Array<ObjectID> = this.distinctIds(
+      data.statusPages.map((statusPage: StatusPage): string | undefined => {
+        return statusPage._id;
+      }),
+    );
+
+    if (monitorIds.length === 0 || statusPageIds.length === 0) {
+      return {};
+    }
+
+    const resources: Array<StatusPageResource> =
+      await StatusPageResourceService.findByMonitors({
+        monitorIds: monitorIds,
+        statusPageIds: statusPageIds,
+        select: {
+          ...data.select,
+          // Needed to group by page and to dedupe, whatever the caller asked for.
+          _id: true,
+          statusPageId: true,
+        },
+      });
+
+    return this.groupByStatusPage(resources);
+  }
+
+  /*
+   * The resources keyed by their status page's id, each page's in the order
+   * given and each resource once. A resource without a page is left out.
+   */
+  public static groupByStatusPage(
+    resources: Array<StatusPageResource>,
+  ): Dictionary<Array<StatusPageResource>> {
+    const byStatusPage: Dictionary<Array<StatusPageResource>> = {};
+    const seenResourceIds: Set<string> = new Set();
+
+    for (const resource of resources) {
+      const statusPageId: string | undefined = resource.statusPageId
+        ?.toString()
+        .trim();
+
+      if (!statusPageId) {
+        continue;
+      }
+
+      const resourceId: string | undefined = resource._id?.toString();
+
+      if (resourceId) {
+        if (seenResourceIds.has(resourceId)) {
+          continue;
+        }
+
+        seenResourceIds.add(resourceId);
+      }
+
+      const pageResources: Array<StatusPageResource> =
+        byStatusPage[statusPageId] || [];
+
+      pageResources.push(resource);
+      byStatusPage[statusPageId] = pageResources;
+    }
+
+    return byStatusPage;
+  }
+
+  // The ids, each once, in the order given. A record never saved has none.
+  private static distinctIds(
+    candidates: Array<ObjectID | string | undefined>,
+  ): Array<ObjectID> {
+    const ids: Array<ObjectID> = [];
+    const seen: Set<string> = new Set();
+
+    for (const candidate of candidates) {
+      const id: string = candidate ? candidate.toString().trim() : "";
+
+      if (!id || seen.has(id.toLowerCase())) {
+        continue;
+      }
+
+      seen.add(id.toLowerCase());
+      ids.push(new ObjectID(id));
+    }
+
+    return ids;
+  }
+}

package/Server/Utils/StatusPage/StatusPagesListingMonitorsBuilder.ts

@@ -0,0 +1,294 @@
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import StatusPageResource from "../../../Models/DatabaseModels/StatusPageResource";
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import IncidentScopeAddedPagesNotification from "../../../Types/StatusPage/IncidentScopeAddedPagesNotification";
+import StatusPageEventType from "../../../Types/StatusPage/StatusPageEventType";
+import StatusPagesListingMonitors, {
+  StatusPageListingMonitors,
+  StatusPagesListingMonitorsResult,
+} from "../../../Types/StatusPage/StatusPagesListingMonitors";
+import MonitorService from "../../Services/MonitorService";
+import StatusPageResourceService from "../../Services/StatusPageResourceService";
+import StatusPageService from "../../Services/StatusPageService";
+import QueryHelper from "../../Types/Database/QueryHelper";
+import StatusPageReadAccess from "./StatusPageReadAccess";
+
+/*
+ * Which status pages list some monitors (see
+ * Common/Types/StatusPage/StatusPagesListingMonitors), for
+ * POST /status-page/listing-monitors: the status pages the dashboard
+ * suggests for a scheduled maintenance event or an announcement about those
+ * monitors.
+ *
+ * It only reads, and what the caller learns is bounded by what they may
+ * read:
+ *
+ * - the monitors are read with the caller's own permissions, in the caller's
+ *   project. A monitor they cannot read - another project's, or one outside
+ *   the labels their monitor access is limited to - is left out, as if it
+ *   had not been named, so the answer says nothing about it;
+ * - the status pages listing the rest are found the way the subscriber jobs
+ *   find them (StatusPageResourceService.findByMonitors: listed directly, or
+ *   through a monitor group);
+ * - of those, only the pages the caller can read are named:
+ *   StatusPageReadAccess.getReadableStatusPageIds, the rule that decides
+ *   which pages someone may pick for an incident. Status page access can be
+ *   limited to pages with some labels, and a page outside them is neither
+ *   named nor counted;
+ * - an archived page, and a page that does not show the kind of event asked
+ *   about, are left out: adding the event to them would show nobody
+ *   anything.
+ */
+
+export interface StatusPagesListingMonitorsRequest {
+  projectId: ObjectID;
+  props: DatabaseCommonInteractionProps;
+  monitorIds: Array<ObjectID>;
+  // Left out: every page that lists the monitors, whatever it shows.
+  eventType?: StatusPageEventType | undefined;
+}
+
+export default class StatusPagesListingMonitorsBuilder {
+  /*
+   * The request body: {monitorIds, eventType?}. monitorIds is a list of at
+   * most StatusPagesListingMonitors.maxIdsPerRequest ids; eventType, when
+   * sent, one of StatusPagesListingMonitors.eventTypes.
+   */
+  public static parseRequest(data: {
+    body: unknown;
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): StatusPagesListingMonitorsRequest {
+    const body: JSONObject =
+      data.body && typeof data.body === "object" && !Array.isArray(data.body)
+        ? (data.body as JSONObject)
+        : {};
+
+    const monitorIds: unknown = body["monitorIds"];
+
+    if (!Array.isArray(monitorIds)) {
+      throw new BadDataException("monitorIds must be a list of IDs.");
+    }
+
+    if (monitorIds.length > StatusPagesListingMonitors.maxIdsPerRequest) {
+      throw new BadDataException(
+        `monitorIds can list at most ${StatusPagesListingMonitors.maxIdsPerRequest} IDs.`,
+      );
+    }
+
+    const eventType: unknown = body["eventType"];
+
+    if (
+      eventType !== undefined &&
+      eventType !== null &&
+      !StatusPagesListingMonitors.isEventType(eventType)
+    ) {
+      throw new BadDataException(
+        `eventType must be one of: ${StatusPagesListingMonitors.eventTypes.join(", ")}.`,
+      );
+    }
+
+    return {
+      projectId: data.projectId,
+      props: data.props,
+      monitorIds: monitorIds.map((item: unknown): ObjectID => {
+        return this.parseObjectID(item);
+      }),
+      ...(StatusPagesListingMonitors.isEventType(eventType)
+        ? { eventType: eventType }
+        : {}),
+    };
+  }
+
+  public static async build(
+    request: StatusPagesListingMonitorsRequest,
+  ): Promise<StatusPagesListingMonitorsResult> {
+    const monitorIds: Array<string> = await this.getReadableMonitorIds({
+      projectId: request.projectId,
+      props: request.props,
+      monitorIds: this.normalizeIds(request.monitorIds),
+    });
+
+    if (monitorIds.length === 0) {
+      return { statusPages: [] };
+    }
+
+    const resources: Array<StatusPageResource> =
+      await StatusPageResourceService.findByMonitors({
+        monitorIds: monitorIds.map((id: string): ObjectID => {
+          return new ObjectID(id);
+        }),
+        select: {
+          _id: true,
+          statusPageId: true,
+        },
+      });
+
+    const listingStatusPageIds: Array<string> = this.normalizeIds(
+      resources.map((resource: StatusPageResource): unknown => {
+        return resource.statusPageId;
+      }),
+    );
+
+    if (listingStatusPageIds.length === 0) {
+      return { statusPages: [] };
+    }
+
+    // The caller's own read of the pages: labels and all.
+    const readableStatusPageIds: Array<string> =
+      await StatusPageReadAccess.getReadableStatusPageIds({
+        statusPageIds: listingStatusPageIds,
+        props: request.props,
+      });
+
+    if (readableStatusPageIds.length === 0) {
+      return { statusPages: [] };
+    }
+
+    /*
+     * Read as root, now that the caller has been shown to read these pages:
+     * only their names and the flags that decide whether the event would
+     * show on them. Narrowed to the project either way.
+     */
+    const statusPages: Array<StatusPage> = await StatusPageService.findBy({
+      query: {
+        _id: QueryHelper.any(readableStatusPageIds),
+        projectId: request.projectId,
+      },
+      select: {
+        _id: true,
+        name: true,
+        isArchived: true,
+        showScheduledMaintenanceEventsOnStatusPage: true,
+        showAnnouncementsOnStatusPage: true,
+      },
+      limit: readableStatusPageIds.length,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    /*
+     * A page without a name is named "" - the dashboard calls it what the
+     * reader's language calls an untitled page.
+     */
+    const suggested: Array<StatusPageListingMonitors> = statusPages
+      .filter((statusPage: StatusPage): boolean => {
+        return this.isShowing(statusPage, request.eventType);
+      })
+      .map((statusPage: StatusPage): StatusPageListingMonitors => {
+        return {
+          statusPageId: this.normalizeIds(statusPage._id)[0] || "",
+          name: statusPage.name?.trim() || "",
+        };
+      })
+      .filter((statusPage: StatusPageListingMonitors): boolean => {
+        return Boolean(statusPage.statusPageId);
+      })
+      .sort(StatusPagesListingMonitors.compareByName);
+
+    return { statusPages: suggested };
+  }
+
+  /*
+   * Whether an event of this kind would show on the page: it is not
+   * archived (an archived page is offline, and tells its subscribers
+   * nothing), and it shows that kind of event. A flag that was not loaded
+   * counts as the column's default - on.
+   */
+  public static isShowing(
+    statusPage: StatusPage,
+    eventType: StatusPageEventType | undefined,
+  ): boolean {
+    if (statusPage.isArchived === true) {
+      return false;
+    }
+
+    if (eventType === StatusPageEventType.ScheduledEvent) {
+      return statusPage.showScheduledMaintenanceEventsOnStatusPage !== false;
+    }
+
+    if (eventType === StatusPageEventType.Announcement) {
+      return statusPage.showAnnouncementsOnStatusPage !== false;
+    }
+
+    return true;
+  }
+
+  /*
+   * The monitors, of these, that the caller can read in the project,
+   * lower-cased. A caller with no monitor read access reads none of them.
+   */
+  private static async getReadableMonitorIds(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+    monitorIds: Array<string>;
+  }): Promise<Array<string>> {
+    if (data.monitorIds.length === 0) {
+      return [];
+    }
+
+    try {
+      const monitors: Array<Monitor> = await MonitorService.findBy({
+        query: {
+          _id: QueryHelper.any(data.monitorIds),
+          projectId: data.projectId,
+        },
+        select: {
+          _id: true,
+        },
+        limit: data.monitorIds.length,
+        skip: 0,
+        props: data.props,
+      });
+
+      const readable: Array<string> = this.normalizeIds(monitors);
+
+      // In the order they were named, and only those.
+      return data.monitorIds.filter((id: string): boolean => {
+        return readable.includes(id);
+      });
+    } catch (err) {
+      if (err instanceof NotAuthorizedException) {
+        return [];
+      }
+
+      throw err;
+    }
+  }
+
+  // An id as a string or a serialized ObjectID.
+  private static parseObjectID(value: unknown): ObjectID {
+    let id: string = "";
+
+    if (typeof value === "string") {
+      id = value;
+    } else if (value instanceof ObjectID) {
+      id = value.toString();
+    } else if (value && typeof value === "object") {
+      id = new ObjectID(value as JSONObject).toString();
+    }
+
+    id = id.trim();
+
+    if (!id || !ObjectID.isValidUUID(id)) {
+      throw new BadDataException("monitorIds must be a list of valid IDs.");
+    }
+
+    return new ObjectID(id);
+  }
+
+  /*
+   * Ids in any shape they arrive in - an ObjectID, a string, a model or a
+   * {_id} - lower-cased as the database returns them, without duplicates.
+   */
+  private static normalizeIds(value: unknown): Array<string> {
+    return IncidentScopeAddedPagesNotification.normalizeStatusPageIds(value);
+  }
+}