@oneuptime/common 10.2.2 → 10.2.4

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -313,6 +313,9 @@ import { AddAlertIsPrivate1778438949454 } from "./1778438949454-AddAlertIsPrivat
 import { AddPrivacyRules1778440665575 } from "./1778440665575-AddPrivacyRules";
 import { AddEpisodePrivacyRules1778442385970 } from "./1778442385970-AddEpisodePrivacyRules";
 import { AddProjectOIDC1778506655291 } from "./1778506655291-AddProjectOIDC";
+import { MigrationName1778514515756 } from "./1778514515756-MigrationName";
+import { MigrationName1778521361934 } from "./1778521361934-MigrationName";
+import { AddStatusPageOIDC1778522070962 } from "./1778522070962-AddStatusPageOIDC";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -629,4 +632,7 @@ export default [
   AddPrivacyRules1778440665575,
   AddEpisodePrivacyRules1778442385970,
   AddProjectOIDC1778506655291,
+  MigrationName1778514515756,
+  MigrationName1778521361934,
+  AddStatusPageOIDC1778522070962,
 ];

package/Server/Services/Index.ts

@@ -130,6 +130,7 @@ import StatusPageResourceService from "./StatusPageResourceService";
 // Status Page
 import StatusPageService from "./StatusPageService";
 import StatusPageSsoService from "./StatusPageSsoService";
+import StatusPageOidcService from "./StatusPageOidcService";
 import StatusPageSubscriberService from "./StatusPageSubscriberService";
 import StatusPageSubscriberNotificationTemplateService from "./StatusPageSubscriberNotificationTemplateService";
 import StatusPageSubscriberNotificationTemplateStatusPageService from "./StatusPageSubscriberNotificationTemplateStatusPageService";
@@ -335,6 +336,7 @@ const services: Array<BaseService> = [
   StatusPageResourceService,
   StatusPageService,
   StatusPageSsoService,
+  StatusPageOidcService,
   StatusPageSubscriberService,
   StatusPageSubscriberNotificationTemplateService,
   StatusPageSubscriberNotificationTemplateStatusPageService,

package/Server/Services/ScheduledMaintenanceService.ts

@@ -51,6 +51,7 @@ import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
+import StatusPageSubscriberWebhookUtil from "../Utils/StatusPageSubscriberWebhook";
 import { Gray500, Red500 } from "../../Types/BrandColors";
 import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
@@ -332,6 +333,39 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
             });
           }
 
+          if (subscriber.subscriberWebhook) {
+            StatusPageSubscriberWebhookUtil.sendWebhookNotification({
+              webhookUrl: subscriber.subscriberWebhook,
+              payload: {
+                eventType: "ScheduledMaintenanceCreated",
+                statusPageId: statuspage.id!.toString(),
+                statusPageName: statusPageName,
+                statusPageUrl: statusPageURL,
+                unsubscribeUrl: unsubscribeUrl,
+                data: {
+                  scheduledMaintenanceId: event.id?.toString() || "",
+                  scheduledMaintenanceTitle: event.title || "",
+                  scheduledMaintenanceDescription: event.description || "",
+                  scheduledStartTime:
+                    OneUptimeDate.getDateAsUserFriendlyFormattedString(
+                      event.startsAt!,
+                    ),
+                  scheduledEndTime: event.endsAt
+                    ? OneUptimeDate.getDateAsUserFriendlyFormattedString(
+                        event.endsAt,
+                      )
+                    : "",
+                  resourcesAffected: resourcesAffected,
+                  detailsUrl: scheduledEventDetailsUrl,
+                },
+              },
+            }).catch((err: Error) => {
+              logger.error(err, {
+                projectId: statuspage.projectId?.toString(),
+              } as LogAttributes);
+            });
+          }
+
           if (subscriber.subscriberEmail) {
             // send email here.
             const statusPageIdString: string | null =

package/Server/Services/StatusPageOidcService.ts

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

package/Server/Services/StatusPageSubscriberService.ts

@@ -36,6 +36,7 @@ import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/Statu
 import NumberUtil from "../../Utils/Number";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import MicrosoftTeamsUtil from "../Utils/Workspace/MicrosoftTeams/MicrosoftTeams";
+import StatusPageSubscriberWebhookUtil from "../Utils/StatusPageSubscriberWebhook";
 import StatusPageSubscriberNotificationTemplateService, {
   Service as StatusPageSubscriberNotificationTemplateServiceClass,
 } from "./StatusPageSubscriberNotificationTemplateService";
@@ -540,6 +541,43 @@ Stay informed about service availability! 🚀`;
         });
     }
 
+    // if generic webhook URL is provided and sendYouHaveSubscribedMessage is true, then ping the webhook with the subscription event.
+    if (
+      createdItem.subscriberWebhook &&
+      createdItem.sendYouHaveSubscribedMessage
+    ) {
+      logger.debug("Sending webhook notification for new subscriber.", {
+        projectId: createdItem.projectId?.toString(),
+      } as LogAttributes);
+
+      StatusPageSubscriberWebhookUtil.sendWebhookNotification({
+        webhookUrl: URL.fromString(createdItem.subscriberWebhook.toString()),
+        payload: {
+          eventType: "SubscriberSubscribed",
+          statusPageId: createdItem.statusPageId.toString(),
+          statusPageName: statusPageName,
+          statusPageUrl: statusPageURL,
+          unsubscribeUrl: unsubscribeLink,
+          data: {
+            message: `You have been subscribed to ${statusPageName}.`,
+          },
+        },
+      })
+        .then(() => {
+          logger.debug("Webhook notification sent successfully.", {
+            projectId: createdItem.projectId?.toString(),
+          } as LogAttributes);
+        })
+        .catch((err: Error) => {
+          logger.error("Error sending webhook notification:", {
+            projectId: createdItem.projectId?.toString(),
+          } as LogAttributes);
+          logger.error(err, {
+            projectId: createdItem.projectId?.toString(),
+          } as LogAttributes);
+        });
+    }
+
     // if Microsoft Teams incoming webhook is provided and sendYouHaveSubscribedMessage is true, then send a message to the Teams channel.
     if (
       createdItem.microsoftTeamsIncomingWebhookUrl &&
@@ -1345,6 +1383,69 @@ Stay informed about service availability! 🚀`;
     return statusPages;
   }
 
+  @CaptureSpan()
+  public async testSubscriberWebhook(data: {
+    webhookUrl: string;
+    statusPageId: ObjectID;
+  }): Promise<void> {
+    // basic validation - must be a valid URL
+    let parsedUrl: URL;
+    try {
+      parsedUrl = URL.fromString(data.webhookUrl);
+    } catch {
+      throw new BadDataException("Invalid Webhook URL");
+    }
+
+    // get the status page info
+    const statusPage: StatusPage | null = await StatusPageService.findOneById({
+      id: data.statusPageId,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        name: true,
+        pageTitle: true,
+        projectId: true,
+        _id: true,
+      },
+    });
+
+    if (!statusPage) {
+      throw new BadDataException("Status page not found");
+    }
+
+    const statusPageName: string =
+      statusPage.pageTitle || statusPage.name || "Status Page";
+    const statusPageURL: string = await StatusPageService.getStatusPageURL(
+      statusPage.id!,
+    );
+
+    try {
+      await StatusPageSubscriberWebhookUtil.sendWebhookNotification({
+        webhookUrl: parsedUrl,
+        payload: {
+          eventType: "TestNotification",
+          statusPageId: statusPage.id!.toString(),
+          statusPageName: statusPageName,
+          statusPageUrl: statusPageURL,
+          unsubscribeUrl: "",
+          data: {
+            message:
+              "This is a test notification from OneUptime. Your webhook is configured correctly.",
+          },
+        },
+      });
+    } catch (error) {
+      logger.error("Error sending test webhook notification:", {
+        projectId: statusPage?.projectId?.toString(),
+      } as LogAttributes);
+      logger.error(error, {
+        projectId: statusPage?.projectId?.toString(),
+      } as LogAttributes);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   public async testSlackWebhook(data: {
     webhookUrl: string;

package/Server/Services/UserNotificationRuleService.ts

@@ -10,6 +10,7 @@ import MailService from "./MailService";
 import ShortLinkService from "./ShortLinkService";
 import SmsService from "./SmsService";
 import TelegramService from "./TelegramService";
+import WebhookService from "./WebhookService";
 import WhatsAppService from "./WhatsAppService";
 import UserEmailService from "./UserEmailService";
 import UserOnCallLogService from "./UserOnCallLogService";
@@ -28,6 +29,7 @@ import Email from "../../Types/Email";
 import EmailMessage from "../../Types/Email/EmailMessage";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
 import NotificationRuleType from "../../Types/NotificationRule/NotificationRuleType";
 import ObjectID from "../../Types/ObjectID";
 import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
@@ -78,6 +80,7 @@ export interface NotificationMethodDescriptor {
   userWhatsAppId?: ObjectID;
   userTelegramId?: ObjectID;
   userPushId?: ObjectID;
+  userWebhookId?: ObjectID;
 }
 
 export class Service extends DatabaseService<Model> {
@@ -173,6 +176,11 @@ export class Service extends DatabaseService<Model> {
           telegramUserHandle: true,
           isVerified: true,
         },
+        userWebhook: {
+          webhookUrl: true,
+          name: true,
+          secret: true,
+        },
         userEmail: {
           email: true,
           isVerified: true,
@@ -1082,6 +1090,202 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    // send webhook.
+    if (notificationRuleItem.userWebhook?.webhookUrl) {
+      const webhookUrl: string = notificationRuleItem.userWebhook.webhookUrl;
+      const webhookSecret: string | undefined =
+        notificationRuleItem.userWebhook.secret;
+      const userWebhookId: ObjectID = notificationRuleItem.userWebhook.id!;
+
+      const dispatchWebhook: (params: {
+        eventType: string;
+        payload: JSONObject;
+        entityId?: ObjectID;
+        entityKind: "alert" | "incident" | "alertEpisode" | "incidentEpisode";
+      }) => Promise<void> = async (params: {
+        eventType: string;
+        payload: JSONObject;
+        entityId?: ObjectID;
+        entityKind: "alert" | "incident" | "alertEpisode" | "incidentEpisode";
+      }): Promise<void> => {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending webhook to ${webhookUrl}.`;
+        logTimelineItem.userWebhookId = userWebhookId;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const callbacksByKind: {
+          alert?: { alertId?: ObjectID };
+          incident?: { incidentId?: ObjectID };
+        } = {};
+        if (params.entityKind === "alert" && params.entityId) {
+          callbacksByKind.alert = { alertId: params.entityId };
+        } else if (params.entityKind === "incident" && params.entityId) {
+          callbacksByKind.incident = { incidentId: params.entityId };
+        }
+
+        WebhookService.sendWebhook(
+          {
+            url: webhookUrl,
+            eventType: params.eventType,
+            payload: params.payload,
+            secret: webhookSecret,
+          },
+          {
+            projectId: options.projectId,
+            userOnCallLogTimelineId: updatedLog.id!,
+            userId: notificationRuleItem.userId!,
+            onCallPolicyId: options.onCallPolicyId,
+            onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+            teamId: options.userBelongsToTeamId,
+            onCallDutyPolicyExecutionLogTimelineId:
+              options.onCallDutyPolicyExecutionLogTimelineId,
+            onCallScheduleId: options.onCallScheduleId,
+            ...callbacksByKind.alert,
+            ...callbacksByKind.incident,
+          },
+        ).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending webhook.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      };
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.alert.created",
+          entityKind: "alert",
+          entityId: alert.id!,
+          payload: {
+            eventType: "on-call.alert.created",
+            timestamp: new Date().toISOString(),
+            projectId: alert.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            alert: {
+              id: alert.id?.toString() || "",
+              title: alert.title || "",
+              description: alert.description || "",
+              alertNumber: alert.alertNumber || null,
+              alertNumberWithPrefix: alert.alertNumberWithPrefix || null,
+              severity: alert.alertSeverity?.name || null,
+              state: alert.currentAlertState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentCreated &&
+        incident
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.incident.created",
+          entityKind: "incident",
+          entityId: incident.id!,
+          payload: {
+            eventType: "on-call.incident.created",
+            timestamp: new Date().toISOString(),
+            projectId: incident.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            incident: {
+              id: incident.id?.toString() || "",
+              title: incident.title || "",
+              description: incident.description || "",
+              incidentNumber: incident.incidentNumber || null,
+              incidentNumberWithPrefix:
+                incident.incidentNumberWithPrefix || null,
+              severity: incident.incidentSeverity?.name || null,
+              state: incident.currentIncidentState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.alertEpisode.created",
+          entityKind: "alertEpisode",
+          payload: {
+            eventType: "on-call.alertEpisode.created",
+            timestamp: new Date().toISOString(),
+            projectId: alertEpisode.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            alertEpisode: {
+              id: alertEpisode.id?.toString() || "",
+              title: alertEpisode.title || "",
+              description: alertEpisode.description || "",
+              episodeNumber: alertEpisode.episodeNumber || null,
+              episodeNumberWithPrefix:
+                alertEpisode.episodeNumberWithPrefix || null,
+              severity: alertEpisode.alertSeverity?.name || null,
+              state: alertEpisode.currentAlertState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentEpisodeCreated &&
+        incidentEpisode
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.incidentEpisode.created",
+          entityKind: "incidentEpisode",
+          payload: {
+            eventType: "on-call.incidentEpisode.created",
+            timestamp: new Date().toISOString(),
+            projectId: incidentEpisode.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            incidentEpisode: {
+              id: incidentEpisode.id?.toString() || "",
+              title: incidentEpisode.title || "",
+              description: incidentEpisode.description || "",
+              episodeNumber: incidentEpisode.episodeNumber || null,
+              episodeNumberWithPrefix:
+                incidentEpisode.episodeNumberWithPrefix || null,
+              severity: incidentEpisode.incidentSeverity?.name || null,
+              state: incidentEpisode.currentIncidentState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+    }
+
     // send call.
     if (
       notificationRuleItem.userCall?.phone &&
@@ -2631,12 +2835,14 @@ export class Service extends DatabaseService<Model> {
       !createBy.data.userWhatsAppId &&
       !createBy.data.userTelegram &&
       !createBy.data.userTelegramId &&
+      !createBy.data.userWebhook &&
+      !createBy.data.userWebhookId &&
       !createBy.data.userEmailId &&
       !createBy.data.userPushId &&
       !createBy.data.userPush
     ) {
       throw new BadDataException(
-        "Call, SMS, WhatsApp, Telegram, Email, or Push notification is required",
+        "Call, SMS, WhatsApp, Telegram, Webhook, Email, or Push notification is required",
       );
     }
 
@@ -2701,6 +2907,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userTelegramId) {
       rule.userTelegramId = descriptor.userTelegramId;
     }
+    if (descriptor.userWebhookId) {
+      rule.userWebhookId = descriptor.userWebhookId;
+    }
     if (descriptor.userPushId) {
       rule.userPushId = descriptor.userPushId;
     }
@@ -2725,6 +2934,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userTelegramId) {
       query["userTelegramId"] = descriptor.userTelegramId;
     }
+    if (descriptor.userWebhookId) {
+      query["userWebhookId"] = descriptor.userWebhookId;
+    }
     if (descriptor.userPushId) {
       query["userPushId"] = descriptor.userPushId;
     }

package/Server/Services/UserNotificationSettingService.ts

@@ -12,7 +12,9 @@ import UserEmailService from "./UserEmailService";
 import UserSmsService from "./UserSmsService";
 import PushNotificationService from "./PushNotificationService";
 import UserTelegramService from "./UserTelegramService";
+import UserWebhookService from "./UserWebhookService";
 import UserWhatsAppService from "./UserWhatsAppService";
+import WebhookService from "./WebhookService";
 import WhatsAppService from "./WhatsAppService";
 import { CallRequestMessage } from "../../Types/Call/CallRequest";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
@@ -29,11 +31,13 @@ import TelegramMessage, {
 import WhatsAppMessage, {
   WhatsAppMessagePayload,
 } from "../../Types/WhatsApp/WhatsAppMessage";
+import { JSONObject } from "../../Types/JSON";
 import UserCall from "../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
+import UserWebhook from "../../Models/DatabaseModels/UserWebhook";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { appendRecipientToWhatsAppMessage } from "../Utils/WhatsAppTemplateUtil";
@@ -89,6 +93,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           alertByTelegram: true,
           alertByCall: true,
           alertByPush: true,
+          alertByWebhook: true,
         },
         props: {
           isRoot: true,
@@ -425,6 +430,96 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           logger.error(err);
         });
       }
+
+      if (notificationSettings.alertByWebhook) {
+        const userWebhooks: Array<UserWebhook> =
+          await UserWebhookService.findBy({
+            query: {
+              userId: data.userId,
+              projectId: data.projectId,
+            },
+            select: {
+              webhookUrl: true,
+              secret: true,
+              name: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const webhookPayload: JSONObject = {
+          eventType: data.eventType,
+          timestamp: new Date().toISOString(),
+          projectId: data.projectId.toString(),
+          userId: data.userId.toString(),
+          subject: data.emailEnvelope?.subject || "",
+          message: data.smsMessage?.message || "",
+        };
+
+        if (data.incidentId) {
+          webhookPayload["incidentId"] = data.incidentId.toString();
+        }
+        if (data.alertId) {
+          webhookPayload["alertId"] = data.alertId.toString();
+        }
+        if (data.monitorId) {
+          webhookPayload["monitorId"] = data.monitorId.toString();
+        }
+        if (data.scheduledMaintenanceId) {
+          webhookPayload["scheduledMaintenanceId"] =
+            data.scheduledMaintenanceId.toString();
+        }
+        if (data.statusPageId) {
+          webhookPayload["statusPageId"] = data.statusPageId.toString();
+        }
+        if (data.statusPageAnnouncementId) {
+          webhookPayload["statusPageAnnouncementId"] =
+            data.statusPageAnnouncementId.toString();
+        }
+        if (data.onCallPolicyId) {
+          webhookPayload["onCallPolicyId"] = data.onCallPolicyId.toString();
+        }
+        if (data.onCallPolicyEscalationRuleId) {
+          webhookPayload["onCallPolicyEscalationRuleId"] =
+            data.onCallPolicyEscalationRuleId.toString();
+        }
+
+        for (const userWebhook of userWebhooks) {
+          if (!userWebhook.webhookUrl) {
+            continue;
+          }
+
+          WebhookService.sendWebhook(
+            {
+              url: userWebhook.webhookUrl,
+              eventType: data.eventType,
+              payload: webhookPayload,
+              secret: userWebhook.secret,
+            },
+            {
+              projectId: data.projectId,
+              incidentId: data.incidentId,
+              alertId: data.alertId,
+              monitorId: data.monitorId,
+              scheduledMaintenanceId: data.scheduledMaintenanceId,
+              statusPageId: data.statusPageId,
+              statusPageAnnouncementId: data.statusPageAnnouncementId,
+              userId: data.userId,
+              teamId: data.teamId,
+              onCallPolicyId: data.onCallPolicyId,
+              onCallPolicyEscalationRuleId: data.onCallPolicyEscalationRuleId,
+              onCallDutyPolicyExecutionLogTimelineId:
+                data.onCallDutyPolicyExecutionLogTimelineId,
+              onCallScheduleId: data.onCallScheduleId,
+            },
+          ).catch((err: Error) => {
+            logger.error(err);
+          });
+        }
+      }
     }
   }