@oneuptime/common 12.0.11 → 12.0.13

package/build/dist/Server/API/StatusPageAPI.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import UserMiddleware from "../Middleware/UserAuthorization";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 import AcmeChallengeService from "../Services/AcmeChallengeService";
 import IncidentEpisodeService from "../Services/IncidentEpisodeService";
 import IncidentEpisodeMemberService from "../Services/IncidentEpisodeMemberService";
@@ -36,6 +37,7 @@ import StatusPageOidcService from "../Services/StatusPageOidcService";
 import StatusPageSubscriberService from "../Services/StatusPageSubscriberService";
 import QueryHelper from "../Types/Database/QueryHelper";
 import logger, { getLogAttributesFromRequest } from "../Utils/Logger";
+import { SEARCH_ENGINE_INDEXING_FLAG_NAME, isSearchEngineIndexingEnabled, } from "../../Types/StatusPage/SearchEngineIndexing";
 import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
@@ -120,7 +122,11 @@ const resolveStatusPageIdOrThrow = async (statusPageIdOrDomain) => {
     }
     return statusPageId;
 };
-export default class StatusPageAPI extends BaseAPI {
+class StatusPageAPI extends BaseAPI {
+    static clearOverviewResponseCache() {
+        this.overviewResponseCache.clear();
+        this.overviewResponseInFlight.clear();
+    }
     constructor() {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
         super(StatusPage, StatusPageService);
@@ -142,6 +148,7 @@ export default class StatusPageAPI extends BaseAPI {
                     pageDescription: true,
                     name: true,
                     defaultLanguage: true,
+                    enableSearchEngineIndexing: true,
                 },
                 props: {
                     isRoot: true,
@@ -155,6 +162,12 @@ export default class StatusPageAPI extends BaseAPI {
                 description: statusPage.pageDescription,
                 _id: (_a = statusPage._id) === null || _a === void 0 ? void 0 : _a.toString(),
                 defaultLanguage: statusPage.defaultLanguage || null,
+                /*
+                 * Drives <meta name="robots"> and X-Robots-Tag on the rendered page.
+                 * Normalised here rather than shipping the raw column, so the two
+                 * frontend servers never have to decide what a missing value means.
+                 */
+                [SEARCH_ENGINE_INDEXING_FLAG_NAME]: isSearchEngineIndexingEnabled(statusPage.enableSearchEngineIndexing),
             });
         });
         // favicon api.
@@ -1056,686 +1069,42 @@ export default class StatusPageAPI extends BaseAPI {
          * can never drift between the two methods. It does not read req.body.
          */
         const overviewHandler = async (req, res, next) => {
-            var _a;
             try {
                 const statusPageId = await resolveStatusPageIdOrThrow(req.params["statusPageIdOrDomain"]);
-                await this.checkHasReadAccess({
-                    statusPageId: statusPageId,
-                    req: req,
-                });
                 /*
-                 * The timeline window comes from the status page's configured
-                 * showUptimeHistoryInDays. getStatusPageResourcesAndTimelines
-                 * fetches the status page row anyway, so let it compute the window
-                 * (clamped to 1..90 days, ending now) instead of issuing a separate
-                 * StatusPage query here just to read that one column.
+                 * checkHasReadAccess MUST stay before any cache read: it is what keeps
+                 * private pages, IP whitelists, and master passwords enforced on every
+                 * request even when the payload below is served from cache.
                  */
-                const { monitorStatuses, monitorGroupCurrentStatuses, statusPageResources, statusPage, monitorsOnStatusPage, monitorStatusTimelines, statusPageGroups, monitorsInGroup, startDateForMonitorTimeline: startDate, endDateForMonitorTimeline: endDate, } = await this.getStatusPageResourcesAndTimelines({
+                await this.checkHasReadAccess({
                     statusPageId: statusPageId,
+                    req: req,
                 });
-                // check if status page has active incident.
-                let activeIncidents = [];
-                if (monitorsOnStatusPage.length > 0) {
-                    let select = {
-                        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 = Object.assign(Object.assign({}, select), { labels: {
-                                name: true,
-                                color: true,
-                            } });
-                    }
-                    const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(statusPage.projectId, {
-                        isRoot: true,
-                    });
-                    const unresolvedIncidentStateIds = unresolvedIncidentStates.map((state) => {
-                        return state.id;
-                    });
-                    if (statusPage.showIncidentsOnStatusPage) {
-                        activeIncidents = await IncidentService.findBy({
-                            query: {
-                                monitors: monitorsOnStatusPage,
-                                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 = activeIncidents.map((incident) => {
-                    return incident.id;
-                });
-                let incidentPublicNotes = [];
-                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,
-                            },
-                        },
-                        sort: {
-                            postedAt: SortOrder.Descending, // new note first
-                        },
-                        skip: 0,
-                        limit: LIMIT_PER_PROJECT,
-                        props: {
-                            isRoot: true,
-                        },
-                    });
-                }
-                let incidentStateTimelines = [];
-                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,
-                                isCreatedState: true,
-                                isResolvedState: true,
-                                isAcknowledgedState: true,
-                            },
-                        },
-                        sort: {
-                            startsAt: SortOrder.Descending, // newer state changes first
-                        },
-                        skip: 0,
-                        limit: LIMIT_PER_PROJECT,
-                        props: {
-                            isRoot: true,
-                        },
-                    });
-                }
-                // Fetch active episodes (similar to incidents)
-                let activeEpisodes = [];
-                let activeEpisodesJson = [];
-                let episodePublicNotes = [];
-                let episodeStateTimelines = [];
+                // Resolved id, so domain-served and id-served views share one entry.
+                const cacheKey = statusPageId.toString();
                 /*
-                 * Cheap guard before the expensive part: the block below scans every
-                 * incident ever attached to this page's monitors (a many-to-many
-                 * join, up to LIMIT_PER_PROJECT rows) just to discover episode
-                 * membership — on every overview view, even though most pages have
-                 * zero active episodes most of the time. One indexed COUNT of the
-                 * project's unresolved, visible episodes lets us skip all of it in
-                 * the common case. Behavior-preserving: the final activeEpisodes
-                 * query applies exactly these three constraints, so count == 0
-                 * implies the block's outputs stay empty.
+                 * The cached JSONObject is shared across requests and must never be
+                 * mutated after build.
                  */
-                let unresolvedIncidentStateIds = [];
-                let hasActiveEpisodes = false;
-                if (statusPage.showEpisodesOnStatusPage &&
-                    monitorsOnStatusPage.length > 0) {
-                    const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(statusPage.projectId, { isRoot: true });
-                    unresolvedIncidentStateIds = unresolvedIncidentStates.map((state) => {
-                        return state.id;
-                    });
-                    const activeEpisodeCount = await IncidentEpisodeService.countBy({
-                        query: {
-                            projectId: statusPage.projectId,
-                            isVisibleOnStatusPage: true,
-                            currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
-                        },
-                        props: {
-                            isRoot: true,
-                        },
-                    });
-                    hasActiveEpisodes = activeEpisodeCount.toNumber() > 0;
-                }
-                if (hasActiveEpisodes) {
-                    // First, get incidents that have monitors on status page
-                    const incidentsForEpisodes = await IncidentService.findBy({
-                        query: {
-                            monitors: monitorsOnStatusPage,
-                            isVisibleOnStatusPage: true,
-                            projectId: statusPage.projectId,
-                        },
-                        select: {
-                            _id: true,
-                        },
-                        skip: 0,
-                        limit: LIMIT_PER_PROJECT,
-                        props: {
-                            isRoot: true,
-                        },
-                    });
-                    const incidentIdsForEpisodes = incidentsForEpisodes.map((incident) => {
-                        return incident.id;
-                    });
-                    // Get episode members for these incidents
-                    let episodeMembers = [];
-                    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 = new Set();
-                    for (const member of episodeMembers) {
-                        if (member.incidentEpisodeId) {
-                            episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
-                        }
-                    }
-                    // Fetch active (unresolved) episodes
-                    if (episodeIdsFromMembers.size > 0) {
-                        // unresolvedIncidentStateIds was fetched by the guard above.
-                        let selectEpisodes = {
-                            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,
-                                order: true,
-                                isCreatedState: true,
-                                isAcknowledgedState: true,
-                                isResolvedState: true,
-                            },
-                            incidentCount: true,
-                        };
-                        if (statusPage.showEpisodeLabelsOnStatusPage) {
-                            selectEpisodes = Object.assign(Object.assign({}, selectEpisodes), { labels: {
-                                    name: true,
-                                    color: true,
-                                } });
-                        }
-                        activeEpisodes = await IncidentEpisodeService.findBy({
-                            query: {
-                                _id: QueryHelper.any(Array.from(episodeIdsFromMembers).map((id) => {
-                                    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,
-                            },
+                let response = StatusPageAPI.overviewResponseCache.get(cacheKey);
+                if (!response) {
+                    let inFlight = StatusPageAPI.overviewResponseInFlight.get(cacheKey);
+                    if (!inFlight) {
+                        inFlight = this.buildOverviewResponse(statusPageId);
+                        StatusPageAPI.overviewResponseInFlight.set(cacheKey, inFlight);
+                        inFlight
+                            .then((builtResponse) => {
+                            StatusPageAPI.overviewResponseCache.set(cacheKey, builtResponse, StatusPageAPI.OVERVIEW_CACHE_TTL_MS);
+                        })
+                            .catch(() => {
+                            // Failed builds are never cached; the next request rebuilds.
+                        })
+                            .finally(() => {
+                            StatusPageAPI.overviewResponseInFlight.delete(cacheKey);
                         });
-                        // Build episode monitors map
-                        if (activeEpisodes.length > 0) {
-                            // Collect all incident IDs from episode members for active episodes
-                            const activeEpisodeIds = new Set(activeEpisodes.map((e) => {
-                                return e.id.toString();
-                            }));
-                            const memberIncidentIds = [];
-                            for (const member of episodeMembers) {
-                                if (member.incidentEpisodeId &&
-                                    activeEpisodeIds.has(member.incidentEpisodeId.toString()) &&
-                                    member.incidentId &&
-                                    !memberIncidentIds.some((id) => {
-                                        return id.toString() === member.incidentId.toString();
-                                    })) {
-                                    memberIncidentIds.push(member.incidentId);
-                                }
-                            }
-                            // Fetch incidents with monitors
-                            let memberIncidents = [];
-                            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,
-                                    },
-                                });
-                            }
-                            // Build incident -> monitors map
-                            const incidentMonitorsMap = new Map();
-                            for (const incident of memberIncidents) {
-                                const incidentIdStr = incident.id.toString();
-                                const monitorIds = (incident.monitors || [])
-                                    .map((m) => {
-                                    var _a, _b;
-                                    return new ObjectID(((_a = m._id) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = m.id) === null || _b === void 0 ? void 0 : _b.toString()) || "");
-                                })
-                                    .filter((id) => {
-                                    return id.toString() !== "";
-                                });
-                                incidentMonitorsMap.set(incidentIdStr, monitorIds);
-                            }
-                            // Build episode -> monitors map
-                            const episodeMonitorsMap = new Map();
-                            for (const member of episodeMembers) {
-                                if (member.incidentEpisodeId &&
-                                    member.incidentId &&
-                                    activeEpisodeIds.has(member.incidentEpisodeId.toString())) {
-                                    const episodeIdStr = member.incidentEpisodeId.toString();
-                                    const incidentIdStr = member.incidentId.toString();
-                                    if (!episodeMonitorsMap.has(episodeIdStr)) {
-                                        episodeMonitorsMap.set(episodeIdStr, []);
-                                    }
-                                    const episodeMonitors = episodeMonitorsMap.get(episodeIdStr);
-                                    const incidentMonitors = incidentMonitorsMap.get(incidentIdStr) || [];
-                                    for (const monitorId of incidentMonitors) {
-                                        if (!episodeMonitors.some((m) => {
-                                            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 = episodeJson;
-                                const episodeId = (_a = episodeObj["_id"]) === null || _a === void 0 ? void 0 : _a.toString();
-                                if (episodeId) {
-                                    const monitorIds = episodeMonitorsMap.get(episodeId) || [];
-                                    episodeObj["monitors"] = monitorIds.map((id) => {
-                                        return { _id: id.toString() };
-                                    });
-                                }
-                            }
-                            // Get episode public notes
-                            const episodesOnStatusPage = activeEpisodes.map((episode) => {
-                                return episode.id;
-                            });
-                            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,
-                                        },
-                                    });
-                                // 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,
-                                        },
-                                    });
-                            }
-                        }
                     }
+                    response = await inFlight;
                 }
-                // check if status page has active announcement.
-                const today = OneUptimeDate.getCurrentDate();
-                let activeAnnouncements = [];
-                if (statusPage.showAnnouncementsOnStatusPage) {
-                    activeAnnouncements = await StatusPageAnnouncementService.findBy({
-                        query: {
-                            statusPages: statusPageId,
-                            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,
-                        },
-                    });
-                }
-                // check if status page has active scheduled events.
-                let scheduledEventsSelect = {
-                    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 = Object.assign(Object.assign({}, scheduledEventsSelect), { labels: {
-                            name: true,
-                            color: true,
-                        } });
-                }
-                let scheduledMaintenanceEvents = [];
-                if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
-                    scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy({
-                        query: {
-                            currentScheduledMaintenanceState: {
-                                isOngoingState: true,
-                            },
-                            statusPages: statusPageId,
-                            projectId: statusPage.projectId,
-                            isVisibleOnStatusPage: true,
-                        },
-                        select: scheduledEventsSelect,
-                        sort: {
-                            startsAt: SortOrder.Ascending,
-                        },
-                        skip: 0,
-                        limit: LIMIT_PER_PROJECT,
-                        props: {
-                            isRoot: true,
-                        },
-                    });
-                }
-                let futureScheduledMaintenanceEvents = [];
-                if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
-                    futureScheduledMaintenanceEvents =
-                        await ScheduledMaintenanceService.findBy({
-                            query: {
-                                currentScheduledMaintenanceState: {
-                                    isScheduledState: true,
-                                },
-                                statusPages: statusPageId,
-                                projectId: statusPage.projectId,
-                                isVisibleOnStatusPage: true,
-                            },
-                            select: scheduledEventsSelect,
-                            sort: {
-                                startsAt: SortOrder.Ascending,
-                            },
-                            skip: 0,
-                            limit: LIMIT_PER_PROJECT,
-                            props: {
-                                isRoot: true,
-                            },
-                        });
-                }
-                futureScheduledMaintenanceEvents.forEach((event) => {
-                    scheduledMaintenanceEvents.push(event);
-                });
-                const scheduledMaintenanceEventsOnStatusPage = scheduledMaintenanceEvents.map((event) => {
-                    return event.id;
-                });
-                let scheduledMaintenanceEventsPublicNotes = [];
-                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,
-                            },
-                        });
-                }
-                let scheduledMaintenanceStateTimelines = [];
-                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,
-                                },
-                            },
-                            sort: {
-                                startsAt: SortOrder.Descending, // newer state changes first
-                            },
-                            skip: 0,
-                            limit: LIMIT_PER_PROJECT,
-                            props: {
-                                isRoot: true,
-                            },
-                        });
-                }
-                // get all status page bar chart rules
-                const statusPageHistoryChartBarColorRules = 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,
-                    },
-                });
-                /*
-                 * Fetch all incidents (active + resolved) in the timeline date range
-                 * for the uptime bar tooltip and click-through
-                 */
-                let timelineIncidents = [];
-                if (monitorsOnStatusPage.length > 0 &&
-                    statusPage.showIncidentsOnStatusPage) {
-                    timelineIncidents = await IncidentService.findBy({
-                        query: {
-                            monitors: monitorsOnStatusPage,
-                            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,
-                        },
-                    });
-                }
-                const overallStatus = StatusPageService.getOverallMonitorStatus({
-                    statusPageResources,
-                    monitorStatuses,
-                    monitorGroupCurrentStatuses,
-                });
-                const response = {
-                    overallStatus: overallStatus
-                        ? BaseModel.toJSON(overallStatus, MonitorStatus)
-                        : null,
-                    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),
-                    activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
-                    activeEpisodes: activeEpisodesJson,
-                    episodePublicNotes: BaseModel.toJSONArray(episodePublicNotes, IncidentEpisodePublicNote),
-                    episodeStateTimelines: BaseModel.toJSONArray(episodeStateTimelines, IncidentEpisodeStateTimeline),
-                    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 = 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);
@@ -3609,10 +2978,693 @@ export default class StatusPageAPI extends BaseAPI {
             endDateForMonitorTimeline,
         };
     }
-    async getStatusPageAnnouncementAttachment(req, res) {
+    /*
+     * Builds the full overview payload for one status page. Everything below
+     * is a pure function of the statusPageId — every query runs with isRoot
+     * props and nothing is read from the request — which is what makes the
+     * result safe to cache and share across requests. The returned JSONObject
+     * must never be mutated after build.
+     */
+    async buildOverviewResponse(statusPageId) {
         var _a;
-        const statusPageIdParam = req.params["statusPageId"];
-        const announcementIdParam = req.params["announcementId"];
+        /*
+         * The timeline window comes from the status page's configured
+         * showUptimeHistoryInDays. getStatusPageResourcesAndTimelines
+         * fetches the status page row anyway, so let it compute the window
+         * (clamped to 1..90 days, ending now) instead of issuing a separate
+         * StatusPage query here just to read that one column.
+         */
+        const { monitorStatuses, monitorGroupCurrentStatuses, statusPageResources, statusPage, monitorsOnStatusPage, monitorStatusTimelines, statusPageGroups, monitorsInGroup, startDateForMonitorTimeline: startDate, endDateForMonitorTimeline: endDate, } = await this.getStatusPageResourcesAndTimelines({
+            statusPageId: statusPageId,
+        });
+        // check if status page has active incident.
+        let activeIncidents = [];
+        if (monitorsOnStatusPage.length > 0) {
+            let select = {
+                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 = Object.assign(Object.assign({}, select), { labels: {
+                        name: true,
+                        color: true,
+                    } });
+            }
+            const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(statusPage.projectId, {
+                isRoot: true,
+            });
+            const unresolvedIncidentStateIds = unresolvedIncidentStates.map((state) => {
+                return state.id;
+            });
+            if (statusPage.showIncidentsOnStatusPage) {
+                activeIncidents = await IncidentService.findBy({
+                    query: {
+                        monitors: monitorsOnStatusPage,
+                        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 = activeIncidents.map((incident) => {
+            return incident.id;
+        });
+        let incidentPublicNotes = [];
+        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,
+                    },
+                },
+                sort: {
+                    postedAt: SortOrder.Descending, // new note first
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        let incidentStateTimelines = [];
+        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,
+                        isCreatedState: true,
+                        isResolvedState: true,
+                        isAcknowledgedState: true,
+                    },
+                },
+                sort: {
+                    startsAt: SortOrder.Descending, // newer state changes first
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        // Fetch active episodes (similar to incidents)
+        let activeEpisodes = [];
+        let activeEpisodesJson = [];
+        let episodePublicNotes = [];
+        let episodeStateTimelines = [];
+        /*
+         * Cheap guard before the expensive part: the block below scans every
+         * incident ever attached to this page's monitors (a many-to-many
+         * join, up to LIMIT_PER_PROJECT rows) just to discover episode
+         * membership — on every overview view, even though most pages have
+         * zero active episodes most of the time. One indexed COUNT of the
+         * project's unresolved, visible episodes lets us skip all of it in
+         * the common case. Behavior-preserving: the final activeEpisodes
+         * query applies exactly these three constraints, so count == 0
+         * implies the block's outputs stay empty.
+         */
+        let unresolvedIncidentStateIds = [];
+        let hasActiveEpisodes = false;
+        if (statusPage.showEpisodesOnStatusPage &&
+            monitorsOnStatusPage.length > 0) {
+            const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(statusPage.projectId, { isRoot: true });
+            unresolvedIncidentStateIds = unresolvedIncidentStates.map((state) => {
+                return state.id;
+            });
+            const activeEpisodeCount = await IncidentEpisodeService.countBy({
+                query: {
+                    projectId: statusPage.projectId,
+                    isVisibleOnStatusPage: true,
+                    currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            hasActiveEpisodes = activeEpisodeCount.toNumber() > 0;
+        }
+        if (hasActiveEpisodes) {
+            // First, get incidents that have monitors on status page
+            const incidentsForEpisodes = await IncidentService.findBy({
+                query: {
+                    monitors: monitorsOnStatusPage,
+                    isVisibleOnStatusPage: true,
+                    projectId: statusPage.projectId,
+                },
+                select: {
+                    _id: true,
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+            const incidentIdsForEpisodes = incidentsForEpisodes.map((incident) => {
+                return incident.id;
+            });
+            // Get episode members for these incidents
+            let episodeMembers = [];
+            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 = new Set();
+            for (const member of episodeMembers) {
+                if (member.incidentEpisodeId) {
+                    episodeIdsFromMembers.add(member.incidentEpisodeId.toString());
+                }
+            }
+            // Fetch active (unresolved) episodes
+            if (episodeIdsFromMembers.size > 0) {
+                // unresolvedIncidentStateIds was fetched by the guard above.
+                let selectEpisodes = {
+                    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,
+                        order: true,
+                        isCreatedState: true,
+                        isAcknowledgedState: true,
+                        isResolvedState: true,
+                    },
+                    incidentCount: true,
+                };
+                if (statusPage.showEpisodeLabelsOnStatusPage) {
+                    selectEpisodes = Object.assign(Object.assign({}, selectEpisodes), { labels: {
+                            name: true,
+                            color: true,
+                        } });
+                }
+                activeEpisodes = await IncidentEpisodeService.findBy({
+                    query: {
+                        _id: QueryHelper.any(Array.from(episodeIdsFromMembers).map((id) => {
+                            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 = new Set(activeEpisodes.map((e) => {
+                        return e.id.toString();
+                    }));
+                    const memberIncidentIds = [];
+                    for (const member of episodeMembers) {
+                        if (member.incidentEpisodeId &&
+                            activeEpisodeIds.has(member.incidentEpisodeId.toString()) &&
+                            member.incidentId &&
+                            !memberIncidentIds.some((id) => {
+                                return id.toString() === member.incidentId.toString();
+                            })) {
+                            memberIncidentIds.push(member.incidentId);
+                        }
+                    }
+                    // Fetch incidents with monitors
+                    let memberIncidents = [];
+                    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,
+                            },
+                        });
+                    }
+                    // Build incident -> monitors map
+                    const incidentMonitorsMap = new Map();
+                    for (const incident of memberIncidents) {
+                        const incidentIdStr = incident.id.toString();
+                        const monitorIds = (incident.monitors || [])
+                            .map((m) => {
+                            var _a, _b;
+                            return new ObjectID(((_a = m._id) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = m.id) === null || _b === void 0 ? void 0 : _b.toString()) || "");
+                        })
+                            .filter((id) => {
+                            return id.toString() !== "";
+                        });
+                        incidentMonitorsMap.set(incidentIdStr, monitorIds);
+                    }
+                    // Build episode -> monitors map
+                    const episodeMonitorsMap = new Map();
+                    for (const member of episodeMembers) {
+                        if (member.incidentEpisodeId &&
+                            member.incidentId &&
+                            activeEpisodeIds.has(member.incidentEpisodeId.toString())) {
+                            const episodeIdStr = member.incidentEpisodeId.toString();
+                            const incidentIdStr = member.incidentId.toString();
+                            if (!episodeMonitorsMap.has(episodeIdStr)) {
+                                episodeMonitorsMap.set(episodeIdStr, []);
+                            }
+                            const episodeMonitors = episodeMonitorsMap.get(episodeIdStr);
+                            const incidentMonitors = incidentMonitorsMap.get(incidentIdStr) || [];
+                            for (const monitorId of incidentMonitors) {
+                                if (!episodeMonitors.some((m) => {
+                                    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 = episodeJson;
+                        const episodeId = (_a = episodeObj["_id"]) === null || _a === void 0 ? void 0 : _a.toString();
+                        if (episodeId) {
+                            const monitorIds = episodeMonitorsMap.get(episodeId) || [];
+                            episodeObj["monitors"] = monitorIds.map((id) => {
+                                return { _id: id.toString() };
+                            });
+                        }
+                    }
+                    // Get episode public notes
+                    const episodesOnStatusPage = activeEpisodes.map((episode) => {
+                        return episode.id;
+                    });
+                    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,
+                            },
+                        });
+                        // 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 announcement.
+        const today = OneUptimeDate.getCurrentDate();
+        let activeAnnouncements = [];
+        if (statusPage.showAnnouncementsOnStatusPage) {
+            activeAnnouncements = await StatusPageAnnouncementService.findBy({
+                query: {
+                    statusPages: statusPageId,
+                    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,
+                },
+            });
+        }
+        // check if status page has active scheduled events.
+        let scheduledEventsSelect = {
+            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 = Object.assign(Object.assign({}, scheduledEventsSelect), { labels: {
+                    name: true,
+                    color: true,
+                } });
+        }
+        let scheduledMaintenanceEvents = [];
+        if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
+            scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy({
+                query: {
+                    currentScheduledMaintenanceState: {
+                        isOngoingState: true,
+                    },
+                    statusPages: statusPageId,
+                    projectId: statusPage.projectId,
+                    isVisibleOnStatusPage: true,
+                },
+                select: scheduledEventsSelect,
+                sort: {
+                    startsAt: SortOrder.Ascending,
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        let futureScheduledMaintenanceEvents = [];
+        if (statusPage.showScheduledMaintenanceEventsOnStatusPage) {
+            futureScheduledMaintenanceEvents =
+                await ScheduledMaintenanceService.findBy({
+                    query: {
+                        currentScheduledMaintenanceState: {
+                            isScheduledState: true,
+                        },
+                        statusPages: statusPageId,
+                        projectId: statusPage.projectId,
+                        isVisibleOnStatusPage: true,
+                    },
+                    select: scheduledEventsSelect,
+                    sort: {
+                        startsAt: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+        }
+        futureScheduledMaintenanceEvents.forEach((event) => {
+            scheduledMaintenanceEvents.push(event);
+        });
+        const scheduledMaintenanceEventsOnStatusPage = scheduledMaintenanceEvents.map((event) => {
+            return event.id;
+        });
+        let scheduledMaintenanceEventsPublicNotes = [];
+        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,
+                    },
+                });
+        }
+        let scheduledMaintenanceStateTimelines = [];
+        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,
+                        },
+                    },
+                    sort: {
+                        startsAt: SortOrder.Descending, // newer state changes first
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+        }
+        // get all status page bar chart rules
+        const statusPageHistoryChartBarColorRules = 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,
+            },
+        });
+        /*
+         * Fetch all incidents (active + resolved) in the timeline date range
+         * for the uptime bar tooltip and click-through
+         */
+        let timelineIncidents = [];
+        if (monitorsOnStatusPage.length > 0 &&
+            statusPage.showIncidentsOnStatusPage) {
+            timelineIncidents = await IncidentService.findBy({
+                query: {
+                    monitors: monitorsOnStatusPage,
+                    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,
+                },
+            });
+        }
+        const overallStatus = StatusPageService.getOverallMonitorStatus({
+            statusPageResources,
+            monitorStatuses,
+            monitorGroupCurrentStatuses,
+        });
+        const response = {
+            overallStatus: overallStatus
+                ? BaseModel.toJSON(overallStatus, MonitorStatus)
+                : null,
+            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),
+            activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
+            activeEpisodes: activeEpisodesJson,
+            episodePublicNotes: BaseModel.toJSONArray(episodePublicNotes, IncidentEpisodePublicNote),
+            episodeStateTimelines: BaseModel.toJSONArray(episodeStateTimelines, IncidentEpisodeStateTimeline),
+            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 = 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),
+        };
+        return response;
+    }
+    async getStatusPageAnnouncementAttachment(req, res) {
+        var _a;
+        const statusPageIdParam = req.params["statusPageId"];
+        const announcementIdParam = req.params["announcementId"];
         const fileIdParam = req.params["fileId"];
         if (!statusPageIdParam || !announcementIdParam || !fileIdParam) {
             throw new NotFoundException("Attachment not found");
@@ -4131,6 +4183,20 @@ export default class StatusPageAPI extends BaseAPI {
         }
     }
 }
+/*
+ * Post-auth overview responses keyed by resolved statusPageId. The payload
+ * is user-independent (authorization is a binary gate checked per-request,
+ * before any cache read), so one short-TTL snapshot per page per process
+ * serves every viewer. See buildOverviewResponse.
+ */
+StatusPageAPI.overviewResponseCache = new InMemoryTTLCache(500);
+/*
+ * In-flight overview builds keyed by the same cache key, so concurrent
+ * cold-cache requests share one build instead of stampeding the database.
+ */
+StatusPageAPI.overviewResponseInFlight = new Map();
+StatusPageAPI.OVERVIEW_CACHE_TTL_MS = 15000;
+export default StatusPageAPI;
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),
@@ -4179,4 +4245,10 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], StatusPageAPI.prototype, "getStatusPageResourcesAndTimelines", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], StatusPageAPI.prototype, "buildOverviewResponse", null);
 //# sourceMappingURL=StatusPageAPI.js.map