@oneuptime/common 14.0.7 → 14.0.8

package/Server/Services/IncidentStateTimelineService.ts

@@ -34,6 +34,7 @@ import AIIncidentPostmortemRunner from "../Utils/AI/SRE/IncidentPostmortemRunner
 import InvestigationGrader from "../Utils/AI/SRE/InvestigationGrader";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import SubscriberNotificationResendAccess from "../Utils/StatusPage/SubscriberNotificationResendAccess";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
@@ -748,6 +749,18 @@ ${createdItem.rootCause}`,
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<IncidentStateTimeline>,
   ): Promise<OnUpdate<IncidentStateTimeline>> {
+    /*
+     * Retry - a user's Pending - over a state change notification that is
+     * being sent would let a second run send it alongside, or be overwritten
+     * when the send settles (SubscriberNotificationResendAccess).
+     */
+    await SubscriberNotificationResendAccess.assertNotQueuedWhileBeingSent({
+      modelType: IncidentStateTimeline,
+      service: this,
+      updateBy: updateBy,
+      statusColumns: ["subscriberNotificationStatus"],
+    });
+
     const incidentIds: Array<ObjectID> =
       await this.getIncidentIdsForTimelineQuery(updateBy);
 

package/Server/Services/IncidentTemplateService.ts

@@ -10,6 +10,7 @@ import LabelService from "./LabelService";
 import MonitorService from "./MonitorService";
 import MonitorStatusService from "./MonitorStatusService";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import StatusPageService from "./StatusPageService";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import Dictionary from "../../Types/Dictionary";
@@ -28,6 +29,8 @@ import Query from "../Types/Database/Query";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
 import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
+import StatusPageReadAccess from "../Utils/StatusPage/StatusPageReadAccess";
+import IncidentScopeAddedPagesNotification from "../../Types/StatusPage/IncidentScopeAddedPagesNotification";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -52,6 +55,12 @@ export class Service extends DatabaseService<Model> {
     const projectId: ObjectID | undefined =
       createBy.props.tenantId || createBy.data.projectId;
 
+    // Derived from the list, whatever the caller sent (see the column).
+    createBy.data.isScopedToStatusPages =
+      IncidentScopeAddedPagesNotification.normalizeStatusPageIds(
+        createBy.data.statusPages,
+      ).length > 0;
+
     await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
       projectId: projectId,
       subject: "incident template",
@@ -64,6 +73,19 @@ export class Service extends DatabaseService<Model> {
       ],
     });
 
+    /*
+     * A template's status pages are picked for everyone who declares from
+     * it, so picking them needs the same read access as picking an
+     * incident's (see StatusPageReadAccess).
+     */
+    await StatusPageReadAccess.assertCallerCanPickStatusPages({
+      statusPageIds: IncidentScopeAddedPagesNotification.normalizeStatusPageIds(
+        createBy.data.statusPages,
+      ),
+      props: createBy.props,
+      subject: "incident template",
+    });
+
     return { createBy, carryForward: null };
   }
 
@@ -71,6 +93,22 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
+    /*
+     * The scope flag follows a write to the list and nothing else: a client
+     * value is dropped, and deleting the template's pages (join rows
+     * cascading away) never clears it.
+     */
+    const data: Dictionary<unknown> = updateBy.data as Dictionary<unknown>;
+
+    delete data["isScopedToStatusPages"];
+
+    if (data["statusPages"] !== undefined) {
+      data["isScopedToStatusPages"] =
+        IncidentScopeAddedPagesNotification.normalizeStatusPageIds(
+          data["statusPages"],
+        ).length > 0;
+    }
+
     const references: Array<ProjectScopedReference> =
       this.getProjectScopedReferences(updateBy.data);
 
@@ -131,9 +169,75 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    // Once the pages are known to be the project's.
+    await this.assertCallerCanReadAddedStatusPages(updateBy);
+
     return { updateBy, carryForward: null };
   }
 
+  /*
+   * The status pages an update adds to a template must be pages the caller
+   * can read (see StatusPageReadAccess). Pages the template already holds are
+   * not checked, so saving a template limited to a page the editor cannot
+   * see does not fail. The templates are read as root, limited to the
+   * caller's project: the update's own tenant filter is only added after
+   * this hook.
+   */
+  private async assertCallerCanReadAddedStatusPages(
+    updateBy: UpdateBy<Model>,
+  ): Promise<void> {
+    const requested: unknown = (updateBy.data as Dictionary<unknown>)[
+      "statusPages"
+    ];
+
+    if (updateBy.props.isRoot || requested === undefined) {
+      return;
+    }
+
+    const requestedIds: Array<string> =
+      IncidentScopeAddedPagesNotification.normalizeStatusPageIds(requested);
+
+    if (requestedIds.length === 0) {
+      return;
+    }
+
+    const templates: Array<Model> = await this.findBy({
+      query: updateBy.props.tenantId
+        ? { ...updateBy.query, projectId: updateBy.props.tenantId }
+        : updateBy.query,
+      select: {
+        _id: true,
+        statusPages: {
+          _id: true,
+        },
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const addedIds: Array<string> = [];
+
+    for (const template of templates) {
+      for (const id of IncidentScopeAddedPagesNotification.getScopeChange({
+        before: template.statusPages,
+        after: requestedIds,
+      }).addedStatusPageIds) {
+        if (!addedIds.includes(id)) {
+          addedIds.push(id);
+        }
+      }
+    }
+
+    await StatusPageReadAccess.assertCallerCanPickStatusPages({
+      statusPageIds: addedIds,
+      props: updateBy.props,
+      subject: "incident template",
+    });
+  }
+
   /*
    * The many-to-many lists whose ids must belong to the template's project.
    * Built per call rather than at module load: these services sit in an
@@ -157,6 +261,11 @@ export class Service extends DatabaseService<Model> {
         modelName: "On-Call Policy",
         service: OnCallDutyPolicyService,
       },
+      {
+        column: "statusPages",
+        modelName: "Status Page",
+        service: StatusPageService,
+      },
       ...getAffectedResourceRelations(this.getModel()),
     ];
   }

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -19,6 +19,7 @@ import Query from "../Types/Database/Query";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
+import SubscriberNotificationResendAccess from "../Utils/StatusPage/SubscriberNotificationResendAccess";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -122,11 +123,24 @@ export class Service extends DatabaseService<Model> {
    * An edit tells subscribers nothing unless the editor asked for it on this
    * edit (see SubscriberUpdateNotification). When they did, queue the update
    * notification; the ScheduledMaintenancePublicNote worker job sends it.
+   *
+   * Sending the note's 'posted' notification again - its status written back
+   * to Pending, as the dashboard's Retry does - needs the permission to post
+   * a note that notifies subscribers, and a note whose notification can go
+   * out again (see SubscriberNotificationResendAccess). So does telling
+   * subscribers about an edit, which is also refused while that update
+   * notification is being sent.
    */
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
+    await SubscriberNotificationResendAccess.assertPublicNoteResendAllowed({
+      modelType: Model,
+      service: this,
+      updateBy: updateBy,
+    });
+
     if (SubscriberUpdateNotification.isRequested(updateBy.miscDataProps)) {
       updateBy.data.subscriberNotificationStatusOnNoteUpdated =
         StatusPageSubscriberNotificationStatus.Pending;
@@ -134,6 +148,20 @@ export class Service extends DatabaseService<Model> {
         SubscriberUpdateNotification.queuedMessage;
     }
 
+    /*
+     * Telling subscribers about the edit - asked for above, or written as
+     * Pending directly (the dashboard's Retry of a failed update) - needs
+     * the permission to post a note that notifies subscribers too, and is
+     * refused while the update notification is being sent.
+     */
+    await SubscriberNotificationResendAccess.assertPublicNoteUpdateNotificationAllowed(
+      {
+        modelType: Model,
+        service: this,
+        updateBy: updateBy,
+      },
+    );
+
     return {
       updateBy: updateBy,
       carryForward: null,
@@ -246,8 +274,9 @@ ${(createdItem.note || "") + attachmentsMarkdown}
           {
             scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
             projectId: updatedItem.projectId!,
+            // An edit to a public note is a public note event, not a private one.
             scheduledMaintenanceFeedEventType:
-              ScheduledMaintenanceFeedEventType.PrivateNote,
+              ScheduledMaintenanceFeedEventType.PublicNote,
             displayColor: Blue500,
             userId: userId || undefined,
 

package/Server/Services/ScheduledMaintenanceService.ts

@@ -60,6 +60,7 @@ import SmsService from "../../Server/Services/SmsService";
 import StatusPageResourceService from "../../Server/Services/StatusPageResourceService";
 import StatusPageService from "../../Server/Services/StatusPageService";
 import StatusPageSubscriberService from "../../Server/Services/StatusPageSubscriberService";
+import StatusPageSubscriberUnsubscribe from "../../Types/StatusPage/StatusPageSubscriberUnsubscribe";
 import QueryHelper from "../../Server/Types/Database/QueryHelper";
 import Markdown, { MarkdownContentType } from "../../Server/Types/Markdown";
 import logger, { LogAttributes } from "../../Server/Utils/Logger";
@@ -90,6 +91,8 @@ import ProjectService from "./ProjectService";
 import StatusPageSubscriberNotificationTemplateService, {
   Service as StatusPageSubscriberNotificationTemplateServiceClass,
 } from "./StatusPageSubscriberNotificationTemplateService";
+import StatusPageResourceUtil from "../Utils/StatusPageResource";
+import SafeHtml from "../../Types/SafeHtml";
 import StatusPageSubscriberNotificationTemplate from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
 import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
 import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
@@ -208,12 +211,20 @@ export class Service extends DatabaseService<Model> {
 
         // Send email to Email subscribers.
 
+        /*
+         * The resources are read without their groups, so both forms are the
+         * names joined by commas. The HTML one, for email bodies, has every
+         * name escaped; SMS, Slack, subjects and webhooks get the names as
+         * written.
+         */
         const resourcesAffected: string =
-          statusPageToResources[statuspage._id!]
-            ?.map((r: StatusPageResource) => {
-              return r.displayName;
-            })
-            .join(", ") || "";
+          StatusPageResourceUtil.getResourcesGroupedByGroupNameAsPlainText(
+            statusPageToResources[statuspage._id!] || [],
+          );
+        const resourcesAffectedHtml: string =
+          StatusPageResourceUtil.getResourcesGroupedByGroupName(
+            statusPageToResources[statuspage._id!] || [],
+          );
 
         // Fetch custom templates for each notification method
         const [
@@ -270,7 +281,7 @@ export class Service extends DatabaseService<Model> {
           const unsubscribeUrl: string =
             StatusPageSubscriberService.getUnsubscribeLink(
               URL.fromString(statusPageURL),
-              subscriber.id!,
+              subscriber,
             ).toString();
 
           // Template variables for custom templates, as Markdown (Slack)
@@ -298,6 +309,19 @@ export class Service extends DatabaseService<Model> {
           };
 
           if (subscriber.subscriberPhone) {
+            /*
+             * On a public status page the SMS keeps the shorter manage link,
+             * which works there without signing in: an SMS is billed by the
+             * segment (see StatusPageSubscriberUnsubscribe.buildSmsLink).
+             */
+            const smsUnsubscribeUrl: string =
+              StatusPageSubscriberUnsubscribe.buildSmsLink({
+                isPublicStatusPage: statuspage.isPublicStatusPage,
+                statusPageUrl: statusPageURL,
+                subscriberId: subscriber.id!,
+                unsubscribeUrl: unsubscribeUrl,
+              });
+
             let smsMessage: string;
 
             if (
@@ -309,11 +333,14 @@ export class Service extends DatabaseService<Model> {
               smsMessage =
                 StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
                   smsTemplate.templateBody,
-                  plainTextTemplateVariables,
+                  {
+                    ...plainTextTemplateVariables,
+                    unsubscribeUrl: smsUnsubscribeUrl,
+                  },
                 );
             } else {
               // Use default template
-              smsMessage = `Scheduled Maintenance: ${event.title || ""} on ${statusPageName}.${resourcesAffected ? ` Impact: ${resourcesAffected}.` : ""} Details: ${scheduledEventDetailsUrl}. Unsub: ${unsubscribeUrl}`;
+              smsMessage = `Scheduled Maintenance: ${event.title || ""} on ${statusPageName}.${resourcesAffected ? ` Impact: ${resourcesAffected}.` : ""} Details: ${scheduledEventDetailsUrl}. Unsub: ${smsUnsubscribeUrl}`;
             }
 
             const sms: SMS = {
@@ -408,7 +435,20 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
             const statusPageIdString: string | null =
               statuspage.id?.toString() || statuspage._id?.toString() || null;
 
-            // Prepare email variables
+            const scheduledAtHtml: string =
+              OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
+                date: event.startsAt!,
+                timezones: statuspage.subscriberTimezones || [],
+                use12HourFormat: true,
+              });
+
+            /*
+             * The default template's variables. resourcesAffected,
+             * scheduledAt and eventDescription are HTML (the template puts
+             * them in its raw-HTML slot); the footer is HTML the status
+             * page's admins wrote, as they write the template. Everything
+             * else is plain text, which the template escapes.
+             */
             const emailVars: Record<string, string> = {
               statusPageName: statusPageName,
               statusPageUrl: statusPageURL,
@@ -425,13 +465,8 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                 : "false",
               subscriberEmailNotificationFooterText:
                 statuspage.subscriberEmailNotificationFooterText || "",
-              resourcesAffected: resourcesAffected,
-              scheduledAt:
-                OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
-                  date: event.startsAt!,
-                  timezones: statuspage.subscriberTimezones || [],
-                  use12HourFormat: true,
-                }),
+              resourcesAffected: resourcesAffectedHtml,
+              scheduledAt: scheduledAtHtml,
               eventTitle: event.title || "",
               eventDescription: eventDescriptionHtml,
               unsubscribeUrl: unsubscribeUrl,
@@ -448,14 +483,29 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                * is configured. The body is HTML, so the description is too.
                * The subject is plain text, including the email-only
                * variables that are HTML in the body.
+               *
+               * In the body, the plain values are escaped
+               * (compileEmailBodyTemplate) and only the ones wrapped in
+               * SafeHtml below go in as HTML.
                */
               const customEmailBody: string =
-                StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
+                StatusPageSubscriberNotificationTemplateServiceClass.compileEmailBodyTemplate(
                   emailTemplate.templateBody,
                   {
                     ...templateVariables,
                     ...emailVars,
-                    scheduledMaintenanceDescription: eventDescriptionHtml,
+                    resourcesAffected: SafeHtml.fromTrustedHtml(
+                      resourcesAffectedHtml,
+                    ),
+                    scheduledAt: SafeHtml.fromTrustedHtml(scheduledAtHtml),
+                    eventDescription:
+                      SafeHtml.fromTrustedHtml(eventDescriptionHtml),
+                    scheduledMaintenanceDescription:
+                      SafeHtml.fromTrustedHtml(eventDescriptionHtml),
+                    subscriberEmailNotificationFooterText:
+                      SafeHtml.fromTrustedHtml(
+                        emailVars["subscriberEmailNotificationFooterText"],
+                      ),
                   },
                 );
               const customEmailSubject: string = emailTemplate.emailSubject

package/Server/Services/SmsService.ts

@@ -41,6 +41,15 @@ export class SmsService extends BaseService {
       onCallDutyPolicyExecutionLogTimelineId?: ObjectID | undefined;
       onCallScheduleId?: ObjectID | undefined;
       teamId?: ObjectID | undefined;
+      /*
+       * Answer with an error, not success, when the Notification service
+       * deliberately does not send the SMS: the project has SMS notifications
+       * turned off, or too little SMS balance. The status page subscriber
+       * sends that count what they delivered pass it
+       * (SubscriberNotificationDeliveryRecord), so such an SMS counts as
+       * failed rather than sent.
+       */
+      failIfNotSent?: boolean | undefined;
     },
   ): Promise<HTTPResponse<EmptyResponseData>> {
     const body: JSONObject = {
@@ -74,6 +83,7 @@ export class SmsService extends BaseService {
         options.onCallDutyPolicyExecutionLogTimelineId?.toString(),
       onCallScheduleId: options.onCallScheduleId?.toString(),
       teamId: options.teamId?.toString(),
+      ...(options.failIfNotSent ? { failIfNotSent: true } : {}),
     };
 
     return await API.post<EmptyResponseData>({

package/Server/Services/StatusPageService.ts

@@ -63,7 +63,8 @@ import MonitorGroupResource from "../../Models/DatabaseModels/MonitorGroupResour
 import MonitorGroupService from "./MonitorGroupService";
 import QueryHelper from "../Types/Database/QueryHelper";
 import OneUptimeDate from "../../Types/Date";
-import IncidentService from "./IncidentService";
+import IncidentStatusPageScope from "../Utils/StatusPage/IncidentStatusPageScope";
+import Select from "../Types/Database/Select";
 import MonitorStatusTimeline from "../../Models/DatabaseModels/MonitorStatusTimeline";
 import MonitorStatusTimelineService, {
   MergedDowntimeTotals,
@@ -122,6 +123,17 @@ export const STATUS_PAGE_SSO_REQUIREMENT_COLUMNS: ReadonlyArray<string> = [
   "requireSsoForLogin",
 ];
 
+/*
+ * What a report's incident counts read of the status page: which project's
+ * incidents to count, and whether the page only shows incidents limited to
+ * it (IncidentStatusPageScope decides from that which incidents count).
+ */
+export const INCIDENT_COUNT_STATUS_PAGE_SELECT: Select<StatusPage> = {
+  _id: true,
+  projectId: true,
+  onlyShowScopedIncidents: true,
+};
+
 export class Service extends DatabaseService<StatusPage> {
   /*
    * Caches the resolved status page URL per statusPageId. `getStatusPageURL`
@@ -1393,7 +1405,7 @@ export class Service extends DatabaseService<StatusPage> {
         const unsubscribeUrl: string =
           StatusPageSubscriberService.getUnsubscribeLink(
             URL.fromString(statusPageURL),
-            subscriber.id!,
+            subscriber,
           ).toString();
 
         if (subscriber.subscriberEmail) {
@@ -1432,6 +1444,8 @@ export class Service extends DatabaseService<StatusPage> {
       },
       select: {
         downtimeMonitorStatuses: true,
+        // What the incident counts below are scoped by.
+        ...INCIDENT_COUNT_STATUS_PAGE_SELECT,
       },
     });
 
@@ -1499,7 +1513,7 @@ export class Service extends DatabaseService<StatusPage> {
     }
 
     const incidentCount: number = await this.getIncidentCountOnStatusPage({
-      statusPageId: data.statusPageId,
+      statusPage: statusPage,
       startDate: startDate,
       endDate: endDate,
     });
@@ -1661,6 +1675,7 @@ export class Service extends DatabaseService<StatusPage> {
         reportItem: {
           resourceName: resource.displayName || "",
           totalIncidentCount: await this.getIncidentCountByMonitorIds({
+            statusPage: statusPage,
             monitorIds: monitorIdsForThisResource,
             startDate: startDate,
             endDate: endDate,
@@ -1710,6 +1725,7 @@ export class Service extends DatabaseService<StatusPage> {
 
     const groupMetricsByGroupId: Dictionary<StatusPageReportGroupMetrics> =
       await this.getReportGroupMetrics({
+        statusPage: statusPage,
         statusPageGroups: statusPageGroups,
         entries: entries,
         monitorIdsByResourceIndex: monitorIdsByResourceIndex,
@@ -1817,6 +1833,11 @@ export class Service extends DatabaseService<StatusPage> {
    */
   @CaptureSpan()
   public async getReportGroupMetrics(data: {
+    /*
+     * The status page the report is for, which the incident counts are
+     * scoped by: loaded with INCIDENT_COUNT_STATUS_PAGE_SELECT.
+     */
+    statusPage: StatusPage;
     statusPageGroups: Array<StatusPageGroup>;
     entries: Array<StatusPageReportResourceEntry>;
     monitorIdsByResourceIndex: Array<Array<ObjectID>>;
@@ -1913,6 +1934,7 @@ export class Service extends DatabaseService<StatusPage> {
         totalIncidentCount =
           monitorIds.length > 0
             ? await this.getIncidentCountByMonitorIds({
+                statusPage: data.statusPage,
                 monitorIds: monitorIds,
                 startDate: data.reportWindow.startDate,
                 endDate: data.reportWindow.endDate,
@@ -1963,13 +1985,41 @@ export class Service extends DatabaseService<StatusPage> {
     });
   }
 
+  /*
+   * How many incidents the status page shows on these monitors, created in
+   * the window: the report's count for a resource, a group or the page.
+   *
+   * It counts what the page shows, through IncidentStatusPageScope - an
+   * incident limited to other status pages is not counted, nor is an
+   * unlimited one on a page that only shows incidents limited to it - and
+   * only the project's incidents visible on status pages. (Before the scope,
+   * this counted every incident on the monitors, hidden ones and all.)
+   *
+   * The status page must be loaded with INCIDENT_COUNT_STATUS_PAGE_SELECT. It
+   * is passed in rather than read here because a report counts once for each
+   * resource and group.
+   */
   @CaptureSpan()
   public async getIncidentCountByMonitorIds(data: {
+    statusPage: StatusPage;
     monitorIds: Array<ObjectID>;
     startDate: Date;
     endDate: Date;
   }): Promise<number> {
-    const incidentCount: PositiveNumber = await IncidentService.countBy({
+    // No monitor, so no incident on one to count.
+    if (data.monitorIds.length === 0) {
+      return 0;
+    }
+
+    if (!data.statusPage.projectId) {
+      throw new BadDataException(
+        "Cannot count the incidents on a status page without its project.",
+      );
+    }
+
+    return await IncidentStatusPageScope.countIncidentsForStatusPage({
+      statusPage: data.statusPage,
+      projectId: data.statusPage.projectId,
       query: {
         monitors: data.monitorIds as any,
         createdAt: QueryHelper.inBetween(data.startDate, data.endDate),
@@ -1978,24 +2028,31 @@ export class Service extends DatabaseService<StatusPage> {
         isRoot: true,
       },
     });
-
-    return incidentCount.toNumber();
   }
 
+  // How many incidents the status page shows, over all of its monitors.
   @CaptureSpan()
   public async getIncidentCountOnStatusPage(data: {
-    statusPageId: ObjectID;
+    // Loaded with INCIDENT_COUNT_STATUS_PAGE_SELECT.
+    statusPage: StatusPage;
     startDate: Date;
     endDate: Date;
   }): Promise<number> {
+    if (!data.statusPage.id) {
+      throw new BadDataException(
+        "Cannot count the incidents on a status page without its id.",
+      );
+    }
+
     const monitorsOnStatusPage: {
       monitorsOnStatusPage: Array<ObjectID>;
       monitorsInGroup: Dictionary<Array<ObjectID>>;
     } = await this.getMonitorIdsOnStatusPage({
-      statusPageId: data.statusPageId,
+      statusPageId: data.statusPage.id,
     });
 
     return this.getIncidentCountByMonitorIds({
+      statusPage: data.statusPage,
       monitorIds: monitorsOnStatusPage.monitorsOnStatusPage,
       startDate: data.startDate,
       endDate: data.endDate,