@oneuptime/common 9.4.13 → 9.5.0

package/Server/Services/IncidentStateTimelineService.ts

@@ -5,8 +5,11 @@ import QueryHelper from "../Types/Database/QueryHelper";
 import DatabaseService from "./DatabaseService";
 import IncidentPublicNoteService from "./IncidentPublicNoteService";
 import IncidentService from "./IncidentService";
+import IncidentSlaService from "./IncidentSlaService";
 import IncidentStateService from "./IncidentStateService";
 import UserService from "./UserService";
+import IncidentMemberService from "./IncidentMemberService";
+import IncidentRoleService from "./IncidentRoleService";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -18,6 +21,8 @@ import Incident from "../../Models/DatabaseModels/Incident";
 import IncidentPublicNote from "../../Models/DatabaseModels/IncidentPublicNote";
 import IncidentState from "../../Models/DatabaseModels/IncidentState";
 import IncidentStateTimeline from "../../Models/DatabaseModels/IncidentStateTimeline";
+import IncidentMember from "../../Models/DatabaseModels/IncidentMember";
+import IncidentRole from "../../Models/DatabaseModels/IncidentRole";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import logger from "../Utils/Logger";
 import IncidentFeedService from "./IncidentFeedService";
@@ -136,6 +141,7 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
               _id: true,
               order: true,
               name: true,
+              isResolvedState: true,
             },
             startsAt: true,
             endsAt: true,
@@ -438,7 +444,7 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
         ` Changed **[Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) State** to **` +
         stateName +
         "**",
-      moreInformationInMarkdown: `**Cause:** 
+      moreInformationInMarkdown: `**Cause:**
 ${createdItem.rootCause}`,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
       workspaceNotification: {
@@ -448,6 +454,21 @@ ${createdItem.rootCause}`,
       },
     });
 
+    // Auto-assign Incident Commander if not already assigned
+    const stateChangeUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (stateChangeUserId) {
+      this.autoAssignIncidentCommander({
+        incidentId: createdItem.incidentId!,
+        projectId: createdItem.projectId!,
+        userId: stateChangeUserId,
+      }).catch((error: Error) => {
+        logger.error(`Error while auto-assigning incident commander:`);
+        logger.error(error);
+      });
+    }
+
     const isResolvedState: boolean = incidentState?.isResolvedState || false;
 
     if (isResolvedState) {
@@ -500,6 +521,21 @@ ${createdItem.rootCause}`,
       logger.error(error);
     });
 
+    // Track SLA response/resolution times
+    this.trackSlaStateChange({
+      incidentId: createdItem.incidentId,
+      projectId: createdItem.projectId!,
+      isAcknowledgedState: incidentState?.isAcknowledgedState || false,
+      isResolvedState: incidentState?.isResolvedState || false,
+      stateChangedAt: createdItem.startsAt || OneUptimeDate.getCurrentDate(),
+      previousStateWasResolved:
+        onCreate.carryForward.statusTimelineBeforeThisStatus?.incidentState
+          ?.isResolvedState || false,
+    }).catch((error: Error) => {
+      logger.error(`Error while tracking SLA state change:`);
+      logger.error(error);
+    });
+
     const isLastIncidentState: boolean = await this.isLastIncidentState({
       projectId: createdItem.projectId!,
       incidentStateId: createdItem.incidentStateId,
@@ -567,6 +603,151 @@ ${createdItem.rootCause}`,
     return false;
   }
 
+  @CaptureSpan()
+  private async autoAssignIncidentCommander(data: {
+    incidentId: ObjectID;
+    projectId: ObjectID;
+    userId: ObjectID;
+  }): Promise<void> {
+    // Find the primary role (Incident Commander) for this project
+    const primaryRole: IncidentRole | null =
+      await IncidentRoleService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          isPrimaryRole: true,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!primaryRole || !primaryRole.id) {
+      // No primary role found for this project
+      return;
+    }
+
+    // Check if there's already an Incident Commander assigned to this incident
+    const existingCommander: IncidentMember | null =
+      await IncidentMemberService.findOneBy({
+        query: {
+          incidentId: data.incidentId,
+          incidentRoleId: primaryRole.id,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (existingCommander) {
+      // Already has an Incident Commander, don't assign another one
+      return;
+    }
+
+    // Check if this user is already assigned to the incident (with any role)
+    const existingMembership: IncidentMember | null =
+      await IncidentMemberService.findOneBy({
+        query: {
+          incidentId: data.incidentId,
+          userId: data.userId,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (existingMembership) {
+      // User is already assigned to this incident, don't assign again
+      return;
+    }
+
+    // Assign the user as Incident Commander
+    const incidentMember: IncidentMember = new IncidentMember();
+    incidentMember.incidentId = data.incidentId;
+    incidentMember.projectId = data.projectId;
+    incidentMember.userId = data.userId;
+    incidentMember.incidentRoleId = primaryRole.id;
+
+    await IncidentMemberService.create({
+      data: incidentMember,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    logger.debug(
+      `Auto-assigned user ${data.userId.toString()} as Incident Commander for incident ${data.incidentId.toString()}`,
+    );
+  }
+
+  @CaptureSpan()
+  private async trackSlaStateChange(data: {
+    incidentId: ObjectID;
+    projectId: ObjectID;
+    isAcknowledgedState: boolean;
+    isResolvedState: boolean;
+    stateChangedAt: Date;
+    previousStateWasResolved: boolean;
+  }): Promise<void> {
+    try {
+      // Check if incident is being reopened (previous state was resolved, current state is not resolved)
+      if (data.previousStateWasResolved && !data.isResolvedState) {
+        // Incident is being reopened - create a new SLA record
+        const incident: Incident | null = await IncidentService.findOneById({
+          id: data.incidentId,
+          select: {
+            declaredAt: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (incident && incident.declaredAt) {
+          // Create a new SLA record starting from the reopen time
+          await IncidentSlaService.createSlaForIncident({
+            incidentId: data.incidentId,
+            projectId: data.projectId,
+            declaredAt: data.stateChangedAt, // Use reopen time as SLA start time
+          });
+
+          logger.info(
+            `Created new SLA record for reopened incident ${data.incidentId}`,
+          );
+        }
+
+        return;
+      }
+
+      // Track acknowledged state
+      if (data.isAcknowledgedState) {
+        await IncidentSlaService.markResponded({
+          incidentId: data.incidentId,
+          respondedAt: data.stateChangedAt,
+        });
+      }
+
+      // Track resolved state
+      if (data.isResolvedState) {
+        await IncidentSlaService.markResolved({
+          incidentId: data.incidentId,
+          resolvedAt: data.stateChangedAt,
+        });
+      }
+    } catch (error) {
+      logger.error(`Error in trackSlaStateChange: ${error}`);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<IncidentStateTimeline>,

package/Server/Services/Index.ts

@@ -23,6 +23,8 @@ import IncidentCustomFieldService from "./IncidentCustomFieldService";
 import IncidentInternalNoteService from "./IncidentInternalNoteService";
 import IncidentOwnerTeamService from "./IncidentOwnerTeamService";
 import IncidentOwnerUserService from "./IncidentOwnerUserService";
+import IncidentRoleService from "./IncidentRoleService";
+import IncidentMemberService from "./IncidentMemberService";
 import IncidentPublicNoteService from "./IncidentPublicNoteService";
 // Incidents
 import IncidentService from "./IncidentService";
@@ -71,6 +73,7 @@ import AIAgentTaskLogService from "./AIAgentTaskLogService";
 import AIAgentTaskPullRequestService from "./AIAgentTaskPullRequestService";
 import ProjectCallSMSConfigService from "./ProjectCallSMSConfigService";
 import ProjectService from "./ProjectService";
+import ProjectUserProfileService from "./ProjectUserProfileService";
 // Project SMTP Config.
 import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
@@ -118,6 +121,7 @@ import StatusPageSubscriberService from "./StatusPageSubscriberService";
 import StatusPageSubscriberNotificationTemplateService from "./StatusPageSubscriberNotificationTemplateService";
 import StatusPageSubscriberNotificationTemplateStatusPageService from "./StatusPageSubscriberNotificationTemplateStatusPageService";
 import TeamMemberService from "./TeamMemberService";
+import TeamMemberCustomFieldService from "./TeamMemberCustomFieldService";
 import TeamPermissionService from "./TeamPermissionService";
 import TeamComplianceSettingService from "./TeamComplianceSettingService";
 // Team
@@ -173,10 +177,13 @@ import IncidentEpisodeService from "./IncidentEpisodeService";
 import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
 import IncidentEpisodeInternalNoteService from "./IncidentEpisodeInternalNoteService";
 import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
+import IncidentEpisodeRoleMemberService from "./IncidentEpisodeRoleMemberService";
 import IncidentEpisodeOwnerTeamService from "./IncidentEpisodeOwnerTeamService";
 import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
 import IncidentEpisodeStateTimelineService from "./IncidentEpisodeStateTimelineService";
 import AlertGroupingRuleService from "./AlertGroupingRuleService";
+import IncidentSlaRuleService from "./IncidentSlaRuleService";
+import IncidentSlaService from "./IncidentSlaService";
 
 import TableViewService from "./TableViewService";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
@@ -232,6 +239,8 @@ const services: Array<BaseService> = [
   IncidentInternalNoteService,
   IncidentOwnerTeamService,
   IncidentOwnerUserService,
+  IncidentRoleService,
+  IncidentMemberService,
   IncidentPublicNoteService,
   IncidentService,
   IncidentSeverityService,
@@ -309,6 +318,7 @@ const services: Array<BaseService> = [
   StatusPageHistoryChartBarColorRuleService,
 
   TeamMemberService,
+  TeamMemberCustomFieldService,
   TeamPermissionService,
   TeamComplianceSettingService,
   TeamService,
@@ -345,6 +355,7 @@ const services: Array<BaseService> = [
 
   UsageBillingService,
   ProjectCallSMSConfigService,
+  ProjectUserProfileService,
 
   ServiceService,
   ServiceOwnerTeamService,
@@ -385,10 +396,13 @@ const services: Array<BaseService> = [
   IncidentEpisodeFeedService,
   IncidentEpisodeInternalNoteService,
   IncidentEpisodeMemberService,
+  IncidentEpisodeRoleMemberService,
   IncidentEpisodeOwnerTeamService,
   IncidentEpisodeOwnerUserService,
   IncidentEpisodeStateTimelineService,
   AlertGroupingRuleService,
+  IncidentSlaRuleService,
+  IncidentSlaService,
 
   TableViewService,
   MonitorTestService,

package/Server/Services/ProjectService.ts

@@ -14,11 +14,13 @@ import { OnCreate, OnDelete, OnFind, OnUpdate } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import UpdateBy from "../Types/Database/UpdateBy";
 import logger from "../Utils/Logger";
+import Errors from "../Utils/Errors";
 import AccessTokenService from "./AccessTokenService";
 import BillingService from "./BillingService";
 import DatabaseService from "./DatabaseService";
 import IncidentSeverityService from "./IncidentSeverityService";
 import IncidentStateService from "./IncidentStateService";
+import IncidentRoleService from "./IncidentRoleService";
 import MailService from "./MailService";
 import MonitorStatusService from "./MonitorStatusService";
 import NotificationService from "./NotificationService";
@@ -36,9 +38,13 @@ import SubscriptionPlan, {
 import SubscriptionStatus from "../../Types/Billing/SubscriptionStatus";
 import {
   Black,
+  Blue500,
+  Gray500,
   Green,
   Moroon500,
+  Purple500,
   Red,
+  Teal500,
   Yellow,
   Yellow500,
 } from "../../Types/BrandColors";
@@ -48,10 +54,12 @@ import OneUptimeDate from "../../Types/Date";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
+import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
 import IncidentState from "../../Models/DatabaseModels/IncidentState";
+import IncidentRole from "../../Models/DatabaseModels/IncidentRole";
 import MonitorStatus from "../../Models/DatabaseModels/MonitorStatus";
 import Model from "../../Models/DatabaseModels/Project";
 import PromoCode from "../../Models/DatabaseModels/PromoCode";
@@ -387,6 +395,7 @@ export class ProjectService extends DatabaseService<Model> {
         paymentProviderSubscriptionSeats: true,
         paymentProviderPlanId: true,
         trialEndsAt: true,
+        paymentProviderCustomerId: true,
       },
       props: {
         isRoot: true,
@@ -407,6 +416,19 @@ export class ProjectService extends DatabaseService<Model> {
       );
     }
 
+    // Check if customer has payment methods before attempting to change plan
+    if (!project.paymentProviderCustomerId) {
+      throw new BadDataException("Payment Provider customer not found");
+    }
+
+    const hasPaymentMethods: boolean = await BillingService.hasPaymentMethods(
+      project.paymentProviderCustomerId,
+    );
+
+    if (!hasPaymentMethods) {
+      throw new BadDataException(Errors.BillingService.NO_PAYMENTS_METHODS);
+    }
+
     const plan: SubscriptionPlan | undefined =
       SubscriptionPlan.getSubscriptionPlanById(
         params.paymentProviderPlanId,
@@ -689,6 +711,7 @@ export class ProjectService extends DatabaseService<Model> {
     createdItem = await this.addDefaultIncidentState(createdItem);
     createdItem = await this.addDefaultScheduledMaintenanceState(createdItem);
     createdItem = await this.addDefaultAlertState(createdItem);
+    createdItem = await this.addDefaultIncidentRoles(createdItem);
 
     if (NotificationSlackWebhookOnCreateProject) {
       // fetch project again.
@@ -928,6 +951,73 @@ export class ProjectService extends DatabaseService<Model> {
     return createdItem;
   }
 
+  public async addDefaultIncidentRoles(createdItem: Model): Promise<Model> {
+    let incidentCommander: IncidentRole = new IncidentRole();
+    incidentCommander.name = "Incident Commander";
+    incidentCommander.description =
+      "Primary decision maker during an incident. Responsible for coordinating the response and making final decisions.";
+    incidentCommander.color = Purple500;
+    incidentCommander.roleIcon = IconProp.ShieldCheck;
+    incidentCommander.projectId = createdItem.id!;
+    incidentCommander.isPrimaryRole = true;
+    incidentCommander.isDeleteable = false;
+
+    incidentCommander = await IncidentRoleService.create({
+      data: incidentCommander,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    let responder: IncidentRole = new IncidentRole();
+    responder.name = "Responder";
+    responder.description =
+      "Active participant in incident resolution. Performs hands-on work to resolve the incident.";
+    responder.color = Blue500;
+    responder.roleIcon = IconProp.Wrench;
+    responder.projectId = createdItem.id!;
+
+    responder = await IncidentRoleService.create({
+      data: responder,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    let communicationsLead: IncidentRole = new IncidentRole();
+    communicationsLead.name = "Communications Lead";
+    communicationsLead.description =
+      "Handles stakeholder communication and status updates during an incident.";
+    communicationsLead.color = Teal500;
+    communicationsLead.roleIcon = IconProp.Announcement;
+    communicationsLead.projectId = createdItem.id!;
+
+    communicationsLead = await IncidentRoleService.create({
+      data: communicationsLead,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    let observer: IncidentRole = new IncidentRole();
+    observer.name = "Observer";
+    observer.description =
+      "Read-only participant who monitors the incident without active involvement.";
+    observer.color = Gray500;
+    observer.roleIcon = IconProp.Activity;
+    observer.projectId = createdItem.id!;
+    observer.canAssignMultipleUsers = true;
+
+    observer = await IncidentRoleService.create({
+      data: observer,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return createdItem;
+  }
+
   private async addDefaultMonitorStatus(createdItem: Model): Promise<Model> {
     let operationalStatus: MonitorStatus = new MonitorStatus();
     operationalStatus.name = "Operational";

package/Server/Services/ProjectUserProfileService.ts

@@ -0,0 +1,9 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ProjectUserProfile";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+export default new Service();

package/Server/Services/TeamMemberCustomFieldService.ts

@@ -0,0 +1,9 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/TeamMemberCustomField";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+export default new Service();

package/Server/Services/UserOnCallLogService.ts

@@ -376,6 +376,13 @@ export class Service extends DatabaseService<Model> {
       return NotificationRuleType.ON_CALL_EXECUTED_ALERT_EPISODE;
     }
 
+    if (
+      userNotificationEventType ===
+      UserNotificationEventType.IncidentEpisodeCreated
+    ) {
+      return NotificationRuleType.ON_CALL_EXECUTED_INCIDENT_EPISODE;
+    }
+
     // Invalid user notification event type.
     throw new BadDataException("Invalid user notification event type.");
   }

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -1,6 +1,7 @@
 import Alert from "../../../Models/DatabaseModels/Alert";
 import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
 import AlertStateTimeline from "../../../Models/DatabaseModels/AlertStateTimeline";
+import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -218,6 +219,14 @@ export default class MonitorAlert {
             return onCallPolicy;
           }) || [];
 
+        // Set labels from criteria
+        alert.labels =
+          criteriaAlert.labelIds?.map((id: ObjectID) => {
+            const label: Label = new Label();
+            label._id = id.toString();
+            return label;
+          }) || [];
+
         alert.isCreatedAutomatically = true;
 
         if (input.props.telemetryQuery) {
@@ -259,6 +268,23 @@ export default class MonitorAlert {
           },
         });
 
+        // Add owner teams and users after alert creation
+        if (
+          criteriaAlert.ownerTeamIds?.length ||
+          criteriaAlert.ownerUserIds?.length
+        ) {
+          await AlertService.addOwners(
+            input.monitor.projectId!,
+            createdAlert.id!,
+            criteriaAlert.ownerUserIds || [],
+            criteriaAlert.ownerTeamIds || [],
+            true, // notify owners
+            {
+              isRoot: true,
+            },
+          );
+        }
+
         input.evaluationSummary?.events.push({
           type: "alert-created",
           title: `Alert created: ${createdAlert.title || criteriaAlert.title}`,

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -1,6 +1,8 @@
 import Incident from "../../../Models/DatabaseModels/Incident";
 import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
 import IncidentStateTimeline from "../../../Models/DatabaseModels/IncidentStateTimeline";
+import IncidentMember from "../../../Models/DatabaseModels/IncidentMember";
+import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -16,6 +18,7 @@ import { DisableAutomaticIncidentCreation } from "../../EnvironmentConfig";
 import IncidentService from "../../Services/IncidentService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
+import IncidentMemberService from "../../Services/IncidentMemberService";
 import logger from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
@@ -23,6 +26,7 @@ import MonitorTemplateUtil from "./MonitorTemplateUtil";
 import { JSONObject } from "../../../Types/JSON";
 import OneUptimeDate from "../../../Types/Date";
 import MonitorEvaluationSummary from "../../../Types/Monitor/MonitorEvaluationSummary";
+import { IncidentMemberRoleAssignment } from "../../../Types/Monitor/CriteriaIncident";
 
 export default class MonitorIncident {
   @CaptureSpan()
@@ -228,6 +232,14 @@ export default class MonitorIncident {
             return onCallPolicy;
           }) || [];
 
+        // Set labels from criteria
+        incident.labels =
+          criteriaIncident.labelIds?.map((id: ObjectID) => {
+            const label: Label = new Label();
+            label._id = id.toString();
+            return label;
+          }) || [];
+
         incident.isCreatedAutomatically = true;
 
         if (input.props.telemetryQuery) {
@@ -271,6 +283,63 @@ export default class MonitorIncident {
           },
         });
 
+        // Add owner teams and users after incident creation
+        if (
+          criteriaIncident.ownerTeamIds?.length ||
+          criteriaIncident.ownerUserIds?.length
+        ) {
+          await IncidentService.addOwners(
+            input.monitor.projectId!,
+            createdIncident.id!,
+            criteriaIncident.ownerUserIds || [],
+            criteriaIncident.ownerTeamIds || [],
+            true, // notify owners
+            {
+              isRoot: true,
+            },
+          );
+        }
+
+        // Add incident member role assignments after incident creation
+        if (
+          criteriaIncident.incidentMemberRoles &&
+          criteriaIncident.incidentMemberRoles.length > 0
+        ) {
+          for (const roleAssignment of criteriaIncident.incidentMemberRoles) {
+            try {
+              const assignment: IncidentMemberRoleAssignment =
+                roleAssignment as IncidentMemberRoleAssignment;
+
+              if (assignment.roleId && assignment.userId) {
+                const incidentMember: IncidentMember = new IncidentMember();
+                incidentMember.incidentId = createdIncident.id!;
+                incidentMember.projectId = input.monitor.projectId!;
+                incidentMember.userId = new ObjectID(
+                  assignment.userId.toString(),
+                );
+                incidentMember.incidentRoleId = new ObjectID(
+                  assignment.roleId.toString(),
+                );
+
+                await IncidentMemberService.create({
+                  data: incidentMember,
+                  props: {
+                    isRoot: true,
+                  },
+                });
+
+                logger.debug(
+                  `${input.monitor.id?.toString()} - Assigned incident member role ${assignment.roleId.toString()} to user ${assignment.userId.toString()}`,
+                );
+              }
+            } catch (memberError) {
+              logger.error(
+                `${input.monitor.id?.toString()} - Failed to assign incident member role: ${memberError}`,
+              );
+            }
+          }
+        }
+
         input.evaluationSummary?.events.push({
           type: "incident-created",
           title: `Incident created: ${createdIncident.title || criteriaIncident.title}`,

package/Server/Utils/WhatsAppTemplateUtil.ts

@@ -34,6 +34,7 @@ const templateDashboardLinkVariableMap: Partial<
   [WhatsAppTemplateIds.IncidentNotePostedOwnerNotification]: "incident_link",
   [WhatsAppTemplateIds.IncidentStateChangedOwnerNotification]: "incident_link",
   [WhatsAppTemplateIds.IncidentOwnerAddedNotification]: "incident_link",
+  [WhatsAppTemplateIds.IncidentMemberAddedNotification]: "incident_link",
   [WhatsAppTemplateIds.MonitorOwnerAddedNotification]: "monitor_link",
   [WhatsAppTemplateIds.MonitorCreatedOwnerNotification]: "monitor_link",
   [WhatsAppTemplateIds.MonitorStatusChangedOwnerNotification]: "monitor_link",
@@ -75,6 +76,8 @@ const templateIdByEventType: Record<
     WhatsAppTemplateIds.IncidentStateChangedOwnerNotification,
   [NotificationSettingEventType.SEND_INCIDENT_OWNER_ADDED_NOTIFICATION]:
     WhatsAppTemplateIds.IncidentOwnerAddedNotification,
+  [NotificationSettingEventType.SEND_INCIDENT_MEMBER_ADDED_NOTIFICATION]:
+    WhatsAppTemplateIds.IncidentMemberAddedNotification,
   [NotificationSettingEventType.SEND_ALERT_CREATED_OWNER_NOTIFICATION]:
     WhatsAppTemplateIds.AlertCreatedOwnerNotification,
   [NotificationSettingEventType.SEND_ALERT_NOTE_POSTED_OWNER_NOTIFICATION]: