@oneuptime/common 9.5.13 → 10.0.1

package/Server/API/UserCallAPI.ts

@@ -2,6 +2,7 @@ import UserMiddleware from "../Middleware/UserAuthorization";
 import UserCallService, {
   Service as UserCallServiceType,
 } from "../Services/UserCallService";
+import UserNotificationRuleService from "../Services/UserNotificationRuleService";
 import {
   ExpressRequest,
   ExpressResponse,
@@ -9,8 +10,10 @@ import {
   OneUptimeRequest,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
+import logger from "../Utils/Logger";
 import BaseAPI from "./BaseAPI";
 import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
 import UserCall from "../../Models/DatabaseModels/UserCall";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 
@@ -52,6 +55,7 @@ export default class UserCallAPI extends BaseAPI<
             },
             select: {
               userId: true,
+              projectId: true,
               verificationCode: true,
             },
           });
@@ -95,6 +99,21 @@ export default class UserCallAPI extends BaseAPI<
             },
           });
 
+          // Create default notification rules for this verified call number
+          try {
+            await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+              {
+                projectId: new ObjectID(item.projectId!.toString()),
+                userId: new ObjectID(item.userId!.toString()),
+                notificationMethod: {
+                  userCallId: item.id!,
+                },
+              },
+            );
+          } catch (e) {
+            logger.error(e);
+          }
+
           return Response.sendEmptySuccessResponse(req, res);
         } catch (err) {
           return next(err);

package/Server/API/UserEmailAPI.ts

@@ -2,6 +2,7 @@ import UserMiddleware from "../Middleware/UserAuthorization";
 import UserEmailService, {
   Service as UserEmailServiceType,
 } from "../Services/UserEmailService";
+import UserNotificationRuleService from "../Services/UserNotificationRuleService";
 import {
   ExpressRequest,
   ExpressResponse,
@@ -9,8 +10,10 @@ import {
   OneUptimeRequest,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
+import logger from "../Utils/Logger";
 import BaseAPI from "./BaseAPI";
 import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
 import UserEmail from "../../Models/DatabaseModels/UserEmail";
 
 export default class UserEmailAPI extends BaseAPI<
@@ -51,6 +54,7 @@ export default class UserEmailAPI extends BaseAPI<
             },
             select: {
               userId: true,
+              projectId: true,
               verificationCode: true,
             },
           });
@@ -94,6 +98,21 @@ export default class UserEmailAPI extends BaseAPI<
             },
           });
 
+          // Create default notification rules for this verified email
+          try {
+            await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+              {
+                projectId: new ObjectID(item.projectId!.toString()),
+                userId: new ObjectID(item.userId!.toString()),
+                notificationMethod: {
+                  userEmailId: item.id!,
+                },
+              },
+            );
+          } catch (e) {
+            logger.error(e);
+          }
+
           return Response.sendEmptySuccessResponse(req, res);
         } catch (err) {
           return next(err);

package/Server/API/UserPushAPI.ts

@@ -2,8 +2,10 @@ import UserMiddleware from "../Middleware/UserAuthorization";
 import UserPushService, {
   Service as UserPushServiceType,
 } from "../Services/UserPushService";
+import UserNotificationRuleService from "../Services/UserNotificationRuleService";
 import PushNotificationService from "../Services/PushNotificationService";
 import PushNotificationUtil from "../Utils/PushNotificationUtil";
+import logger from "../Utils/Logger";
 import {
   ExpressRequest,
   ExpressResponse,
@@ -13,11 +15,23 @@ import {
 import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
 import BadDataException from "../../Types/Exception/BadDataException";
+import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
 import ObjectID from "../../Types/ObjectID";
 import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import UserPush from "../../Models/DatabaseModels/UserPush";
 import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
 
+function getAuthenticatedUserId(req: ExpressRequest): ObjectID {
+  const userId: ObjectID | undefined = (req as OneUptimeRequest)
+    .userAuthorization?.userId;
+  if (!userId) {
+    throw new NotAuthenticatedException(
+      "You must be logged in to perform this action.",
+    );
+  }
+  return userId;
+}
+
 export default class UserPushAPI extends BaseAPI<
   UserPush,
   UserPushServiceType
@@ -32,6 +46,8 @@ export default class UserPushAPI extends BaseAPI<
         try {
           req = req as OneUptimeRequest;
 
+          const userId: ObjectID = getAuthenticatedUserId(req);
+
           if (!req.body.deviceToken) {
             return Response.sendErrorResponse(
               req,
@@ -65,7 +81,7 @@ export default class UserPushAPI extends BaseAPI<
           // Check if device is already registered
           const existingDevice: UserPush | null = await this.service.findOneBy({
             query: {
-              userId: (req as OneUptimeRequest).userAuthorization!.userId!,
+              userId: userId,
               projectId: new ObjectID(req.body.projectId),
               deviceToken: req.body.deviceToken,
             },
@@ -78,17 +94,18 @@ export default class UserPushAPI extends BaseAPI<
           });
 
           if (existingDevice) {
-            // Mark as used and return a specific response indicating device was already registered
-            throw new BadDataException(
-              "This device is already registered for push notifications",
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "This device is already registered for push notifications",
+              ),
             );
           }
 
           // Create new device registration
           const userPush: UserPush = new UserPush();
-          userPush.userId = (
-            req as OneUptimeRequest
-          ).userAuthorization!.userId!;
+          userPush.userId = userId;
           userPush.projectId = new ObjectID(req.body.projectId);
           userPush.deviceToken = req.body.deviceToken;
           userPush.deviceType = req.body.deviceType;
@@ -102,6 +119,21 @@ export default class UserPushAPI extends BaseAPI<
             },
           });
 
+          // Create default notification rules for this registered push device
+          try {
+            await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+              {
+                projectId: new ObjectID(req.body.projectId),
+                userId,
+                notificationMethod: {
+                  userPushId: savedDevice.id!,
+                },
+              },
+            );
+          } catch (e) {
+            logger.error(e);
+          }
+
           return Response.sendJsonObjectResponse(req, res, {
             success: true,
             deviceId: savedDevice._id!.toString(),
@@ -119,6 +151,8 @@ export default class UserPushAPI extends BaseAPI<
         try {
           req = req as OneUptimeRequest;
 
+          const userId: ObjectID = getAuthenticatedUserId(req);
+
           if (!req.body.deviceToken) {
             return Response.sendErrorResponse(
               req,
@@ -127,9 +161,6 @@ export default class UserPushAPI extends BaseAPI<
             );
           }
 
-          const userId: ObjectID = (req as OneUptimeRequest).userAuthorization!
-            .userId!;
-
           await this.service.deleteBy({
             query: {
               userId: userId,
@@ -159,6 +190,8 @@ export default class UserPushAPI extends BaseAPI<
         try {
           req = req as OneUptimeRequest;
 
+          const userId: ObjectID = getAuthenticatedUserId(req);
+
           if (!req.params["deviceId"]) {
             return Response.sendErrorResponse(
               req,
@@ -192,10 +225,7 @@ export default class UserPushAPI extends BaseAPI<
           }
 
           // Check if the device belongs to the current user
-          if (
-            device.userId?.toString() !==
-            (req as OneUptimeRequest).userAuthorization!.userId!.toString()
-          ) {
+          if (device.userId?.toString() !== userId.toString()) {
             return Response.sendErrorResponse(
               req,
               res,
@@ -264,6 +294,8 @@ export default class UserPushAPI extends BaseAPI<
         try {
           req = req as OneUptimeRequest;
 
+          const userId: ObjectID = getAuthenticatedUserId(req);
+
           if (!req.params["deviceId"]) {
             return Response.sendErrorResponse(
               req,
@@ -279,6 +311,7 @@ export default class UserPushAPI extends BaseAPI<
             },
             select: {
               userId: true,
+              projectId: true,
             },
           });
 
@@ -291,10 +324,7 @@ export default class UserPushAPI extends BaseAPI<
           }
 
           // Check if the device belongs to the current user
-          if (
-            device.userId?.toString() !==
-            (req as OneUptimeRequest).userAuthorization!.userId!.toString()
-          ) {
+          if (device.userId?.toString() !== userId.toString()) {
             return Response.sendErrorResponse(
               req,
               res,
@@ -304,6 +334,21 @@ export default class UserPushAPI extends BaseAPI<
 
           await this.service.verifyDevice(device._id!.toString());
 
+          // Create default notification rules for this verified push device
+          try {
+            await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+              {
+                projectId: new ObjectID(device.projectId!.toString()),
+                userId,
+                notificationMethod: {
+                  userPushId: device.id!,
+                },
+              },
+            );
+          } catch (e) {
+            logger.error(e);
+          }
+
           return Response.sendEmptySuccessResponse(req, res);
         } catch (error) {
           return next(error);
@@ -318,6 +363,8 @@ export default class UserPushAPI extends BaseAPI<
         try {
           req = req as OneUptimeRequest;
 
+          const userId: ObjectID = getAuthenticatedUserId(req);
+
           if (!req.params["deviceId"]) {
             return Response.sendErrorResponse(
               req,
@@ -345,10 +392,7 @@ export default class UserPushAPI extends BaseAPI<
           }
 
           // Check if the device belongs to the current user
-          if (
-            device.userId?.toString() !==
-            (req as OneUptimeRequest).userAuthorization!.userId!.toString()
-          ) {
+          if (device.userId?.toString() !== userId.toString()) {
             return Response.sendErrorResponse(
               req,
               res,

package/Server/API/UserSmsAPI.ts

@@ -2,6 +2,7 @@ import UserMiddleware from "../Middleware/UserAuthorization";
 import UserSMSService, {
   Service as UserSMSServiceType,
 } from "../Services/UserSmsService";
+import UserNotificationRuleService from "../Services/UserNotificationRuleService";
 import {
   ExpressRequest,
   ExpressResponse,
@@ -9,8 +10,10 @@ import {
   OneUptimeRequest,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
+import logger from "../Utils/Logger";
 import BaseAPI from "./BaseAPI";
 import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 
 export default class UserSMSAPI extends BaseAPI<UserSMS, UserSMSServiceType> {
@@ -48,6 +51,7 @@ export default class UserSMSAPI extends BaseAPI<UserSMS, UserSMSServiceType> {
             },
             select: {
               userId: true,
+              projectId: true,
               verificationCode: true,
             },
           });
@@ -91,6 +95,21 @@ export default class UserSMSAPI extends BaseAPI<UserSMS, UserSMSServiceType> {
             },
           });
 
+          // Create default notification rules for this verified SMS
+          try {
+            await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+              {
+                projectId: new ObjectID(item.projectId!.toString()),
+                userId: new ObjectID(item.userId!.toString()),
+                notificationMethod: {
+                  userSmsId: item.id!,
+                },
+              },
+            );
+          } catch (e) {
+            logger.error(e);
+          }
+
           return Response.sendEmptySuccessResponse(req, res);
         } catch (err) {
           return next(err);

package/Server/API/UserWhatsAppAPI.ts

@@ -2,6 +2,7 @@ import UserMiddleware from "../Middleware/UserAuthorization";
 import UserWhatsAppService, {
   Service as UserWhatsAppServiceType,
 } from "../Services/UserWhatsAppService";
+import UserNotificationRuleService from "../Services/UserNotificationRuleService";
 import {
   ExpressRequest,
   ExpressResponse,
@@ -9,8 +10,10 @@ import {
   OneUptimeRequest,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
+import logger from "../Utils/Logger";
 import BaseAPI from "./BaseAPI";
 import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 
 export default class UserWhatsAppAPI extends BaseAPI<
@@ -50,6 +53,7 @@ export default class UserWhatsAppAPI extends BaseAPI<
             },
             select: {
               userId: true,
+              projectId: true,
               verificationCode: true,
               isVerified: true,
             },
@@ -100,6 +104,21 @@ export default class UserWhatsAppAPI extends BaseAPI<
             },
           });
 
+          // Create default notification rules for this verified WhatsApp number
+          try {
+            await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+              {
+                projectId: new ObjectID(item.projectId!.toString()),
+                userId: new ObjectID(item.userId!.toString()),
+                notificationMethod: {
+                  userWhatsAppId: item.id!,
+                },
+              },
+            );
+          } catch (e) {
+            logger.error(e);
+          }
+
           return Response.sendEmptySuccessResponse(req, res);
         } catch (err) {
           return next(err);

package/Server/EnvironmentConfig.ts

@@ -161,6 +161,14 @@ export const ClusterKey: ObjectID = new ObjectID(
 
 export const HasClusterKey: boolean = Boolean(process.env["ONEUPTIME_SECRET"]);
 
+export const RegisterProbeKey: ObjectID = new ObjectID(
+  process.env["REGISTER_PROBE_KEY"] || "secret",
+);
+
+export const HasRegisterProbeKey: boolean = Boolean(
+  process.env["REGISTER_PROBE_KEY"],
+);
+
 export const AppApiHostname: Hostname = Hostname.fromString(
   `${process.env["SERVER_APP_HOSTNAME"] || "localhost"}:${
     process.env["APP_PORT"] || 80
@@ -529,6 +537,13 @@ export const VapidPrivateKey: string | undefined =
 export const VapidSubject: string =
   process.env["VAPID_SUBJECT"] || "mailto:support@oneuptime.com";
 
+export const ExpoAccessToken: string | undefined =
+  process.env["EXPO_ACCESS_TOKEN"] || undefined;
+
+export const PushNotificationRelayUrl: string =
+  process.env["PUSH_NOTIFICATION_RELAY_URL"] ||
+  "https://oneuptime.com/api/notification/push-relay/send";
+
 export const EnterpriseLicenseValidationUrl: URL = URL.fromString(
   "https://oneuptime.com/api/enterprise-license/validate",
 );

package/Server/Services/PushNotificationService.ts

@@ -10,9 +10,16 @@ import {
   VapidPublicKey,
   VapidPrivateKey,
   VapidSubject,
+  ExpoAccessToken,
+  PushNotificationRelayUrl,
 } from "../EnvironmentConfig";
 import webpush from "web-push";
 import { Expo, ExpoPushMessage, ExpoPushTicket } from "expo-server-sdk";
+import API from "../../Utils/API";
+import URL from "../../Types/API/URL";
+import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import { JSONObject } from "../../Types/JSON";
 import PushNotificationUtil from "../Utils/PushNotificationUtil";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import UserPush from "../../Models/DatabaseModels/UserPush";
@@ -43,7 +50,9 @@ export interface PushNotificationOptions {
 
 export default class PushNotificationService {
   public static isWebPushInitialized = false;
-  private static expoClient: Expo = new Expo();
+  private static expoClient: Expo = new Expo(
+    ExpoAccessToken ? { accessToken: ExpoAccessToken } : undefined,
+  );
 
   public static initializeWebPush(): void {
     if (this.isWebPushInitialized) {
@@ -340,20 +349,33 @@ export default class PushNotificationService {
       );
     }
 
-    try {
-      const dataPayload: { [key: string]: string } = {};
-      if (message.data) {
-        for (const key of Object.keys(message.data)) {
-          dataPayload[key] = String(message.data[key]);
-        }
-      }
-      if (message.url || message.clickAction) {
-        dataPayload["url"] = message.url || message.clickAction || "";
+    const dataPayload: { [key: string]: string } = {};
+    if (message.data) {
+      for (const key of Object.keys(message.data)) {
+        dataPayload[key] = String(message.data[key]);
       }
+    }
+    if (message.url || message.clickAction) {
+      dataPayload["url"] = message.url || message.clickAction || "";
+    }
 
-      const channelId: string =
-        deviceType === PushDeviceType.Android ? "oncall_high" : "default";
+    const channelId: string =
+      deviceType === PushDeviceType.Android ? "oncall_high" : "default";
+
+    // If EXPO_ACCESS_TOKEN is not set, relay through the push notification gateway
+    if (!ExpoAccessToken) {
+      await this.sendViaRelay(
+        expoPushToken,
+        message,
+        dataPayload,
+        channelId,
+        deviceType,
+      );
+      return;
+    }
 
+    // Send directly via Expo SDK
+    try {
       const expoPushMessage: ExpoPushMessage = {
         to: expoPushToken,
         title: message.title,
@@ -403,6 +425,108 @@ export default class PushNotificationService {
     }
   }
 
+  private static async sendViaRelay(
+    expoPushToken: string,
+    message: PushNotificationMessage,
+    dataPayload: { [key: string]: string },
+    channelId: string,
+    deviceType: PushDeviceType,
+  ): Promise<void> {
+    logger.info(
+      `Sending ${deviceType} push notification via relay: ${PushNotificationRelayUrl}`,
+    );
+
+    try {
+      const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.post<JSONObject>({
+          url: URL.fromString(PushNotificationRelayUrl),
+          data: {
+            to: expoPushToken,
+            title: message.title || "",
+            body: message.body || "",
+            data: dataPayload,
+            sound: "default",
+            priority: "high",
+            channelId: channelId,
+          },
+        });
+
+      if (response instanceof HTTPErrorResponse) {
+        throw new Error(
+          `Push relay error: ${JSON.stringify(response.jsonData)}`,
+        );
+      }
+
+      logger.info(
+        `Push notification sent via relay successfully to ${deviceType} device`,
+      );
+    } catch (error: any) {
+      logger.error(
+        `Failed to send push notification via relay to ${deviceType} device: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  public static isValidExpoPushToken(token: string): boolean {
+    return Expo.isExpoPushToken(token);
+  }
+
+  public static hasExpoAccessToken(): boolean {
+    return Boolean(ExpoAccessToken);
+  }
+
+  public static async sendRelayPushNotification(data: {
+    to: string;
+    title?: string;
+    body?: string;
+    data?: { [key: string]: string };
+    sound?: string;
+    priority?: string;
+    channelId?: string;
+  }): Promise<void> {
+    if (!ExpoAccessToken) {
+      throw new Error(
+        "Push relay is not configured. EXPO_ACCESS_TOKEN is not set on this server.",
+      );
+    }
+
+    const expoPushMessage: ExpoPushMessage = {
+      to: data.to,
+      title: data.title || "",
+      body: data.body || "",
+      data: data.data || {},
+      sound: (data.sound as "default" | null) || "default",
+      priority: (data.priority as "default" | "normal" | "high") || "high",
+      channelId: data.channelId || "default",
+    };
+
+    const tickets: ExpoPushTicket[] =
+      await this.expoClient.sendPushNotificationsAsync([expoPushMessage]);
+
+    const ticket: ExpoPushTicket | undefined = tickets[0];
+
+    if (ticket && ticket.status === "error") {
+      const errorTicket: ExpoPushTicket & {
+        message?: string;
+        details?: { error?: string };
+      } = ticket as ExpoPushTicket & {
+        message?: string;
+        details?: { error?: string };
+      };
+
+      logger.error(
+        `Push relay: Expo push notification error: ${errorTicket.message}`,
+      );
+
+      throw new Error(
+        `Failed to send push notification: ${errorTicket.message}`,
+      );
+    }
+
+    logger.info(`Push relay: notification sent successfully to ${data.to}`);
+  }
+
   public static async sendPushNotificationToUser(
     userId: ObjectID,
     projectId: ObjectID,