@oneuptime/common 14.0.1 → 14.0.3

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

@@ -34,7 +34,8 @@ import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import { applyIncidentSelfPrivacyFilter } from "../Utils/Incident/IncidentPrivacyFilter";
-import ProjectScopedReferenceValidator, { resolveReferenceId, } from "../Utils/Database/ProjectScopedReferenceValidator";
+import ProjectScopedReferenceValidator, { resolveReferenceId, resolveReferenceIds, } from "../Utils/Database/ProjectScopedReferenceValidator";
+import { getAffectedResourceRelations } from "../Utils/Database/AffectedResourceRelations";
 import SloRecordReferenceValidator from "../Utils/Slo/SloRecordReferenceValidator";
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
@@ -85,6 +86,8 @@ import AIService from "./AIService";
 import AIIncidentInvestigationRunner from "../Utils/AI/SRE/IncidentInvestigationRunner";
 import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
 import IncidentAIContextBuilder from "../Utils/AI/IncidentAIContextBuilder";
+import IncidentAlertService from "./IncidentAlertService";
+import { INCIDENT_ALERT_IDS_TO_LINK_KEY } from "../../Types/Incident/IncidentAlertLink";
 export class Service extends DatabaseService {
     constructor() {
         super(Model);
@@ -433,10 +436,19 @@ export class Service extends DatabaseService {
          * SloRecordReferenceValidator.
          */
         const hasServiceLevelObjectiveIds = SloRecordReferenceValidator.getReferencedIds(updateBy.data.serviceLevelObjectives).length > 0;
+        /*
+         * The monitors, on-call policies, labels and affected-resource lists,
+         * when the update rewrites them. An empty list only removes rows and
+         * needs no check.
+         */
+        const relations = this.getProjectScopedRelations().filter((relation) => {
+            return (resolveReferenceIds(updateBy.data[relation.column]).length > 0);
+        });
         if (!incidentStateId &&
             !incidentSeverityId &&
             !changeMonitorStatusToId &&
-            !hasServiceLevelObjectiveIds) {
+            !hasServiceLevelObjectiveIds &&
+            relations.length === 0) {
             return;
         }
         /*
@@ -446,6 +458,15 @@ export class Service extends DatabaseService {
         const projectIds = updateBy.props.tenantId
             ? [updateBy.props.tenantId]
             : await this.getProjectIdsForUpdateQuery(updateBy);
+        const heldIds = relations.length > 0
+            ? await ProjectScopedReferenceValidator.getHeldRelationIds({
+                service: this,
+                query: updateBy.query,
+                columns: relations.map((relation) => {
+                    return relation.column;
+                }),
+            })
+            : undefined;
         for (const projectId of projectIds) {
             if (hasServiceLevelObjectiveIds) {
                 await SloRecordReferenceValidator.validateServiceLevelObjectivesBelongToProject({
@@ -454,32 +475,67 @@ export class Service extends DatabaseService {
                     serviceLevelObjectives: updateBy.data.serviceLevelObjectives,
                 });
             }
-            if (!incidentStateId && !incidentSeverityId && !changeMonitorStatusToId) {
+            const references = [
+                {
+                    modelName: "Incident State",
+                    id: incidentStateId,
+                    service: IncidentStateService,
+                },
+                {
+                    modelName: "Incident Severity",
+                    id: incidentSeverityId,
+                    service: IncidentSeverityService,
+                },
+                {
+                    modelName: "Monitor Status",
+                    id: changeMonitorStatusToId,
+                    service: MonitorStatusService,
+                },
+                ...ProjectScopedReferenceValidator.getRelationReferences({
+                    payload: updateBy.data,
+                    relations: relations,
+                    projectId: projectId,
+                    heldIds: heldIds,
+                }),
+            ];
+            if (references.every((reference) => {
+                return !reference.id;
+            })) {
                 continue;
             }
             await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
                 projectId: projectId,
                 subject: "incident",
-                references: [
-                    {
-                        modelName: "Incident State",
-                        id: incidentStateId,
-                        service: IncidentStateService,
-                    },
-                    {
-                        modelName: "Incident Severity",
-                        id: incidentSeverityId,
-                        service: IncidentSeverityService,
-                    },
-                    {
-                        modelName: "Monitor Status",
-                        id: changeMonitorStatusToId,
-                        service: MonitorStatusService,
-                    },
-                ],
+                references: references,
             });
         }
     }
+    /*
+     * The many-to-many lists whose ids must belong to the incident's project.
+     * Built per call rather than at module load: these services sit in an
+     * import graph that loops back to this one, and a module-level table would
+     * capture whichever of them had not finished loading yet as undefined.
+     */
+    getProjectScopedRelations() {
+        return [
+            {
+                column: "monitors",
+                modelName: "Monitor",
+                service: MonitorService,
+            },
+            {
+                column: "labels",
+                modelName: "Label",
+                service: LabelService,
+            },
+            {
+                column: "onCallDutyPolicies",
+                modelName: "On-Call Policy",
+                service: OnCallDutyPolicyService,
+            },
+            ...getAffectedResourceRelations(this.getModel()),
+        ];
+    }
     async getProjectIdsForUpdateQuery(updateBy) {
         const incidents = await this.findBy({
             query: updateBy.query,
@@ -501,7 +557,7 @@ export class Service extends DatabaseService {
         return Object.values(projectIds);
     }
     async onBeforeCreate(createBy) {
-        var _a;
+        var _a, _b;
         if (!createBy.props.tenantId && !createBy.props.isRoot) {
             throw new BadDataException("ProjectId required to create incident.");
         }
@@ -511,6 +567,25 @@ export class Service extends DatabaseService {
                 false;
         }
         const projectId = createBy.props.tenantId || createBy.data.projectId;
+        /*
+         * Declaring the incident from alerts. The alert ids are checked here,
+         * before the incident number is taken and before anything is written, so
+         * a bad id (a typo, another project's alert, an alert the caller cannot
+         * see, too many alerts) rejects the whole request instead of leaving an
+         * incident behind that is missing some of its alerts. The alerts are
+         * linked in onCreateSuccess, once the incident exists.
+         */
+        let carryForward = null;
+        const alertIdsToLink = (_a = createBy.miscDataProps) === null || _a === void 0 ? void 0 : _a[INCIDENT_ALERT_IDS_TO_LINK_KEY];
+        if (alertIdsToLink !== undefined && alertIdsToLink !== null) {
+            carryForward = {
+                alertIdsToLink: await IncidentAlertService.validateAlertIdsForNewIncident({
+                    projectId: projectId,
+                    alertIds: alertIdsToLink,
+                    props: createBy.props,
+                }),
+            };
+        }
         if (!createBy.data.declaredAt) {
             createBy.data.declaredAt = OneUptimeDate.getCurrentDate();
         }
@@ -610,7 +685,7 @@ export class Service extends DatabaseService {
                 }
             }
             if (incidentTemplate) {
-                if (!((_a = createBy.data.incidentSeverityId) === null || _a === void 0 ? void 0 : _a.toString()) &&
+                if (!((_b = createBy.data.incidentSeverityId) === null || _b === void 0 ? void 0 : _b.toString()) &&
                     incidentTemplate.incidentSeverityId) {
                     createBy.data.incidentSeverityId =
                         incidentTemplate.incidentSeverityId;
@@ -716,6 +791,15 @@ export class Service extends DatabaseService {
          * caller, an incident template or a monitor criteria, and none of those
          * paths checked that the record belongs to this project. Persisting
          * another project's id leaves that project undeletable, so reject it here.
+         *
+         * The monitors, on-call policies and labels lists are checked for the same
+         * reason and a worse one: onCreateSuccess changes the status of every
+         * listed monitor and executes every listed on-call policy, so another
+         * project's ids here would page that project's on-call and flip its
+         * monitors for this project's incident. The affected-resource lists are
+         * checked too (see getAffectedResourceRelations). Lists copied from the
+         * template above are checked like any other payload.
+         *
          * Runs before the counter increment so a rejected create does not burn an
          * incident number.
          */
@@ -740,6 +824,10 @@ export class Service extends DatabaseService {
                         resolveReferenceId(createBy.data.changeMonitorStatusTo),
                     service: MonitorStatusService,
                 },
+                ...ProjectScopedReferenceValidator.getRelationReferences({
+                    payload: createBy.data,
+                    relations: this.getProjectScopedRelations(),
+                }),
             ],
         });
         /*
@@ -807,7 +895,7 @@ export class Service extends DatabaseService {
         });
         return {
             createBy,
-            carryForward: null,
+            carryForward: carryForward,
         };
     }
     async onCreateSuccess(onCreate, createdItem) {
@@ -884,15 +972,16 @@ export class Service extends DatabaseService {
          * settles (RCA-first ordering, see RemediationHandoff).
          */
         let aiInvestigationEnqueued = false;
-        // Execute operations sequentially with error handling
-        Promise.resolve()
-            .then(async () => {
+        /*
+         * Apply privacy rules BEFORE workspace operations so the workspace
+         * channel is created with the correct privacy setting. This may set
+         * createdItem.isPrivate=true in memory. Kept as its own promise (it never
+         * rejects) so declaring from alerts can wait for it before linking: the
+         * links' feed entries leave out a private incident's title, so they must
+         * see the privacy the rules settle on.
+         */
+        const privacyRulesApplied = Promise.resolve().then(async () => {
             var _a, _b;
-            /*
-             * Apply privacy rules BEFORE workspace operations so the workspace
-             * channel is created with the correct privacy setting. This may set
-             * createdItem.isPrivate=true in memory.
-             */
             try {
                 await IncidentPrivacyRuleEngineService.applyRulesToIncident(createdItem);
             }
@@ -902,7 +991,9 @@ export class Service extends DatabaseService {
                     incidentId: (_b = createdItem.id) === null || _b === void 0 ? void 0 : _b.toString(),
                 });
             }
-        })
+        });
+        // Execute operations sequentially with error handling
+        privacyRulesApplied
             .then(async () => {
             var _a, _b, _c;
             try {
@@ -933,6 +1024,61 @@ export class Service extends DatabaseService {
                 });
                 return Promise.resolve();
             }
+        })
+            .then(async () => {
+            var _a, _b;
+            /*
+             * Declared from alerts: announce the alerts once, here - after
+             * "Incident Created" and after the incident's Slack / Microsoft
+             * Teams channels exist - rather than once per alert as each link is
+             * written (see linkAlertsDeclaredWithIncident). Uses the validated
+             * ids, so it does not wait for the links.
+             */
+            try {
+                const alertIds = this.getAlertIdsDeclaredWith(onCreate);
+                if (alertIds.length > 0) {
+                    await IncidentAlertService.createDeclaredFromAlertsFeedItem({
+                        projectId: createdItem.projectId,
+                        incidentId: createdItem.id,
+                        alertIds: alertIds,
+                        actorUserId: this.getDeclaringUserId(onCreate, createdItem),
+                    });
+                }
+            }
+            catch (error) {
+                logger.error(`Announcing the alerts an incident was declared from failed in IncidentService.onCreateSuccess: ${error}`, {
+                    projectId: (_a = createdItem.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
+                    incidentId: (_b = createdItem.id) === null || _b === void 0 ? void 0 : _b.toString(),
+                });
+            }
+        })
+            .then(async () => {
+            var _a, _b;
+            /*
+             * A private incident declared from alerts - private from the form or
+             * made private by a privacy rule above - gets the alerts' owners as
+             * its owners, so the people who could see the alerts can see the
+             * incident. Here rather than before the request returns: the owners'
+             * own hooks invite them to the incident's Slack / Microsoft Teams
+             * channels, which exist only from the workspace step above, and their
+             * "owner added" entries belong after "Incident Created".
+             */
+            try {
+                const alertIds = this.getAlertIdsDeclaredWith(onCreate);
+                if (alertIds.length > 0 && createdItem.isPrivate === true) {
+                    await IncidentAlertService.copyAlertOwnersToIncident({
+                        projectId: createdItem.projectId,
+                        incidentId: createdItem.id,
+                        alertIds: alertIds,
+                    });
+                }
+            }
+            catch (error) {
+                logger.error(`Adding the owners of the alerts a private incident was declared from failed in IncidentService.onCreateSuccess: ${error}`, {
+                    projectId: (_a = createdItem.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
+                    incidentId: (_b = createdItem.id) === null || _b === void 0 ? void 0 : _b.toString(),
+                });
+            }
         })
             .then(async () => {
             var _a, _b, _c;
@@ -1186,8 +1332,75 @@ export class Service extends DatabaseService {
                 userId: (_c = createdItem.createdByUserId) === null || _c === void 0 ? void 0 : _c.toString(),
             });
         });
+        await this.linkAlertsDeclaredWithIncident(onCreate, createdItem, privacyRulesApplied);
         return createdItem;
     }
+    // The validated alert ids an incident is being declared from, if any.
+    getAlertIdsDeclaredWith(onCreate) {
+        const carryForward = onCreate.carryForward || null;
+        return (carryForward === null || carryForward === void 0 ? void 0 : carryForward.alertIdsToLink) || [];
+    }
+    /*
+     * Who declared the incident, as "Linked by" on the links and the actor of
+     * their feed entries. A user is recorded as themselves and an API key as
+     * nobody: Incident.createdByUserId is writable by the create payload, and
+     * an API key must not be able to name somebody else as the one who linked
+     * the alerts (IncidentAlertService.onBeforeCreate applies the same rule to
+     * a link created directly). Only an internal root caller is trusted to
+     * name the incident's creator.
+     */
+    getDeclaringUserId(onCreate, createdItem) {
+        if (onCreate.createBy.props.isRoot) {
+            return createdItem.createdByUserId || undefined;
+        }
+        return onCreate.createBy.props.userId || undefined;
+    }
+    /*
+     * The incident was declared from alerts (see onBeforeCreate): link them now
+     * that it exists. Awaited, unlike the chain above, so the incident page the
+     * user lands on already lists its alerts. Written as root because the
+     * caller's right to link them was checked before the incident was created;
+     * the user who declared the incident is recorded as the one who linked
+     * them. The links write no incident-side feed entries: the chain above
+     * posts one "Declared from N alerts" entry instead. A link that fails is
+     * logged and never fails the incident.
+     *
+     * The privacy rules run first: each link's entry on its alert leaves out
+     * the incident's title when the incident is private, and a rule can make
+     * it private after it was saved. (The alerts' owners are added to a private
+     * incident later in the chain, once its workspace channels exist.)
+     */
+    async linkAlertsDeclaredWithIncident(onCreate, createdItem, privacyRulesApplied) {
+        const alertIds = this.getAlertIdsDeclaredWith(onCreate);
+        if (alertIds.length === 0 || !createdItem.projectId || !createdItem.id) {
+            return;
+        }
+        await privacyRulesApplied;
+        try {
+            const result = await IncidentAlertService.linkAlertsToIncident({
+                projectId: createdItem.projectId,
+                incidentId: createdItem.id,
+                alertIds: alertIds,
+                createdByUserId: this.getDeclaringUserId(onCreate, createdItem),
+                declaredWithIncident: true,
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (result.failed.length > 0) {
+                logger.error(`${result.failed.length} of ${alertIds.length} alerts could not be linked to the incident they were declared with.`, {
+                    projectId: createdItem.projectId.toString(),
+                    incidentId: createdItem.id.toString(),
+                });
+            }
+        }
+        catch (error) {
+            logger.error(`Linking the alerts an incident was declared from failed in IncidentService.onCreateSuccess: ${error}`, {
+                projectId: createdItem.projectId.toString(),
+                incidentId: createdItem.id.toString(),
+            });
+        }
+    }
     async handleIncidentWorkspaceOperationsAsync(createdItem) {
         var _a, _b, _c;
         try {
@@ -1459,6 +1672,7 @@ ${incident.remediationNotes || "No remediation notes provided."}
         throw new BadDataException("Incident identified date not found.");
     }
     async findOwners(incidentId) {
+        var _a, _b;
         if (!incidentId) {
             throw new BadDataException("incidentId is required");
         }
@@ -1468,6 +1682,7 @@ ${incident.remediationNotes || "No remediation notes provided."}
             },
             select: {
                 _id: true,
+                projectId: true,
                 user: {
                     _id: true,
                     email: true,
@@ -1487,6 +1702,7 @@ ${incident.remediationNotes || "No remediation notes provided."}
             },
             select: {
                 _id: true,
+                projectId: true,
                 teamId: true,
             },
             skip: 0,
@@ -1513,7 +1729,15 @@ ${incident.remediationNotes || "No remediation notes provided."}
                 }
             }
         }
-        return users;
+        const projectId = ((_a = ownerUsers[0]) === null || _a === void 0 ? void 0 : _a.projectId) || ((_b = ownerTeams[0]) === null || _b === void 0 ? void 0 : _b.projectId);
+        if (!projectId) {
+            return [];
+        }
+        // Owners who left the project are not notified, nor listed as notified.
+        return await TeamMemberService.filterUsersToProjectMembers({
+            projectId: projectId,
+            users: users,
+        });
     }
     async addOwners(projectId, incidentId, userIds, teamIds, notifyOwners, props) {
         // Owners already on the incident are skipped, not added a second time.
@@ -3063,6 +3287,12 @@ __decorate([
     __metadata("design:paramtypes", [Object, Model]),
     __metadata("design:returntype", Promise)
 ], Service.prototype, "onCreateSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Model, Promise]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "linkAlertsDeclaredWithIncident", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),