@oneuptime/common 11.6.0 → 11.6.2

package/build/dist/Server/Services/NetworkSiteService.js

@@ -0,0 +1,1038 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import AlertService from "./AlertService";
+import AlertSeverityService from "./AlertSeverityService";
+import AlertStateTimelineService from "./AlertStateTimelineService";
+import DatabaseService from "./DatabaseService";
+import MonitorService from "./MonitorService";
+import MonitorStatusService from "./MonitorStatusService";
+import NetworkDeviceService from "./NetworkDeviceService";
+import NetworkSiteStatusTimelineService from "./NetworkSiteStatusTimelineService";
+import Model from "../../Models/DatabaseModels/NetworkSite";
+import Alert from "../../Models/DatabaseModels/Alert";
+import AlertStateTimeline from "../../Models/DatabaseModels/AlertStateTimeline";
+import NetworkSiteStatusTimeline from "../../Models/DatabaseModels/NetworkSiteStatusTimeline";
+import { DisableAutomaticAlertCreation } from "../EnvironmentConfig";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import QueryHelper from "../Types/Database/QueryHelper";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import NetworkDeviceHydrationUtil from "../Utils/Monitor/NetworkDeviceHydrationUtil";
+import logger from "../Utils/Logger";
+import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import MonitorType from "../../Types/Monitor/MonitorType";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import Text from "../../Types/Text";
+import { Raw } from "typeorm";
+import MaterializedPathUtil from "../../Utils/NetworkSite/MaterializedPathUtil";
+import SiteStatusRollupUtil from "../../Utils/NetworkSite/SiteStatusRollupUtil";
+export class Service extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    /*
+     * ------------------------------------------------------------------
+     * Hierarchy maintenance (materializedPath + depth)
+     * ------------------------------------------------------------------
+     */
+    /*
+     * The hierarchy hooks run BEFORE DatabaseService applies tenant scoping to
+     * the caller's query (ModelPermission.check*QueryPermissions runs after
+     * onBeforeUpdate / onBeforeDelete), so reading the raw client query with
+     * props.isRoot would hand the hook rows from other projects - which the
+     * success hooks then write. Re-apply the caller's tenant here so a hook can
+     * never see, let alone rewrite, a row outside the caller's project.
+     */
+    scopeQueryToCallerTenant(query, props) {
+        if (props.isRoot || !props.tenantId) {
+            return query;
+        }
+        return Object.assign(Object.assign({}, query), { projectId: props.tenantId });
+    }
+    /*
+     * Case-sensitive, un-CAST prefix predicate on materializedPath.
+     * QueryHelper.startsWith emits `CAST(alias AS TEXT) ILIKE :x`, and both the
+     * cast and the case-insensitive match make the btree index on the column
+     * unusable, so every rollup would sequentially scan the table. Paths are
+     * built from UUIDs only, so there are no LIKE wildcards to escape.
+     */
+    pathStartsWith(path) {
+        const rid = Text.generateRandomText(10);
+        return Raw((alias) => {
+            return `(${alias} LIKE :${rid})`;
+        }, {
+            [rid]: `${path}%`,
+        });
+    }
+    /*
+     * A stored path is trustworthy only when it agrees with parentSiteId: it
+     * must end with the site's own id, and the segment before it must be the
+     * parent (nothing before it for a root). A delete that nulls parentSiteId,
+     * or a half-applied move, leaves the two disagreeing - and a stale path
+     * silently corrupts every prefix query built from it, so treat it as
+     * missing and let the caller rebuild.
+     */
+    isPathConsistent(site) {
+        if (!site.id) {
+            return false;
+        }
+        const segments = MaterializedPathUtil.segmentsOf(site.materializedPath);
+        if (segments.length === 0) {
+            return false;
+        }
+        if (segments[segments.length - 1] !== site.id.toString()) {
+            return false;
+        }
+        const parentSegment = segments.length > 1 ? segments[segments.length - 2] : null;
+        const parentId = site.parentSiteId
+            ? site.parentSiteId.toString()
+            : null;
+        return parentSegment === parentId;
+    }
+    async onBeforeCreate(createBy) {
+        let parentPath = null;
+        if (createBy.data.parentSiteId) {
+            const parent = await this.findOneById({
+                id: createBy.data.parentSiteId,
+                select: {
+                    _id: true,
+                    projectId: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!parent) {
+                throw new BadDataException("Parent site not found.");
+            }
+            if (createBy.data.projectId &&
+                parent.projectId &&
+                parent.projectId.toString() !== createBy.data.projectId.toString()) {
+                throw new BadDataException("Parent site must belong to the same project.");
+            }
+            parentPath = await this.getMaterializedPathForSite(createBy.data.parentSiteId);
+        }
+        return {
+            createBy: createBy,
+            carryForward: {
+                parentPath: parentPath,
+            },
+        };
+    }
+    async onCreateSuccess(onCreate, createdItem) {
+        var _a;
+        if (!createdItem.id) {
+            return createdItem;
+        }
+        const parentPath = ((_a = onCreate.carryForward) === null || _a === void 0 ? void 0 : _a.parentPath) || null;
+        const path = MaterializedPathUtil.buildPath(parentPath, createdItem.id.toString());
+        await this.updateColumnsByIdWithoutHooks({
+            id: createdItem.id,
+            data: {
+                materializedPath: path,
+                depth: MaterializedPathUtil.depthOf(path),
+            },
+        });
+        createdItem.materializedPath = path;
+        createdItem.depth = MaterializedPathUtil.depthOf(path);
+        return createdItem;
+    }
+    async onBeforeUpdate(updateBy) {
+        const dataKeys = Object.keys(updateBy.data || {});
+        if (!dataKeys.includes("parentSiteId")) {
+            return { updateBy, carryForward: null };
+        }
+        const newParentIdValue = updateBy.data["parentSiteId"];
+        const newParentId = newParentIdValue
+            ? new ObjectID(newParentIdValue.toString())
+            : null;
+        const previousItems = await this.findBy({
+            query: this.scopeQueryToCallerTenant(updateBy.query, updateBy.props),
+            select: {
+                _id: true,
+                projectId: true,
+                parentSiteId: true,
+                materializedPath: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        /*
+         * Same-project assertion for EVERY parentSiteId write, including the
+         * detach case (parentSiteId: null) which has no parent to compare
+         * against: onUpdateSuccess rewrites each matched site's whole subtree, so
+         * a site outside the caller's project must never reach it.
+         */
+        if (updateBy.props.tenantId) {
+            for (const item of previousItems) {
+                if (item.projectId &&
+                    item.projectId.toString() !== updateBy.props.tenantId.toString()) {
+                    throw new BadDataException("Network site must belong to the same project.");
+                }
+            }
+        }
+        let newParentPath = null;
+        if (newParentId) {
+            const parent = await this.findOneById({
+                id: newParentId,
+                select: {
+                    _id: true,
+                    projectId: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!parent) {
+                throw new BadDataException("Parent site not found.");
+            }
+            for (const item of previousItems) {
+                if (item.id && item.id.toString() === newParentId.toString()) {
+                    throw new BadDataException("A site cannot be its own parent.");
+                }
+                if (item.projectId &&
+                    parent.projectId &&
+                    item.projectId.toString() !== parent.projectId.toString()) {
+                    throw new BadDataException("Parent site must belong to the same project.");
+                }
+            }
+            newParentPath = await this.getMaterializedPathForSite(newParentId);
+            for (const item of previousItems) {
+                if (item.id &&
+                    MaterializedPathUtil.wouldCreateCycle(item.id.toString(), newParentPath)) {
+                    throw new BadDataException("Cannot move a site under itself or one of its own descendants.");
+                }
+            }
+        }
+        const carryForward = {
+            previousItems: previousItems,
+            newParentId: newParentId,
+            newParentPath: newParentPath,
+        };
+        return { updateBy, carryForward };
+    }
+    async onUpdateSuccess(onUpdate, updatedItemIds) {
+        var _a;
+        const parentChange = onUpdate.carryForward || null;
+        if (!parentChange) {
+            return onUpdate;
+        }
+        /*
+         * DatabaseService calls onUpdateSuccess even when the tenant-scoped
+         * UPDATE matched zero rows, so the carried previousItems are not proof
+         * that anything was written. Only rows the UPDATE actually matched may be
+         * rebased here.
+         */
+        const updatedIds = new Set(updatedItemIds.map((id) => {
+            return id.toString();
+        }));
+        for (const previousItem of parentChange.previousItems) {
+            if (!previousItem.id || !updatedIds.has(previousItem.id.toString())) {
+                continue;
+            }
+            const oldPath = previousItem.materializedPath || null;
+            const newPath = MaterializedPathUtil.buildPath(parentChange.newParentPath, previousItem.id.toString());
+            if (oldPath === newPath) {
+                continue;
+            }
+            // Rebase the moved site itself...
+            await this.updateColumnsByIdWithoutHooks({
+                id: previousItem.id,
+                data: {
+                    materializedPath: newPath,
+                    depth: MaterializedPathUtil.depthOf(newPath),
+                },
+            });
+            // ...then its entire subtree in one prefix query.
+            if (oldPath) {
+                const descendants = await this.findBy({
+                    query: {
+                        projectId: previousItem.projectId,
+                        materializedPath: this.pathStartsWith(oldPath),
+                    },
+                    select: {
+                        _id: true,
+                        materializedPath: true,
+                    },
+                    limit: LIMIT_MAX,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                for (const descendant of descendants) {
+                    if (!descendant.id ||
+                        !descendant.materializedPath ||
+                        descendant.id.toString() === previousItem.id.toString()) {
+                        continue;
+                    }
+                    const rebasedPath = MaterializedPathUtil.rebasePaths(oldPath, newPath, [descendant.materializedPath])[0];
+                    await this.updateColumnsByIdWithoutHooks({
+                        id: descendant.id,
+                        data: {
+                            materializedPath: rebasedPath,
+                            depth: MaterializedPathUtil.depthOf(rebasedPath),
+                        },
+                    });
+                }
+            }
+            /*
+             * Moving a subtree changes the rollup of both the new ancestor chain
+             * (via the moved site) and the old one (via the old parent). Rollup
+             * failures must never fail the move itself - the cron backstop
+             * reconciles.
+             */
+            try {
+                await this.recomputeRollupForSiteAndAncestors(previousItem.id);
+                if (previousItem.parentSiteId) {
+                    await this.recomputeRollupForSiteAndAncestors(previousItem.parentSiteId);
+                }
+            }
+            catch (error) {
+                logger.error(`NetworkSiteService.onUpdateSuccess: rollup after site move failed for site ${previousItem.id.toString()}: ${error}`, {
+                    projectId: (_a = previousItem.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
+                    siteId: previousItem.id.toString(),
+                });
+            }
+        }
+        return onUpdate;
+    }
+    /*
+     * Deletes are hard deletes, so the rows' hierarchy state has to be captured
+     * before they disappear. Scoped to the caller's tenant for the same reason
+     * onBeforeUpdate is: this hook runs before the delete query is permission
+     * checked.
+     */
+    async onBeforeDelete(deleteBy) {
+        const sitesToDelete = await this.findBy({
+            query: this.scopeQueryToCallerTenant(deleteBy.query, deleteBy.props),
+            select: {
+                _id: true,
+                projectId: true,
+                parentSiteId: true,
+                materializedPath: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const carryForward = {
+            sitesToDelete: sitesToDelete,
+        };
+        return { deleteBy, carryForward };
+    }
+    /*
+     * parentSiteId is declared onDelete: "SET NULL", so Postgres detaches the
+     * deleted site's direct children but leaves their materializedPath - and
+     * their whole subtree's - routed through a row that no longer exists. That
+     * strands the subtree: the children endpoint (which reads parentSiteId)
+     * shows them at the root while the rollup engine (which reads
+     * materializedPath) still folds them into the dead ancestor's chain, double
+     * counting every outage. Re-attach the orphans to the deleted site's own
+     * parent - NULL when it was a root, which is exactly what the FK did - and
+     * rebase the subtree paths so both readers agree again.
+     */
+    async onDeleteSuccess(onDelete, itemIdsBeforeDelete) {
+        const carryForward = onDelete.carryForward || null;
+        if (!carryForward) {
+            return onDelete;
+        }
+        // Only rows the permission-checked delete actually removed.
+        const deletedIds = new Set(itemIdsBeforeDelete.map((id) => {
+            return id.toString();
+        }));
+        for (const deletedSite of carryForward.sitesToDelete) {
+            if (!deletedSite.id ||
+                !deletedSite.projectId ||
+                !deletedIds.has(deletedSite.id.toString())) {
+                continue;
+            }
+            /*
+             * Repair failures must never fail the delete itself - the row is
+             * already gone, and getMaterializedPathForSite self-heals a stranded
+             * path on next use.
+             */
+            try {
+                await this.reattachOrphanedSubtree(deletedSite);
+            }
+            catch (error) {
+                logger.error(`NetworkSiteService.onDeleteSuccess: subtree repair after deleting site ${deletedSite.id.toString()} failed: ${error}`, {
+                    projectId: deletedSite.projectId.toString(),
+                    siteId: deletedSite.id.toString(),
+                });
+            }
+        }
+        return onDelete;
+    }
+    /*
+     * Rewrites the deleted site's former subtree so the '/deletedId/' segment
+     * is dropped from every path, and re-points its direct children at the
+     * deleted site's parent.
+     */
+    async reattachOrphanedSubtree(deletedSite) {
+        const oldPath = deletedSite.materializedPath || null;
+        if (!oldPath || !deletedSite.id) {
+            return;
+        }
+        const parentPath = deletedSite.parentSiteId
+            ? await this.getMaterializedPathForSite(deletedSite.parentSiteId)
+            : null;
+        const deletedDepth = MaterializedPathUtil.segmentsOf(oldPath).length;
+        const descendants = await this.findBy({
+            query: {
+                projectId: deletedSite.projectId,
+                materializedPath: this.pathStartsWith(oldPath),
+            },
+            select: {
+                _id: true,
+                materializedPath: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const descendant of descendants) {
+            if (!descendant.id ||
+                !descendant.materializedPath ||
+                descendant.id.toString() === deletedSite.id.toString()) {
+                continue;
+            }
+            const tailSegments = MaterializedPathUtil.segmentsOf(descendant.materializedPath).slice(deletedDepth);
+            if (tailSegments.length === 0) {
+                continue;
+            }
+            let rebasedPath = parentPath;
+            for (const segment of tailSegments) {
+                rebasedPath = MaterializedPathUtil.buildPath(rebasedPath, segment);
+            }
+            const data = {
+                materializedPath: rebasedPath,
+                depth: MaterializedPathUtil.depthOf(rebasedPath),
+            };
+            // A direct child is the one the FK just detached - give it a parent back.
+            if (tailSegments.length === 1) {
+                data["parentSiteId"] = deletedSite.parentSiteId || null;
+            }
+            await this.updateColumnsByIdWithoutHooks({
+                id: descendant.id,
+                data: data,
+            });
+        }
+        /*
+         * The deleted site's own devices were detached by their FK too, so the
+         * surviving ancestor chain's rollup is now stale.
+         */
+        if (deletedSite.parentSiteId) {
+            await this.recomputeRollupForSiteAndAncestors(deletedSite.parentSiteId);
+        }
+    }
+    /*
+     * Returns the site's materialized path, rebuilding (and persisting) it by
+     * walking up the parent chain when the stored value is missing OR no longer
+     * agrees with parentSiteId - a row created before path maintenance existed,
+     * one whose maintenance write failed, or one stranded by a deleted
+     * ancestor, self-heals on first use.
+     */
+    async getMaterializedPathForSite(siteId) {
+        var _a;
+        const site = await this.findOneById({
+            id: siteId,
+            select: {
+                _id: true,
+                parentSiteId: true,
+                materializedPath: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!site || !site.id) {
+            return null;
+        }
+        if (site.materializedPath && this.isPathConsistent(site)) {
+            return site.materializedPath;
+        }
+        /*
+         * Walk up until a parent with a stored path (or a root) is found. The
+         * visited set guards against pre-existing cycles in the data - without
+         * it a corrupted parent chain would loop forever.
+         */
+        const chain = [site];
+        const visited = new Set([site.id.toString()]);
+        let prefixPath = null;
+        let cursor = site;
+        while (cursor.parentSiteId) {
+            if (visited.has(cursor.parentSiteId.toString())) {
+                logger.error(`NetworkSiteService.getMaterializedPathForSite: cycle detected in parent chain of site ${siteId.toString()}; treating ${(_a = cursor.id) === null || _a === void 0 ? void 0 : _a.toString()} as a root.`);
+                break;
+            }
+            const parent = await this.findOneById({
+                id: cursor.parentSiteId,
+                select: {
+                    _id: true,
+                    parentSiteId: true,
+                    materializedPath: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!parent || !parent.id) {
+                break;
+            }
+            // A stale ancestor path would poison every path rebuilt from it.
+            if (parent.materializedPath && this.isPathConsistent(parent)) {
+                prefixPath = parent.materializedPath;
+                break;
+            }
+            visited.add(parent.id.toString());
+            chain.push(parent);
+            cursor = parent;
+        }
+        // Fold back down, persisting the healed paths as we go.
+        let path = prefixPath;
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const chainSite = chain[i];
+            path = MaterializedPathUtil.buildPath(path, chainSite.id.toString());
+            await this.updateColumnsByIdWithoutHooks({
+                id: chainSite.id,
+                data: {
+                    materializedPath: path,
+                    depth: MaterializedPathUtil.depthOf(path),
+                },
+            });
+        }
+        return path;
+    }
+    // Ancestor IDs from root to direct parent (excludes the site itself).
+    async getAncestorIds(siteId) {
+        const path = await this.getMaterializedPathForSite(siteId);
+        if (!path) {
+            return [];
+        }
+        return MaterializedPathUtil.segmentsOf(path)
+            .filter((segment) => {
+            return segment !== siteId.toString();
+        })
+            .map((segment) => {
+            return new ObjectID(segment);
+        });
+    }
+    /*
+     * Strict descendant IDs (excludes the site itself), via path prefix query.
+     * projectId is required by every production caller: without it the prefix
+     * scan has no indexable predicate and reads every tenant's rows.
+     */
+    async getDescendantSiteIds(siteId, projectId) {
+        const path = await this.getMaterializedPathForSite(siteId);
+        if (!path) {
+            return [];
+        }
+        const query = {
+            materializedPath: this.pathStartsWith(path),
+        };
+        if (projectId) {
+            query.projectId = projectId;
+        }
+        const descendants = await this.findBy({
+            query: query,
+            select: {
+                _id: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        return descendants
+            .filter((descendant) => {
+            return descendant.id && descendant.id.toString() !== siteId.toString();
+        })
+            .map((descendant) => {
+            return descendant.id;
+        });
+    }
+    /*
+     * ------------------------------------------------------------------
+     * Persisted rollup engine
+     * ------------------------------------------------------------------
+     */
+    /*
+     * Recomputes the worst-of rollup for one site from the devices in its
+     * subtree, persisting currentMonitorStatusId + lastRollupAt and keeping
+     * the NetworkSiteStatusTimeline in sync (close the open row, open a new
+     * one) whenever the status actually changes.
+     */
+    async recomputeRollupForSite(siteId) {
+        var _a;
+        const site = await this.findOneById({
+            id: siteId,
+            select: {
+                _id: true,
+                projectId: true,
+                currentMonitorStatusId: true,
+                name: true,
+                shouldAlertWhenUnhealthy: true,
+                alertSeverityId: true,
+                currentActiveAlertId: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!site || !site.id || !site.projectId) {
+            return;
+        }
+        const subtreeSiteIds = [
+            site.id,
+            ...(await this.getDescendantSiteIds(site.id, site.projectId)),
+        ];
+        /*
+         * Archived devices are decommissioned: they keep their siteId but must
+         * not vote in the rollup. An archived, never-monitored device otherwise
+         * falls through to the freshness fallback (stale lastSeenAt -> Offline)
+         * and pins its whole ancestor chain red forever, with the drill-down
+         * showing zero devices because that query excludes archived rows.
+         */
+        const devices = await NetworkDeviceService.findBy({
+            query: {
+                projectId: site.projectId,
+                siteId: QueryHelper.any(subtreeSiteIds),
+                isArchived: false,
+            },
+            select: {
+                _id: true,
+                currentMonitorStatusId: true,
+                lastSeenAt: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const statuses = await MonitorStatusService.findBy({
+            query: {
+                projectId: site.projectId,
+            },
+            select: {
+                _id: true,
+                name: true,
+                priority: true,
+                isOperationalState: true,
+                isOfflineState: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const priorityByStatusId = new Map();
+        let operationalStatus = null;
+        let offlineStatus = null;
+        for (const status of statuses) {
+            if (!status.id || typeof status.priority !== "number") {
+                continue;
+            }
+            priorityByStatusId.set(status.id.toString(), status.priority);
+            if (status.isOperationalState && !operationalStatus) {
+                operationalStatus = {
+                    monitorStatusId: status.id.toString(),
+                    priority: status.priority,
+                };
+            }
+            if (status.isOfflineState && !offlineStatus) {
+                offlineStatus = {
+                    monitorStatusId: status.id.toString(),
+                    priority: status.priority,
+                };
+            }
+        }
+        const deviceStates = devices.map((device) => {
+            var _a;
+            const statusId = (_a = device.currentMonitorStatusId) === null || _a === void 0 ? void 0 : _a.toString();
+            return {
+                currentMonitorStatusId: statusId,
+                monitorStatusPriority: statusId
+                    ? priorityByStatusId.get(statusId)
+                    : undefined,
+                lastSeenAt: device.lastSeenAt,
+            };
+        });
+        const worstStatusId = SiteStatusRollupUtil.worstStatus({
+            deviceStates: deviceStates,
+            operationalStatus: operationalStatus,
+            offlineStatus: offlineStatus,
+        });
+        const now = OneUptimeDate.getCurrentDate();
+        const currentStatusId = ((_a = site.currentMonitorStatusId) === null || _a === void 0 ? void 0 : _a.toString()) || null;
+        // No devices contribute -> leave the status alone, just stamp the run.
+        if (!worstStatusId || worstStatusId === currentStatusId) {
+            await this.updateColumnsByIdWithoutHooks({
+                id: site.id,
+                data: {
+                    lastRollupAt: now,
+                },
+            });
+            return;
+        }
+        await this.updateColumnsByIdWithoutHooks({
+            id: site.id,
+            data: {
+                currentMonitorStatusId: new ObjectID(worstStatusId),
+                lastRollupAt: now,
+            },
+        });
+        // Close every open timeline row, then open one for the new status.
+        await NetworkSiteStatusTimelineService.updateBy({
+            query: {
+                siteId: site.id,
+                endsAt: QueryHelper.isNull(),
+            },
+            data: {
+                endsAt: now,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const timeline = new NetworkSiteStatusTimeline();
+        timeline.projectId = site.projectId;
+        timeline.siteId = site.id;
+        timeline.monitorStatusId = new ObjectID(worstStatusId);
+        timeline.startsAt = now;
+        await NetworkSiteStatusTimelineService.create({
+            data: timeline,
+            props: {
+                isRoot: true,
+            },
+        });
+        /*
+         * Site alerting rides the same transition the timeline records. Alert
+         * bookkeeping must never break the rollup itself.
+         */
+        try {
+            await this.syncSiteAlertForStatusTransition({
+                site: site,
+                newStatus: statuses.find((status) => {
+                    var _a;
+                    return ((_a = status.id) === null || _a === void 0 ? void 0 : _a.toString()) === worstStatusId;
+                }) || null,
+            });
+        }
+        catch (err) {
+            logger.error(`Network site rollup: error syncing alert for site ${site.id.toString()}:`);
+            logger.error(err);
+        }
+    }
+    /*
+     * Opens an alert when a site's rollup TRANSITIONS to a non-operational
+     * status (and alerting is enabled on the site), and auto-resolves that
+     * alert when the site transitions back to operational. Transition-only
+     * by design: enabling alerting on an already-unhealthy site arms the
+     * next transition instead of retro-alerting, and a manually resolved
+     * alert is not reopened until the site recovers and degrades again
+     * (a transition clears the tracked id).
+     */
+    async syncSiteAlertForStatusTransition(data) {
+        const site = data.site;
+        if (!site.id || !site.projectId || !data.newStatus) {
+            return;
+        }
+        const isNowOperational = Boolean(data.newStatus.isOperationalState);
+        // Recovery: resolve the open site alert, if one is tracked.
+        if (isNowOperational) {
+            if (!site.currentActiveAlertId) {
+                return;
+            }
+            await this.resolveSiteAlert({
+                projectId: site.projectId,
+                alertId: site.currentActiveAlertId,
+                rootCause: `**Recovered:** Network site **${site.name || "site"}** rolled back up to ${data.newStatus.name || "an operational status"}.`,
+            });
+            await this.updateColumnsByIdWithoutHooks({
+                id: site.id,
+                data: {
+                    currentActiveAlertId: null,
+                },
+            });
+            return;
+        }
+        // Degradation between two unhealthy statuses keeps the existing alert.
+        if (!site.shouldAlertWhenUnhealthy ||
+            site.currentActiveAlertId ||
+            DisableAutomaticAlertCreation) {
+            return;
+        }
+        let alertSeverityId = site.alertSeverityId;
+        if (!alertSeverityId) {
+            // Same default the monitor alert path uses: the most severe first.
+            const severity = await AlertSeverityService.findOneBy({
+                query: {
+                    projectId: site.projectId,
+                },
+                sort: {
+                    order: SortOrder.Ascending,
+                },
+                select: {
+                    _id: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!severity || !severity.id) {
+                logger.warn(`Network site alerting: project ${site.projectId.toString()} has no alert severity; skipping site alert.`);
+                return;
+            }
+            alertSeverityId = severity.id;
+        }
+        const statusName = data.newStatus.name || "Unhealthy";
+        const alert = new Alert();
+        alert.projectId = site.projectId;
+        alert.title = `Network site ${site.name || site.id.toString()} is ${statusName}`;
+        alert.description = `The health rollup of network site **${site.name || site.id.toString()}** changed to **${statusName}** — the worst status of the devices at this site and every site below it. This alert auto-resolves when the site rolls back up to an operational status.`;
+        alert.alertSeverityId = alertSeverityId;
+        alert.rootCause = `Network site **${site.name || site.id.toString()}** rolled up to **${statusName}**.`;
+        const createdAlert = await AlertService.create({
+            data: alert,
+            props: {
+                isRoot: true,
+            },
+        });
+        if (createdAlert.id) {
+            await this.updateColumnsByIdWithoutHooks({
+                id: site.id,
+                data: {
+                    currentActiveAlertId: createdAlert.id,
+                },
+            });
+        }
+    }
+    // Moves a site alert to the project's resolved state, if not already there.
+    async resolveSiteAlert(data) {
+        var _a;
+        const alert = await AlertService.findOneById({
+            id: data.alertId,
+            select: {
+                _id: true,
+                currentAlertStateId: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!alert || !alert.id) {
+            // Deleted by hand — nothing to resolve.
+            return;
+        }
+        const resolvedStateId = await AlertStateTimelineService.getResolvedStateIdForProject(data.projectId);
+        if (((_a = alert.currentAlertStateId) === null || _a === void 0 ? void 0 : _a.toString()) === resolvedStateId.toString()) {
+            // Already resolved manually.
+            return;
+        }
+        const alertStateTimeline = new AlertStateTimeline();
+        alertStateTimeline.alertId = alert.id;
+        alertStateTimeline.alertStateId = resolvedStateId;
+        alertStateTimeline.projectId = data.projectId;
+        alertStateTimeline.rootCause = data.rootCause;
+        await AlertStateTimelineService.create({
+            data: alertStateTimeline,
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+    // Recomputes the site itself, then each ancestor (nearest first).
+    async recomputeRollupForSiteAndAncestors(siteId) {
+        await this.recomputeRollupForSite(siteId);
+        const ancestorIds = await this.getAncestorIds(siteId);
+        // getAncestorIds returns root-first; recompute nearest ancestor first.
+        for (let i = ancestorIds.length - 1; i >= 0; i--) {
+            await this.recomputeRollupForSite(ancestorIds[i]);
+        }
+    }
+    /*
+     * ------------------------------------------------------------------
+     * Monitor status bridge
+     * ------------------------------------------------------------------
+     */
+    /*
+     * Called by MonitorService.changeMonitorStatus after a status persists.
+     * Resolves which NetworkDevices the monitors reference in their steps,
+     * stamps those devices' currentMonitorStatusId, then recomputes the
+     * rollup for every affected site chain. Never throws - a rollup failure
+     * must never break a monitor status change.
+     */
+    async onMonitorStatusChanged(data) {
+        try {
+            if (data.monitorIds.length === 0) {
+                return;
+            }
+            const monitors = await MonitorService.findBy({
+                query: {
+                    _id: QueryHelper.any(data.monitorIds),
+                    projectId: data.projectId,
+                    monitorType: MonitorType.NetworkDevice,
+                },
+                select: {
+                    _id: true,
+                    monitorType: true,
+                    monitorSteps: true,
+                },
+                limit: LIMIT_MAX,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (monitors.length === 0) {
+                return;
+            }
+            const deviceIds = NetworkDeviceHydrationUtil.getReferencedNetworkDeviceIds(monitors);
+            if (deviceIds.length === 0) {
+                return;
+            }
+            const devices = await NetworkDeviceService.findBy({
+                query: {
+                    _id: QueryHelper.any(deviceIds),
+                    projectId: data.projectId,
+                },
+                select: {
+                    _id: true,
+                    siteId: true,
+                },
+                limit: LIMIT_MAX,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            for (const device of devices) {
+                if (!device.id) {
+                    continue;
+                }
+                await NetworkDeviceService.updateColumnsByIdWithoutHooks({
+                    id: device.id,
+                    data: {
+                        currentMonitorStatusId: data.monitorStatusId,
+                    },
+                });
+            }
+            const distinctSiteIds = new Map();
+            for (const device of devices) {
+                if (device.siteId) {
+                    distinctSiteIds.set(device.siteId.toString(), device.siteId);
+                }
+            }
+            for (const siteId of distinctSiteIds.values()) {
+                await this.recomputeRollupForSiteAndAncestors(siteId);
+            }
+        }
+        catch (error) {
+            logger.error(`NetworkSiteService.onMonitorStatusChanged: failed to update network site rollups: ${error}`, {
+                projectId: data.projectId.toString(),
+                monitorStatusId: data.monitorStatusId.toString(),
+            });
+        }
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeCreate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Model]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onCreateSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeUpdate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onUpdateSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeDelete", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onDeleteSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getMaterializedPathForSite", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getAncestorIds", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID, Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getDescendantSiteIds", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "recomputeRollupForSite", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "syncSiteAlertForStatusTransition", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "recomputeRollupForSiteAndAncestors", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onMonitorStatusChanged", null);
+export default new Service();
+//# sourceMappingURL=NetworkSiteService.js.map