@oneuptime/common 11.3.20 → 11.3.21

package/Server/API/StatusPageAPI.ts

@@ -1492,171 +1492,242 @@ export default class StatusPageAPI extends BaseAPI<
       },
     );
 
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/overview/:statusPageIdOrDomain`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const statusPageId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
+    /*
+     * Shared handler for the overview endpoint. Registered for both POST
+     * (used by the status page SPA) and GET (machine-readable access for
+     * crawlers / AI agents) so the authentication and authorization path
+     * can never drift between the two methods. It does not read req.body.
+     */
+    const overviewHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const statusPageId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-          await this.checkHasReadAccess({
-            statusPageId: statusPageId,
-            req: req,
+        await this.checkHasReadAccess({
+          statusPageId: statusPageId,
+          req: req,
+        });
+
+        // First fetch the status page to get the configured uptime history days
+        const statusPageForDays: StatusPage | null =
+          await StatusPageService.findOneBy({
+            query: {
+              _id: statusPageId.toString(),
+            },
+            select: {
+              showUptimeHistoryInDays: true,
+            },
+            props: {
+              isRoot: true,
+            },
           });
 
-          // First fetch the status page to get the configured uptime history days
-          const statusPageForDays: StatusPage | null =
-            await StatusPageService.findOneBy({
+        let uptimeHistoryDays: number =
+          statusPageForDays?.showUptimeHistoryInDays || 90;
+
+        if (uptimeHistoryDays > 90) {
+          uptimeHistoryDays = 90;
+        }
+
+        if (uptimeHistoryDays < 1) {
+          uptimeHistoryDays = 1;
+        }
+
+        const startDate: Date = OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
+        const endDate: Date = OneUptimeDate.getCurrentDate();
+
+        const {
+          monitorStatuses,
+          monitorGroupCurrentStatuses,
+          statusPageResources,
+          statusPage,
+          monitorsOnStatusPage,
+          monitorStatusTimelines,
+          statusPageGroups,
+          monitorsInGroup,
+        } = await this.getStatusPageResourcesAndTimelines({
+          statusPageId: statusPageId,
+          startDateForMonitorTimeline: startDate,
+          endDateForMonitorTimeline: endDate,
+        });
+
+        // check if status page has active incident.
+        let activeIncidents: Array<Incident> = [];
+        if (monitorsOnStatusPage.length > 0) {
+          let select: Select<Incident> = {
+            createdAt: true,
+            declaredAt: true,
+            updatedAt: true,
+            title: true,
+            description: true,
+            _id: true,
+            postmortemNote: true,
+            postmortemPostedAt: true,
+            showPostmortemOnStatusPage: true,
+            postmortemAttachments: {
+              _id: true,
+              name: true,
+            },
+            incidentSeverity: {
+              name: true,
+              color: true,
+            },
+            currentIncidentState: {
+              _id: true,
+              name: true,
+              color: true,
+              order: true,
+            },
+            monitors: {
+              _id: true,
+            },
+          };
+
+          if (statusPage.showIncidentLabelsOnStatusPage) {
+            select = {
+              ...select,
+              labels: {
+                name: true,
+                color: true,
+              },
+            };
+          }
+
+          const unresolvedIncidentStates: Array<IncidentState> =
+            await IncidentStateService.getUnresolvedIncidentStates(
+              statusPage.projectId!,
+              {
+                isRoot: true,
+              },
+            );
+
+          const unresolvedIncidentStateIds: Array<ObjectID> =
+            unresolvedIncidentStates.map((state: IncidentState) => {
+              return state.id!;
+            });
+
+          if (statusPage.showIncidentsOnStatusPage) {
+            activeIncidents = await IncidentService.findBy({
               query: {
-                _id: statusPageId.toString(),
+                monitors: monitorsOnStatusPage as any,
+                currentIncidentStateId: QueryHelper.any(
+                  unresolvedIncidentStateIds,
+                ),
+                isVisibleOnStatusPage: true,
+                projectId: statusPage.projectId!,
               },
-              select: {
-                showUptimeHistoryInDays: true,
+              select: select,
+              sort: {
+                declaredAt: SortOrder.Descending,
+                createdAt: SortOrder.Descending,
               },
+
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
               props: {
                 isRoot: true,
               },
             });
-
-          let uptimeHistoryDays: number =
-            statusPageForDays?.showUptimeHistoryInDays || 90;
-
-          if (uptimeHistoryDays > 90) {
-            uptimeHistoryDays = 90;
-          }
-
-          if (uptimeHistoryDays < 1) {
-            uptimeHistoryDays = 1;
           }
+        }
 
-          const startDate: Date =
-            OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
-          const endDate: Date = OneUptimeDate.getCurrentDate();
+        const incidentsOnStatusPage: Array<ObjectID> = activeIncidents.map(
+          (incident: Incident) => {
+            return incident.id!;
+          },
+        );
 
-          const {
-            monitorStatuses,
-            monitorGroupCurrentStatuses,
-            statusPageResources,
-            statusPage,
-            monitorsOnStatusPage,
-            monitorStatusTimelines,
-            statusPageGroups,
-            monitorsInGroup,
-          } = await this.getStatusPageResourcesAndTimelines({
-            statusPageId: statusPageId,
-            startDateForMonitorTimeline: startDate,
-            endDateForMonitorTimeline: endDate,
-          });
+        let incidentPublicNotes: Array<IncidentPublicNote> = [];
 
-          // check if status page has active incident.
-          let activeIncidents: Array<Incident> = [];
-          if (monitorsOnStatusPage.length > 0) {
-            let select: Select<Incident> = {
-              createdAt: true,
-              declaredAt: true,
-              updatedAt: true,
-              title: true,
-              description: true,
-              _id: true,
-              postmortemNote: true,
-              postmortemPostedAt: true,
-              showPostmortemOnStatusPage: true,
-              postmortemAttachments: {
+        if (incidentsOnStatusPage.length > 0) {
+          incidentPublicNotes = await IncidentPublicNoteService.findBy({
+            query: {
+              incidentId: QueryHelper.any(incidentsOnStatusPage),
+              projectId: statusPage.projectId!,
+            },
+            select: {
+              note: true,
+              incidentId: true,
+              postedAt: true,
+              attachments: {
                 _id: true,
                 name: true,
               },
-              incidentSeverity: {
-                name: true,
-                color: true,
-              },
-              currentIncidentState: {
+            },
+            sort: {
+              postedAt: SortOrder.Descending, // new note first
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+              isRoot: true,
+            },
+          });
+        }
+
+        let incidentStateTimelines: Array<IncidentStateTimeline> = [];
+
+        if (incidentsOnStatusPage.length > 0) {
+          incidentStateTimelines = await IncidentStateTimelineService.findBy({
+            query: {
+              incidentId: QueryHelper.any(incidentsOnStatusPage),
+              projectId: statusPage.projectId!,
+            },
+            select: {
+              _id: true,
+              createdAt: true,
+              startsAt: true,
+              incidentId: true,
+              incidentState: {
                 _id: true,
                 name: true,
                 color: true,
-                order: true,
+                isCreatedState: true,
+                isResolvedState: true,
+                isAcknowledgedState: true,
               },
-              monitors: {
-                _id: true,
-              },
-            };
-
-            if (statusPage.showIncidentLabelsOnStatusPage) {
-              select = {
-                ...select,
-                labels: {
-                  name: true,
-                  color: true,
-                },
-              };
-            }
-
-            const unresolvedIncidentStates: Array<IncidentState> =
-              await IncidentStateService.getUnresolvedIncidentStates(
-                statusPage.projectId!,
-                {
-                  isRoot: true,
-                },
-              );
-
-            const unresolvedIncidentStateIds: Array<ObjectID> =
-              unresolvedIncidentStates.map((state: IncidentState) => {
-                return state.id!;
-              });
-
-            if (statusPage.showIncidentsOnStatusPage) {
-              activeIncidents = await IncidentService.findBy({
-                query: {
-                  monitors: monitorsOnStatusPage as any,
-                  currentIncidentStateId: QueryHelper.any(
-                    unresolvedIncidentStateIds,
-                  ),
-                  isVisibleOnStatusPage: true,
-                  projectId: statusPage.projectId!,
-                },
-                select: select,
-                sort: {
-                  declaredAt: SortOrder.Descending,
-                  createdAt: SortOrder.Descending,
-                },
-
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
-            }
-          }
+            },
 
-          const incidentsOnStatusPage: Array<ObjectID> = activeIncidents.map(
-            (incident: Incident) => {
-              return incident.id!;
+            sort: {
+              startsAt: SortOrder.Descending, // newer state changes first
             },
-          );
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+              isRoot: true,
+            },
+          });
+        }
 
-          let incidentPublicNotes: Array<IncidentPublicNote> = [];
+        // Fetch active episodes (similar to incidents)
+        let activeEpisodes: Array<IncidentEpisode> = [];
+        let activeEpisodesJson: JSONArray = [];
+        let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
+        let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
 
-          if (incidentsOnStatusPage.length > 0) {
-            incidentPublicNotes = await IncidentPublicNoteService.findBy({
+        if (
+          statusPage.showEpisodesOnStatusPage &&
+          monitorsOnStatusPage.length > 0
+        ) {
+          // First, get incidents that have monitors on status page
+          const incidentsForEpisodes: Array<Incident> =
+            await IncidentService.findBy({
               query: {
-                incidentId: QueryHelper.any(incidentsOnStatusPage),
+                monitors: monitorsOnStatusPage as any,
+                isVisibleOnStatusPage: true,
                 projectId: statusPage.projectId!,
               },
               select: {
-                note: true,
-                incidentId: true,
-                postedAt: true,
-                attachments: {
-                  _id: true,
-                  name: true,
-                },
-              },
-              sort: {
-                postedAt: SortOrder.Descending, // new note first
+                _id: true,
               },
               skip: 0,
               limit: LIMIT_PER_PROJECT,
@@ -1664,33 +1735,23 @@ export default class StatusPageAPI extends BaseAPI<
                 isRoot: true,
               },
             });
-          }
 
-          let incidentStateTimelines: Array<IncidentStateTimeline> = [];
+          const incidentIdsForEpisodes: Array<ObjectID> =
+            incidentsForEpisodes.map((incident: Incident) => {
+              return incident.id!;
+            });
 
-          if (incidentsOnStatusPage.length > 0) {
-            incidentStateTimelines = await IncidentStateTimelineService.findBy({
+          // Get episode members for these incidents
+          let episodeMembers: Array<IncidentEpisodeMember> = [];
+          if (incidentIdsForEpisodes.length > 0) {
+            episodeMembers = await IncidentEpisodeMemberService.findBy({
               query: {
-                incidentId: QueryHelper.any(incidentsOnStatusPage),
+                incidentId: QueryHelper.any(incidentIdsForEpisodes),
                 projectId: statusPage.projectId!,
               },
               select: {
-                _id: true,
-                createdAt: true,
-                startsAt: true,
+                incidentEpisodeId: true,
                 incidentId: true,
-                incidentState: {
-                  _id: true,
-                  name: true,
-                  color: true,
-                  isCreatedState: true,
-                  isResolvedState: true,
-                  isAcknowledgedState: true,
-                },
-              },
-
-              sort: {
-                startsAt: SortOrder.Descending, // newer state changes first
               },
               skip: 0,
               limit: LIMIT_PER_PROJECT,
@@ -1700,534 +1761,418 @@ export default class StatusPageAPI extends BaseAPI<
             });
           }
 
-          // Fetch active episodes (similar to incidents)
-          let activeEpisodes: Array<IncidentEpisode> = [];
-          let activeEpisodesJson: JSONArray = [];
-          let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
-          let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
-
-          if (
-            statusPage.showEpisodesOnStatusPage &&
-            monitorsOnStatusPage.length > 0
-          ) {
-            // First, get incidents that have monitors on status page
-            const incidentsForEpisodes: Array<Incident> =
-              await IncidentService.findBy({
-                query: {
-                  monitors: monitorsOnStatusPage as any,
-                  isVisibleOnStatusPage: true,
-                  projectId: statusPage.projectId!,
-                },
-                select: {
-                  _id: true,
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
-
-            const incidentIdsForEpisodes: Array<ObjectID> =
-              incidentsForEpisodes.map((incident: Incident) => {
-                return incident.id!;
-              });
-
-            // Get episode members for these incidents
-            let episodeMembers: Array<IncidentEpisodeMember> = [];
-            if (incidentIdsForEpisodes.length > 0) {
-              episodeMembers = await IncidentEpisodeMemberService.findBy({
-                query: {
-                  incidentId: QueryHelper.any(incidentIdsForEpisodes),
-                  projectId: statusPage.projectId!,
-                },
-                select: {
-                  incidentEpisodeId: true,
-                  incidentId: true,
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
+          // Get unique episode IDs
+          const episodeIdsFromMembers: Set<string> = new Set();
+          for (const member of episodeMembers) {
+            if (member.incidentEpisodeId) {
+              episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
             }
+          }
 
-            // Get unique episode IDs
-            const episodeIdsFromMembers: Set<string> = new Set();
-            for (const member of episodeMembers) {
-              if (member.incidentEpisodeId) {
-                episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
-              }
-            }
+          // Fetch active (unresolved) episodes
+          if (episodeIdsFromMembers.size > 0) {
+            const unresolvedIncidentStates: Array<IncidentState> =
+              await IncidentStateService.getUnresolvedIncidentStates(
+                statusPage.projectId!,
+                { isRoot: true },
+              );
 
-            // Fetch active (unresolved) episodes
-            if (episodeIdsFromMembers.size > 0) {
-              const unresolvedIncidentStates: Array<IncidentState> =
-                await IncidentStateService.getUnresolvedIncidentStates(
-                  statusPage.projectId!,
-                  { isRoot: true },
-                );
-
-              const unresolvedIncidentStateIds: Array<ObjectID> =
-                unresolvedIncidentStates.map((state: IncidentState) => {
-                  return state.id!;
-                });
+            const unresolvedIncidentStateIds: Array<ObjectID> =
+              unresolvedIncidentStates.map((state: IncidentState) => {
+                return state.id!;
+              });
 
-              let selectEpisodes: Select<IncidentEpisode> = {
-                createdAt: true,
-                declaredAt: true,
-                updatedAt: true,
-                title: true,
-                description: true,
+            let selectEpisodes: Select<IncidentEpisode> = {
+              createdAt: true,
+              declaredAt: true,
+              updatedAt: true,
+              title: true,
+              description: true,
+              _id: true,
+              episodeNumber: true,
+              incidentSeverity: {
+                name: true,
+                color: true,
+              },
+              currentIncidentState: {
+                name: true,
+                color: true,
                 _id: true,
-                episodeNumber: true,
-                incidentSeverity: {
-                  name: true,
-                  color: true,
-                },
-                currentIncidentState: {
+                order: true,
+                isCreatedState: true,
+                isAcknowledgedState: true,
+                isResolvedState: true,
+              },
+              incidentCount: true,
+            };
+
+            if (statusPage.showEpisodeLabelsOnStatusPage) {
+              selectEpisodes = {
+                ...selectEpisodes,
+                labels: {
                   name: true,
                   color: true,
-                  _id: true,
-                  order: true,
-                  isCreatedState: true,
-                  isAcknowledgedState: true,
-                  isResolvedState: true,
                 },
-                incidentCount: true,
               };
+            }
+
+            activeEpisodes = await IncidentEpisodeService.findBy({
+              query: {
+                _id: QueryHelper.any(
+                  Array.from(episodeIdsFromMembers).map((id: string) => {
+                    return new ObjectID(id);
+                  }),
+                ),
+                currentIncidentStateId: QueryHelper.any(
+                  unresolvedIncidentStateIds,
+                ),
+                isVisibleOnStatusPage: true,
+                projectId: statusPage.projectId!,
+              },
+              select: selectEpisodes,
+              sort: {
+                declaredAt: SortOrder.Descending,
+                createdAt: SortOrder.Descending,
+              },
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
+              props: {
+                isRoot: true,
+              },
+            });
+
+            // Build episode monitors map
+            if (activeEpisodes.length > 0) {
+              // Collect all incident IDs from episode members for active episodes
+              const activeEpisodeIds: Set<string> = new Set(
+                activeEpisodes.map((e: IncidentEpisode) => {
+                  return e.id!.toString();
+                }),
+              );
+
+              const memberIncidentIds: Array<ObjectID> = [];
+              for (const member of episodeMembers) {
+                if (
+                  member.incidentEpisodeId &&
+                  activeEpisodeIds.has(member.incidentEpisodeId.toString()) &&
+                  member.incidentId &&
+                  !memberIncidentIds.some((id: ObjectID) => {
+                    return id.toString() === member.incidentId!.toString();
+                  })
+                ) {
+                  memberIncidentIds.push(member.incidentId);
+                }
+              }
 
-              if (statusPage.showEpisodeLabelsOnStatusPage) {
-                selectEpisodes = {
-                  ...selectEpisodes,
-                  labels: {
-                    name: true,
-                    color: true,
+              // Fetch incidents with monitors
+              let memberIncidents: Array<Incident> = [];
+              if (memberIncidentIds.length > 0) {
+                memberIncidents = await IncidentService.findBy({
+                  query: {
+                    _id: QueryHelper.any(memberIncidentIds),
+                    isVisibleOnStatusPage: true,
+                    projectId: statusPage.projectId!,
                   },
-                };
+                  select: {
+                    _id: true,
+                    monitors: {
+                      _id: true,
+                    },
+                  },
+                  skip: 0,
+                  limit: LIMIT_PER_PROJECT,
+                  props: {
+                    isRoot: true,
+                  },
+                });
               }
 
-              activeEpisodes = await IncidentEpisodeService.findBy({
-                query: {
-                  _id: QueryHelper.any(
-                    Array.from(episodeIdsFromMembers).map((id: string) => {
-                      return new ObjectID(id);
-                    }),
-                  ),
-                  currentIncidentStateId: QueryHelper.any(
-                    unresolvedIncidentStateIds,
-                  ),
-                  isVisibleOnStatusPage: true,
-                  projectId: statusPage.projectId!,
-                },
-                select: selectEpisodes,
-                sort: {
-                  declaredAt: SortOrder.Descending,
-                  createdAt: SortOrder.Descending,
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
+              // Build incident -> monitors map
+              const incidentMonitorsMap: Map<
+                string,
+                Array<ObjectID>
+              > = new Map();
+              for (const incident of memberIncidents) {
+                const incidentIdStr: string = incident.id!.toString();
+                const monitorIds: Array<ObjectID> = (incident.monitors || [])
+                  .map((m: Monitor) => {
+                    return new ObjectID(
+                      m._id?.toString() || m.id?.toString() || "",
+                    );
+                  })
+                  .filter((id: ObjectID) => {
+                    return id.toString() !== "";
+                  });
+                incidentMonitorsMap.set(incidentIdStr, monitorIds);
+              }
 
-              // Build episode monitors map
-              if (activeEpisodes.length > 0) {
-                // Collect all incident IDs from episode members for active episodes
-                const activeEpisodeIds: Set<string> = new Set(
-                  activeEpisodes.map((e: IncidentEpisode) => {
-                    return e.id!.toString();
-                  }),
-                );
-
-                const memberIncidentIds: Array<ObjectID> = [];
-                for (const member of episodeMembers) {
-                  if (
-                    member.incidentEpisodeId &&
-                    activeEpisodeIds.has(member.incidentEpisodeId.toString()) &&
-                    member.incidentId &&
-                    !memberIncidentIds.some((id: ObjectID) => {
-                      return id.toString() === member.incidentId!.toString();
-                    })
-                  ) {
-                    memberIncidentIds.push(member.incidentId);
+              // Build episode -> monitors map
+              const episodeMonitorsMap: Map<
+                string,
+                Array<ObjectID>
+              > = new Map();
+              for (const member of episodeMembers) {
+                if (
+                  member.incidentEpisodeId &&
+                  member.incidentId &&
+                  activeEpisodeIds.has(member.incidentEpisodeId.toString())
+                ) {
+                  const episodeIdStr: string =
+                    member.incidentEpisodeId.toString();
+                  const incidentIdStr: string = member.incidentId.toString();
+
+                  if (!episodeMonitorsMap.has(episodeIdStr)) {
+                    episodeMonitorsMap.set(episodeIdStr, []);
+                  }
+
+                  const episodeMonitors: Array<ObjectID> =
+                    episodeMonitorsMap.get(episodeIdStr)!;
+                  const incidentMonitors: Array<ObjectID> =
+                    incidentMonitorsMap.get(incidentIdStr) || [];
+
+                  for (const monitorId of incidentMonitors) {
+                    if (
+                      !episodeMonitors.some((m: ObjectID) => {
+                        return m.toString() === monitorId.toString();
+                      })
+                    ) {
+                      episodeMonitors.push(monitorId);
+                    }
                   }
                 }
+              }
+
+              // Serialize episodes and add monitors
+              activeEpisodesJson = BaseModel.toJSONArray(
+                activeEpisodes,
+                IncidentEpisode,
+              );
+              for (const episodeJson of activeEpisodesJson) {
+                const episodeObj: JSONObject = episodeJson as JSONObject;
+                const episodeId: string | undefined =
+                  episodeObj["_id"]?.toString();
+                if (episodeId) {
+                  const monitorIds: Array<ObjectID> =
+                    episodeMonitorsMap.get(episodeId) || [];
+                  episodeObj["monitors"] = monitorIds.map((id: ObjectID) => {
+                    return { _id: id.toString() };
+                  });
+                }
+              }
 
-                // Fetch incidents with monitors
-                let memberIncidents: Array<Incident> = [];
-                if (memberIncidentIds.length > 0) {
-                  memberIncidents = await IncidentService.findBy({
+              // Get episode public notes
+              const episodesOnStatusPage: Array<ObjectID> = activeEpisodes.map(
+                (episode: IncidentEpisode) => {
+                  return episode.id!;
+                },
+              );
+
+              if (episodesOnStatusPage.length > 0) {
+                episodePublicNotes =
+                  await IncidentEpisodePublicNoteService.findBy({
                     query: {
-                      _id: QueryHelper.any(memberIncidentIds),
-                      isVisibleOnStatusPage: true,
+                      incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
                       projectId: statusPage.projectId!,
                     },
                     select: {
-                      _id: true,
-                      monitors: {
+                      postedAt: true,
+                      note: true,
+                      incidentEpisodeId: true,
+                      attachments: {
                         _id: true,
+                        name: true,
                       },
                     },
+                    sort: {
+                      postedAt: SortOrder.Descending,
+                    },
                     skip: 0,
                     limit: LIMIT_PER_PROJECT,
                     props: {
                       isRoot: true,
                     },
                   });
-                }
-
-                // Build incident -> monitors map
-                const incidentMonitorsMap: Map<
-                  string,
-                  Array<ObjectID>
-                > = new Map();
-                for (const incident of memberIncidents) {
-                  const incidentIdStr: string = incident.id!.toString();
-                  const monitorIds: Array<ObjectID> = (incident.monitors || [])
-                    .map((m: Monitor) => {
-                      return new ObjectID(
-                        m._id?.toString() || m.id?.toString() || "",
-                      );
-                    })
-                    .filter((id: ObjectID) => {
-                      return id.toString() !== "";
-                    });
-                  incidentMonitorsMap.set(incidentIdStr, monitorIds);
-                }
 
-                // Build episode -> monitors map
-                const episodeMonitorsMap: Map<
-                  string,
-                  Array<ObjectID>
-                > = new Map();
-                for (const member of episodeMembers) {
-                  if (
-                    member.incidentEpisodeId &&
-                    member.incidentId &&
-                    activeEpisodeIds.has(member.incidentEpisodeId.toString())
-                  ) {
-                    const episodeIdStr: string =
-                      member.incidentEpisodeId.toString();
-                    const incidentIdStr: string = member.incidentId.toString();
-
-                    if (!episodeMonitorsMap.has(episodeIdStr)) {
-                      episodeMonitorsMap.set(episodeIdStr, []);
-                    }
+                // Get episode state timelines
+                episodeStateTimelines =
+                  await IncidentEpisodeStateTimelineService.findBy({
+                    query: {
+                      incidentEpisodeId: QueryHelper.any(episodesOnStatusPage),
+                      projectId: statusPage.projectId!,
+                    },
+                    select: {
+                      _id: true,
+                      createdAt: true,
+                      startsAt: true,
+                      incidentEpisodeId: true,
+                      incidentState: {
+                        name: true,
+                        color: true,
+                        isCreatedState: true,
+                        isAcknowledgedState: true,
+                        isResolvedState: true,
+                      },
+                    },
+                    sort: {
+                      startsAt: SortOrder.Descending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                      isRoot: true,
+                    },
+                  });
+              }
+            }
+          }
+        }
 
-                    const episodeMonitors: Array<ObjectID> =
-                      episodeMonitorsMap.get(episodeIdStr)!;
-                    const incidentMonitors: Array<ObjectID> =
-                      incidentMonitorsMap.get(incidentIdStr) || [];
-
-                    for (const monitorId of incidentMonitors) {
-                      if (
-                        !episodeMonitors.some((m: ObjectID) => {
-                          return m.toString() === monitorId.toString();
-                        })
-                      ) {
-                        episodeMonitors.push(monitorId);
-                      }
-                    }
-                  }
-                }
+        // check if status page has active announcement.
 
-                // Serialize episodes and add monitors
-                activeEpisodesJson = BaseModel.toJSONArray(
-                  activeEpisodes,
-                  IncidentEpisode,
-                );
-                for (const episodeJson of activeEpisodesJson) {
-                  const episodeObj: JSONObject = episodeJson as JSONObject;
-                  const episodeId: string | undefined =
-                    episodeObj["_id"]?.toString();
-                  if (episodeId) {
-                    const monitorIds: Array<ObjectID> =
-                      episodeMonitorsMap.get(episodeId) || [];
-                    episodeObj["monitors"] = monitorIds.map((id: ObjectID) => {
-                      return { _id: id.toString() };
-                    });
-                  }
-                }
+        const today: Date = OneUptimeDate.getCurrentDate();
 
-                // Get episode public notes
-                const episodesOnStatusPage: Array<ObjectID> =
-                  activeEpisodes.map((episode: IncidentEpisode) => {
-                    return episode.id!;
-                  });
+        let activeAnnouncements: Array<StatusPageAnnouncement> = [];
 
-                if (episodesOnStatusPage.length > 0) {
-                  episodePublicNotes =
-                    await IncidentEpisodePublicNoteService.findBy({
-                      query: {
-                        incidentEpisodeId:
-                          QueryHelper.any(episodesOnStatusPage),
-                        projectId: statusPage.projectId!,
-                      },
-                      select: {
-                        postedAt: true,
-                        note: true,
-                        incidentEpisodeId: true,
-                        attachments: {
-                          _id: true,
-                          name: true,
-                        },
-                      },
-                      sort: {
-                        postedAt: SortOrder.Descending,
-                      },
-                      skip: 0,
-                      limit: LIMIT_PER_PROJECT,
-                      props: {
-                        isRoot: true,
-                      },
-                    });
+        if (statusPage.showAnnouncementsOnStatusPage) {
+          activeAnnouncements = await StatusPageAnnouncementService.findBy({
+            query: {
+              statusPages: statusPageId as any,
+              showAnnouncementAt: QueryHelper.lessThan(today),
+              endAnnouncementAt: QueryHelper.greaterThanOrNull(today),
+              projectId: statusPage.projectId!,
+            },
+            select: {
+              createdAt: true,
+              title: true,
+              description: true,
+              _id: true,
+              showAnnouncementAt: true,
+              endAnnouncementAt: true,
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+              isRoot: true,
+            },
+          });
+        }
 
-                  // Get episode state timelines
-                  episodeStateTimelines =
-                    await IncidentEpisodeStateTimelineService.findBy({
-                      query: {
-                        incidentEpisodeId:
-                          QueryHelper.any(episodesOnStatusPage),
-                        projectId: statusPage.projectId!,
-                      },
-                      select: {
-                        _id: true,
-                        createdAt: true,
-                        startsAt: true,
-                        incidentEpisodeId: true,
-                        incidentState: {
-                          name: true,
-                          color: true,
-                          isCreatedState: true,
-                          isAcknowledgedState: true,
-                          isResolvedState: true,
-                        },
-                      },
-                      sort: {
-                        startsAt: SortOrder.Descending,
-                      },
-                      skip: 0,
-                      limit: LIMIT_PER_PROJECT,
-                      props: {
-                        isRoot: true,
-                      },
-                    });
-                }
-              }
-            }
-          }
+        // check if status page has active scheduled events.
 
-          // check if status page has active announcement.
+        let scheduledEventsSelect: Select<ScheduledMaintenance> = {
+          createdAt: true,
+          title: true,
+          description: true,
+          _id: true,
+          endsAt: true,
+          startsAt: true,
+          currentScheduledMaintenanceState: {
+            name: true,
+            color: true,
+            isScheduledState: true,
+            isResolvedState: true,
+            isOngoingState: true,
+          },
+          monitors: {
+            _id: true,
+          },
+        };
 
-          const today: Date = OneUptimeDate.getCurrentDate();
+        if (statusPage.showScheduledEventLabelsOnStatusPage) {
+          scheduledEventsSelect = {
+            ...scheduledEventsSelect,
+            labels: {
+              name: true,
+              color: true,
+            },
+          };
+        }
 
-          let activeAnnouncements: Array<StatusPageAnnouncement> = [];
+        let scheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
 
-          if (statusPage.showAnnouncementsOnStatusPage) {
-            activeAnnouncements = await StatusPageAnnouncementService.findBy({
+        if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
+          scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy(
+            {
               query: {
+                currentScheduledMaintenanceState: {
+                  isOngoingState: true,
+                } as any,
                 statusPages: statusPageId as any,
-                showAnnouncementAt: QueryHelper.lessThan(today),
-                endAnnouncementAt: QueryHelper.greaterThanOrNull(today),
                 projectId: statusPage.projectId!,
+                isVisibleOnStatusPage: true,
               },
-              select: {
-                createdAt: true,
-                title: true,
-                description: true,
-                _id: true,
-                showAnnouncementAt: true,
-                endAnnouncementAt: true,
+              select: scheduledEventsSelect,
+              sort: {
+                startsAt: SortOrder.Ascending,
               },
               skip: 0,
               limit: LIMIT_PER_PROJECT,
               props: {
                 isRoot: true,
               },
-            });
-          }
-
-          // check if status page has active scheduled events.
-
-          let scheduledEventsSelect: Select<ScheduledMaintenance> = {
-            createdAt: true,
-            title: true,
-            description: true,
-            _id: true,
-            endsAt: true,
-            startsAt: true,
-            currentScheduledMaintenanceState: {
-              name: true,
-              color: true,
-              isScheduledState: true,
-              isResolvedState: true,
-              isOngoingState: true,
-            },
-            monitors: {
-              _id: true,
-            },
-          };
-
-          if (statusPage.showScheduledEventLabelsOnStatusPage) {
-            scheduledEventsSelect = {
-              ...scheduledEventsSelect,
-              labels: {
-                name: true,
-                color: true,
-              },
-            };
-          }
-
-          let scheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
-
-          if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
-            scheduledMaintenanceEvents =
-              await ScheduledMaintenanceService.findBy({
-                query: {
-                  currentScheduledMaintenanceState: {
-                    isOngoingState: true,
-                  } as any,
-                  statusPages: statusPageId as any,
-                  projectId: statusPage.projectId!,
-                  isVisibleOnStatusPage: true,
-                },
-                select: scheduledEventsSelect,
-                sort: {
-                  startsAt: SortOrder.Ascending,
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
-          }
-
-          let futureScheduledMaintenanceEvents: Array<ScheduledMaintenance> =
-            [];
-
-          if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
-            futureScheduledMaintenanceEvents =
-              await ScheduledMaintenanceService.findBy({
-                query: {
-                  currentScheduledMaintenanceState: {
-                    isScheduledState: true,
-                  } as any,
-                  statusPages: statusPageId as any,
-                  projectId: statusPage.projectId!,
-                  isVisibleOnStatusPage: true,
-                },
-                select: scheduledEventsSelect,
-                sort: {
-                  startsAt: SortOrder.Ascending,
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
-          }
-
-          futureScheduledMaintenanceEvents.forEach(
-            (event: ScheduledMaintenance) => {
-              scheduledMaintenanceEvents.push(event);
             },
           );
+        }
 
-          const scheduledMaintenanceEventsOnStatusPage: Array<ObjectID> =
-            scheduledMaintenanceEvents.map((event: ScheduledMaintenance) => {
-              return event.id!;
-            });
-
-          let scheduledMaintenanceEventsPublicNotes: Array<ScheduledMaintenancePublicNote> =
-            [];
+        let futureScheduledMaintenanceEvents: Array<ScheduledMaintenance> = [];
 
-          if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
-            scheduledMaintenanceEventsPublicNotes =
-              await ScheduledMaintenancePublicNoteService.findBy({
-                query: {
-                  scheduledMaintenanceId: QueryHelper.any(
-                    scheduledMaintenanceEventsOnStatusPage,
-                  ),
-                  projectId: statusPage.projectId!,
-                },
-                select: {
-                  postedAt: true,
-                  note: true,
-                  scheduledMaintenanceId: true,
-                  attachments: {
-                    _id: true,
-                    name: true,
-                  },
-                },
-                sort: {
-                  postedAt: SortOrder.Ascending,
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
-          }
+        if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
+          futureScheduledMaintenanceEvents =
+            await ScheduledMaintenanceService.findBy({
+              query: {
+                currentScheduledMaintenanceState: {
+                  isScheduledState: true,
+                } as any,
+                statusPages: statusPageId as any,
+                projectId: statusPage.projectId!,
+                isVisibleOnStatusPage: true,
+              },
+              select: scheduledEventsSelect,
+              sort: {
+                startsAt: SortOrder.Ascending,
+              },
+              skip: 0,
+              limit: LIMIT_PER_PROJECT,
+              props: {
+                isRoot: true,
+              },
+            });
+        }
 
-          let scheduledMaintenanceStateTimelines: Array<ScheduledMaintenanceStateTimeline> =
-            [];
+        futureScheduledMaintenanceEvents.forEach(
+          (event: ScheduledMaintenance) => {
+            scheduledMaintenanceEvents.push(event);
+          },
+        );
 
-          if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
-            scheduledMaintenanceStateTimelines =
-              await ScheduledMaintenanceStateTimelineService.findBy({
-                query: {
-                  scheduledMaintenanceId: QueryHelper.any(
-                    scheduledMaintenanceEventsOnStatusPage,
-                  ),
-                  projectId: statusPage.projectId!,
-                },
-                select: {
-                  _id: true,
-                  createdAt: true,
-                  startsAt: true,
-                  scheduledMaintenanceId: true,
-                  scheduledMaintenanceState: {
-                    _id: true,
-                    color: true,
-                    name: true,
-                    isScheduledState: true,
-                    isResolvedState: true,
-                    isOngoingState: true,
-                  },
-                },
+        const scheduledMaintenanceEventsOnStatusPage: Array<ObjectID> =
+          scheduledMaintenanceEvents.map((event: ScheduledMaintenance) => {
+            return event.id!;
+          });
 
-                sort: {
-                  startsAt: SortOrder.Descending, // newer state changes first
-                },
-                skip: 0,
-                limit: LIMIT_PER_PROJECT,
-                props: {
-                  isRoot: true,
-                },
-              });
-          }
+        let scheduledMaintenanceEventsPublicNotes: Array<ScheduledMaintenancePublicNote> =
+          [];
 
-          // get all status page bar chart rules
-          const statusPageHistoryChartBarColorRules: Array<StatusPageHistoryChartBarColorRule> =
-            await StatusPageHistoryChartBarColorRuleService.findBy({
+        if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+          scheduledMaintenanceEventsPublicNotes =
+            await ScheduledMaintenancePublicNoteService.findBy({
               query: {
-                statusPageId: statusPageId,
+                scheduledMaintenanceId: QueryHelper.any(
+                  scheduledMaintenanceEventsOnStatusPage,
+                ),
+                projectId: statusPage.projectId!,
               },
               select: {
-                _id: true,
-                barColor: true,
-                order: true,
-                statusPageId: true,
-                uptimePercentGreaterThanOrEqualTo: true,
+                postedAt: true,
+                note: true,
+                scheduledMaintenanceId: true,
+                attachments: {
+                  _id: true,
+                  name: true,
+                },
               },
               sort: {
-                order: SortOrder.Ascending,
+                postedAt: SortOrder.Ascending,
               },
               skip: 0,
               limit: LIMIT_PER_PROJECT,
@@ -2235,42 +2180,37 @@ export default class StatusPageAPI extends BaseAPI<
                 isRoot: true,
               },
             });
+        }
 
-          /*
-           * Fetch all incidents (active + resolved) in the timeline date range
-           * for the uptime bar tooltip and click-through
-           */
-          let timelineIncidents: Array<Incident> = [];
-          if (
-            monitorsOnStatusPage.length > 0 &&
-            statusPage.showIncidentsOnStatusPage
-          ) {
-            timelineIncidents = await IncidentService.findBy({
+        let scheduledMaintenanceStateTimelines: Array<ScheduledMaintenanceStateTimeline> =
+          [];
+
+        if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+          scheduledMaintenanceStateTimelines =
+            await ScheduledMaintenanceStateTimelineService.findBy({
               query: {
-                monitors: monitorsOnStatusPage as any,
-                declaredAt: QueryHelper.inBetween(startDate, endDate),
-                isVisibleOnStatusPage: true,
+                scheduledMaintenanceId: QueryHelper.any(
+                  scheduledMaintenanceEventsOnStatusPage,
+                ),
                 projectId: statusPage.projectId!,
               },
               select: {
                 _id: true,
-                title: true,
-                declaredAt: true,
-                incidentSeverity: {
-                  name: true,
-                  color: true,
-                },
-                currentIncidentState: {
+                createdAt: true,
+                startsAt: true,
+                scheduledMaintenanceId: true,
+                scheduledMaintenanceState: {
                   _id: true,
-                  name: true,
                   color: true,
-                },
-                monitors: {
-                  _id: true,
+                  name: true,
+                  isScheduledState: true,
+                  isResolvedState: true,
+                  isOngoingState: true,
                 },
               },
+
               sort: {
-                declaredAt: SortOrder.Descending,
+                startsAt: SortOrder.Descending, // newer state changes first
               },
               skip: 0,
               limit: LIMIT_PER_PROJECT,
@@ -2278,101 +2218,188 @@ export default class StatusPageAPI extends BaseAPI<
                 isRoot: true,
               },
             });
-          }
+        }
 
-          const overallStatus: MonitorStatus | null =
-            StatusPageService.getOverallMonitorStatus({
-              statusPageResources,
-              monitorStatuses,
-              monitorGroupCurrentStatuses,
-            });
+        // get all status page bar chart rules
+        const statusPageHistoryChartBarColorRules: Array<StatusPageHistoryChartBarColorRule> =
+          await StatusPageHistoryChartBarColorRuleService.findBy({
+            query: {
+              statusPageId: statusPageId,
+            },
+            select: {
+              _id: true,
+              barColor: true,
+              order: true,
+              statusPageId: true,
+              uptimePercentGreaterThanOrEqualTo: true,
+            },
+            sort: {
+              order: SortOrder.Ascending,
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+              isRoot: true,
+            },
+          });
 
-          const response: JSONObject = {
-            overallStatus: overallStatus
-              ? BaseModel.toJSON(overallStatus, MonitorStatus)
-              : null,
+        /*
+         * Fetch all incidents (active + resolved) in the timeline date range
+         * for the uptime bar tooltip and click-through
+         */
+        let timelineIncidents: Array<Incident> = [];
+        if (
+          monitorsOnStatusPage.length > 0 &&
+          statusPage.showIncidentsOnStatusPage
+        ) {
+          timelineIncidents = await IncidentService.findBy({
+            query: {
+              monitors: monitorsOnStatusPage as any,
+              declaredAt: QueryHelper.inBetween(startDate, endDate),
+              isVisibleOnStatusPage: true,
+              projectId: statusPage.projectId!,
+            },
+            select: {
+              _id: true,
+              title: true,
+              declaredAt: true,
+              incidentSeverity: {
+                name: true,
+                color: true,
+              },
+              currentIncidentState: {
+                _id: true,
+                name: true,
+                color: true,
+              },
+              monitors: {
+                _id: true,
+              },
+            },
+            sort: {
+              declaredAt: SortOrder.Descending,
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+              isRoot: true,
+            },
+          });
+        }
 
-            scheduledMaintenanceEventsPublicNotes: BaseModel.toJSONArray(
-              scheduledMaintenanceEventsPublicNotes,
-              ScheduledMaintenancePublicNote,
-            ),
-            statusPageHistoryChartBarColorRules: BaseModel.toJSONArray(
-              statusPageHistoryChartBarColorRules,
-              StatusPageHistoryChartBarColorRule,
-            ),
-            scheduledMaintenanceEvents: BaseModel.toJSONArray(
-              scheduledMaintenanceEvents,
-              ScheduledMaintenance,
-            ),
-            activeAnnouncements: BaseModel.toJSONArray(
-              activeAnnouncements,
-              StatusPageAnnouncement,
-            ),
-            incidentPublicNotes: BaseModel.toJSONArray(
-              incidentPublicNotes,
-              IncidentPublicNote,
-            ),
+        const overallStatus: MonitorStatus | null =
+          StatusPageService.getOverallMonitorStatus({
+            statusPageResources,
+            monitorStatuses,
+            monitorGroupCurrentStatuses,
+          });
 
-            activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
+        const response: JSONObject = {
+          overallStatus: overallStatus
+            ? BaseModel.toJSON(overallStatus, MonitorStatus)
+            : null,
 
-            activeEpisodes: activeEpisodesJson,
-            episodePublicNotes: BaseModel.toJSONArray(
-              episodePublicNotes,
-              IncidentEpisodePublicNote,
-            ),
-            episodeStateTimelines: BaseModel.toJSONArray(
-              episodeStateTimelines,
-              IncidentEpisodeStateTimeline,
-            ),
+          scheduledMaintenanceEventsPublicNotes: BaseModel.toJSONArray(
+            scheduledMaintenanceEventsPublicNotes,
+            ScheduledMaintenancePublicNote,
+          ),
+          statusPageHistoryChartBarColorRules: BaseModel.toJSONArray(
+            statusPageHistoryChartBarColorRules,
+            StatusPageHistoryChartBarColorRule,
+          ),
+          scheduledMaintenanceEvents: BaseModel.toJSONArray(
+            scheduledMaintenanceEvents,
+            ScheduledMaintenance,
+          ),
+          activeAnnouncements: BaseModel.toJSONArray(
+            activeAnnouncements,
+            StatusPageAnnouncement,
+          ),
+          incidentPublicNotes: BaseModel.toJSONArray(
+            incidentPublicNotes,
+            IncidentPublicNote,
+          ),
 
-            monitorStatusTimelines: BaseModel.toJSONArray(
-              monitorStatusTimelines,
-              MonitorStatusTimeline,
-            ),
-            resourceGroups: BaseModel.toJSONArray(
-              statusPageGroups,
-              StatusPageGroup,
-            ),
-            monitorStatuses: BaseModel.toJSONArray(
-              monitorStatuses,
-              MonitorStatus,
-            ),
-            statusPageResources: BaseModel.toJSONArray(
-              statusPageResources,
-              StatusPageResource,
-            ),
-            incidentStateTimelines: BaseModel.toJSONArray(
-              incidentStateTimelines,
-              IncidentStateTimeline,
-            ),
-            statusPage: (() => {
-              const statusPageJson: JSONObject = BaseModel.toJSONObject(
-                statusPage,
-                StatusPage,
-              );
-              delete statusPageJson["projectId"];
-              return statusPageJson;
-            })(),
-            scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(
-              scheduledMaintenanceStateTimelines,
-              ScheduledMaintenanceStateTimeline,
-            ),
+          activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
 
-            monitorGroupCurrentStatuses: JSONFunctions.serialize(
-              monitorGroupCurrentStatuses,
-            ),
-            monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
-            timelineIncidents: BaseModel.toJSONArray(
-              timelineIncidents,
-              Incident,
-            ),
-          };
+          activeEpisodes: activeEpisodesJson,
+          episodePublicNotes: BaseModel.toJSONArray(
+            episodePublicNotes,
+            IncidentEpisodePublicNote,
+          ),
+          episodeStateTimelines: BaseModel.toJSONArray(
+            episodeStateTimelines,
+            IncidentEpisodeStateTimeline,
+          ),
 
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
+          monitorStatusTimelines: BaseModel.toJSONArray(
+            monitorStatusTimelines,
+            MonitorStatusTimeline,
+          ),
+          resourceGroups: BaseModel.toJSONArray(
+            statusPageGroups,
+            StatusPageGroup,
+          ),
+          monitorStatuses: BaseModel.toJSONArray(
+            monitorStatuses,
+            MonitorStatus,
+          ),
+          statusPageResources: BaseModel.toJSONArray(
+            statusPageResources,
+            StatusPageResource,
+          ),
+          incidentStateTimelines: BaseModel.toJSONArray(
+            incidentStateTimelines,
+            IncidentStateTimeline,
+          ),
+          statusPage: (() => {
+            const statusPageJson: JSONObject = BaseModel.toJSONObject(
+              statusPage,
+              StatusPage,
+            );
+            delete statusPageJson["projectId"];
+            return statusPageJson;
+          })(),
+          scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(
+            scheduledMaintenanceStateTimelines,
+            ScheduledMaintenanceStateTimeline,
+          ),
+
+          monitorGroupCurrentStatuses: JSONFunctions.serialize(
+            monitorGroupCurrentStatuses,
+          ),
+          monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
+          timelineIncidents: BaseModel.toJSONArray(timelineIncidents, Incident),
+        };
+
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
+
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
+
+    const overviewApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/overview/:statusPageIdOrDomain`;
+
+    this.router.post(
+      overviewApiPath,
+      UserMiddleware.getUserMiddleware,
+      overviewHandler,
+    );
+
+    /*
+     * GET variant of the overview endpoint. Same middleware and same handler
+     * as the POST route above — private status pages are rejected for
+     * unauthenticated callers exactly as they are on POST.
+     */
+    this.router.get(
+      overviewApiPath,
+      UserMiddleware.getUserMiddleware,
+      overviewHandler,
     );
 
     this.router.put(
@@ -2444,78 +2471,154 @@ export default class StatusPageAPI extends BaseAPI<
       },
     );
 
-    this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/incidents/:statusPageIdOrDomain`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
+    /*
+     * Shared handler for the incidents list endpoint. Registered for both
+     * POST and GET (same auth path). It does not read req.body.
+     */
+    const incidentsListHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-          const response: JSONObject = await this.getIncidents(
-            objectId,
-            null,
-            req,
-          );
+        const response: JSONObject = await this.getIncidents(
+          objectId,
+          null,
+          req,
+        );
 
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
+
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
+
+    const incidentsListApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/incidents/:statusPageIdOrDomain`;
 
     this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/scheduled-maintenance-events/:statusPageIdOrDomain`,
+      incidentsListApiPath,
       UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
+      incidentsListHandler,
+    );
 
-          const response: JSONObject = await this.getScheduledMaintenanceEvents(
-            objectId,
-            null,
+    this.router.get(
+      incidentsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      incidentsListHandler,
+    );
 
-            req,
-          );
+    /*
+     * Shared handler for the scheduled maintenance events list endpoint.
+     * Registered for both POST and GET (same auth path). It does not read
+     * req.body.
+     */
+    const scheduledMaintenanceEventsListHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
-    );
+        const response: JSONObject = await this.getScheduledMaintenanceEvents(
+          objectId,
+          null,
+
+          req,
+        );
+
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
+
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
+
+    const scheduledMaintenanceEventsListApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/scheduled-maintenance-events/:statusPageIdOrDomain`;
 
     this.router.post(
-      `${new this.entityType()
-        .getCrudApiPath()
-        ?.toString()}/announcements/:statusPageIdOrDomain`,
+      scheduledMaintenanceEventsListApiPath,
       UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          const objectId: ObjectID = await resolveStatusPageIdOrThrow(
-            req.params["statusPageIdOrDomain"] as string,
-          );
+      scheduledMaintenanceEventsListHandler,
+    );
 
-          const response: JSONObject = await this.getAnnouncements(
-            objectId,
-            null,
+    this.router.get(
+      scheduledMaintenanceEventsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      scheduledMaintenanceEventsListHandler,
+    );
 
-            req,
-          );
+    /*
+     * Shared handler for the announcements list endpoint. Registered for
+     * both POST and GET (same auth path). It does not read req.body.
+     */
+    const announcementsListHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const objectId: ObjectID = await resolveStatusPageIdOrThrow(
+          req.params["statusPageIdOrDomain"] as string,
+        );
 
-          return Response.sendJsonObjectResponse(req, res, response);
-        } catch (err) {
-          next(err);
-        }
-      },
+        const response: JSONObject = await this.getAnnouncements(
+          objectId,
+          null,
+
+          req,
+        );
+
+        // These can serve private-page data on a GET; never let shared caches store them.
+        Response.setNoCacheHeaders(res);
+
+        return Response.sendJsonObjectResponse(req, res, response);
+      } catch (err) {
+        next(err);
+      }
+    };
+
+    const announcementsListApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/announcements/:statusPageIdOrDomain`;
+
+    this.router.post(
+      announcementsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      announcementsListHandler,
+    );
+
+    this.router.get(
+      announcementsListApiPath,
+      UserMiddleware.getUserMiddleware,
+      announcementsListHandler,
     );
 
     this.router.post(