@oneuptime/common 9.4.7 → 9.4.9

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

@@ -223,7 +223,19 @@ import { AddIncomingEmailMonitor1768335589018 } from "./1768335589018-AddIncomin
 import { MigrationName1768422356713 } from "./1768422356713-MigrationName";
 import { MigrationName1768583966447 } from "./1768583966447-MigrationName";
 import { MigrationName1768825402472 } from "./1768825402472-MigrationName";
+import { MigrationName1768938069147 } from "./1768938069147-MigrationName";
+import { MigrationName1769125561322 } from "./1769125561322-MigrationName";
 import { MigrationName1769169355244 } from "./1769169355244-MigrationName";
+import { MigrationName1769170578688 } from "./1769170578688-MigrationName";
+import { MigrationName1769172358833 } from "./1769172358833-MigrationName";
+import { MigrationName1769176450526 } from "./1769176450526-MigrationName";
+import { MigrationName1769190495840 } from "./1769190495840-MigrationName";
+import { MigrationName1769199303656 } from "./1769199303656-MigrationName";
+import { MigrationName1769202898645 } from "./1769202898645-MigrationName";
+import { MigrationName1769428619414 } from "./1769428619414-MigrationName";
+import { MigrationName1769428821686 } from "./1769428821686-MigrationName";
+import { MigrationName1769469813786 } from "./1769469813786-MigrationName";
+import { RenameNotificationRuleTypes1769517677937 } from "./1769517677937-RenameNotificationRuleTypes";
 
 export default [
   InitialMigration,
@@ -452,4 +464,16 @@ export default [
   MigrationName1768583966447,
   MigrationName1768825402472,
   MigrationName1769169355244,
+  MigrationName1768938069147,
+  MigrationName1769125561322,
+  MigrationName1769170578688,
+  MigrationName1769172358833,
+  MigrationName1769176450526,
+  MigrationName1769190495840,
+  MigrationName1769199303656,
+  MigrationName1769202898645,
+  MigrationName1769428619414,
+  MigrationName1769428821686,
+  MigrationName1769469813786,
+  RenameNotificationRuleTypes1769517677937,
 ];

package/Server/Services/AlertEpisodeFeedService.ts

@@ -0,0 +1,94 @@
+import { Blue500 } from "../../Types/BrandColors";
+import Color from "../../Types/Color";
+import OneUptimeDate from "../../Types/Date";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger from "../Utils/Logger";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  AlertEpisodeFeedEventType,
+} from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  public async createAlertEpisodeFeedItem(data: {
+    alertEpisodeId: ObjectID;
+    feedInfoInMarkdown: string;
+    alertEpisodeFeedEventType: AlertEpisodeFeedEventType;
+    projectId: ObjectID;
+    moreInformationInMarkdown?: string | undefined;
+    displayColor?: Color | undefined;
+    userId?: ObjectID | undefined;
+    postedAt?: Date | undefined;
+  }): Promise<void> {
+    try {
+      if (!data.alertEpisodeId) {
+        throw new BadDataException("Alert Episode ID is required");
+      }
+
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
+
+      if (!data.alertEpisodeFeedEventType) {
+        throw new BadDataException("Alert episode log event is required");
+      }
+
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
+
+      const alertEpisodeFeed: Model = new Model();
+
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
+
+      if (data.userId) {
+        alertEpisodeFeed.userId = data.userId;
+      }
+
+      alertEpisodeFeed.displayColor = data.displayColor;
+
+      alertEpisodeFeed.alertEpisodeId = data.alertEpisodeId;
+      alertEpisodeFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      alertEpisodeFeed.alertEpisodeFeedEventType =
+        data.alertEpisodeFeedEventType;
+      alertEpisodeFeed.projectId = data.projectId;
+
+      if (!data.postedAt) {
+        alertEpisodeFeed.postedAt = OneUptimeDate.getCurrentDate();
+      } else {
+        alertEpisodeFeed.postedAt = data.postedAt;
+      }
+
+      if (data.moreInformationInMarkdown) {
+        alertEpisodeFeed.moreInformationInMarkdown =
+          data.moreInformationInMarkdown;
+      }
+
+      await this.create({
+        data: alertEpisodeFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (error) {
+      logger.error("AlertEpisodeFeedService.createAlertEpisodeFeedItem");
+      logger.error(error);
+      // we dont want to throw the error here, as this is a non-critical operation
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/AlertEpisodeInternalNoteService.ts

@@ -0,0 +1,71 @@
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AlertEpisodeInternalNote";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import File from "../../Models/DatabaseModels/File";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async addNote(data: {
+    userId: ObjectID;
+    alertEpisodeId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+    attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.alertEpisodeId = data.alertEpisodeId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    if (data.postedFromSlackMessageId) {
+      internalNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
+    if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
+      internalNote.attachments = data.attachmentFileIds.map(
+        (fileId: ObjectID) => {
+          const file: File = new File();
+          file.id = fileId;
+          return file;
+        },
+      );
+    }
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    alertEpisodeId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        alertEpisodeId: data.alertEpisodeId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+}
+
+export default new Service();

package/Server/Services/AlertEpisodeMemberService.ts

@@ -0,0 +1,267 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import Model from "../../Models/DatabaseModels/AlertEpisodeMember";
+import Alert from "../../Models/DatabaseModels/Alert";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import { Yellow500, Green500 } from "../../Types/BrandColors";
+import OneUptimeDate from "../../Types/Date";
+import AlertService from "./AlertService";
+import AlertEpisodeService from "./AlertEpisodeService";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.data.alertEpisodeId) {
+      throw new BadDataException("alertEpisodeId is required");
+    }
+
+    if (!createBy.data.alertId) {
+      throw new BadDataException("alertId is required");
+    }
+
+    // Check if this alert is already in the episode
+    const existingMember: Model | null = await this.findOneBy({
+      query: {
+        alertEpisodeId: createBy.data.alertEpisodeId,
+        alertId: createBy.data.alertId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+      },
+    });
+
+    if (existingMember) {
+      throw new BadDataException("Alert is already a member of this episode");
+    }
+
+    // Set addedAt if not provided
+    if (!createBy.data.addedAt) {
+      createBy.data.addedAt = OneUptimeDate.getCurrentDate();
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (!createdItem.alertEpisodeId) {
+      throw new BadDataException("alertEpisodeId is required");
+    }
+
+    if (!createdItem.alertId) {
+      throw new BadDataException("alertId is required");
+    }
+
+    if (!createdItem.projectId) {
+      throw new BadDataException("projectId is required");
+    }
+
+    // Update alert's episode reference
+    await AlertService.updateOneById({
+      id: createdItem.alertId,
+      data: {
+        alertEpisodeId: createdItem.alertEpisodeId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Update episode's alertCount and lastAlertAddedAt
+    Promise.resolve()
+      .then(async () => {
+        try {
+          await AlertEpisodeService.updateAlertCount(
+            createdItem.alertEpisodeId!,
+          );
+          await AlertEpisodeService.updateLastAlertAddedAt(
+            createdItem.alertEpisodeId!,
+          );
+        } catch (error) {
+          logger.error(
+            `Error updating episode counts in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
+      .catch((error: Error) => {
+        logger.error(
+          `Critical error in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
+        );
+      });
+
+    // Get alert details for feed
+    const alert: Alert | null = await AlertService.findOneById({
+      id: createdItem.alertId,
+      select: {
+        alertNumber: true,
+        title: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Create feed item
+    await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+      alertEpisodeId: createdItem.alertEpisodeId,
+      projectId: createdItem.projectId,
+      alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertAdded,
+      displayColor: Yellow500,
+      feedInfoInMarkdown: `**Alert #${alert?.alertNumber || "N/A"}** added to episode: ${alert?.title || "No title"}`,
+      userId: createdItem.addedByUserId || undefined,
+    });
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    // Get the member records before deletion
+    const membersToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        alertEpisodeId: true,
+        alertId: true,
+        projectId: true,
+      },
+      limit: 100,
+      skip: 0,
+    });
+
+    return {
+      deleteBy,
+      carryForward: membersToDelete,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: ObjectID[],
+  ): Promise<OnDelete<Model>> {
+    const membersDeleted: Model[] = onDelete.carryForward as Model[];
+
+    if (membersDeleted && membersDeleted.length > 0) {
+      for (const member of membersDeleted) {
+        if (member.alertId) {
+          // Clear the episode reference from the alert
+          await AlertService.updateOneById({
+            id: member.alertId,
+            data: {
+              alertEpisodeId: undefined as any,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Get alert details for feed
+          const alert: Alert | null = await AlertService.findOneById({
+            id: member.alertId,
+            select: {
+              alertNumber: true,
+              title: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Create feed item for removal
+          if (member.alertEpisodeId && member.projectId) {
+            await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+              alertEpisodeId: member.alertEpisodeId,
+              projectId: member.projectId,
+              alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertRemoved,
+              displayColor: Green500,
+              feedInfoInMarkdown: `**Alert #${alert?.alertNumber || "N/A"}** removed from episode: ${alert?.title || "No title"}`,
+            });
+          }
+        }
+
+        if (member.alertEpisodeId) {
+          // Update episode's alertCount
+          await AlertEpisodeService.updateAlertCount(member.alertEpisodeId);
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public async getAlertsInEpisode(episodeId: ObjectID): Promise<ObjectID[]> {
+    const members: Model[] = await this.findBy({
+      query: {
+        alertEpisodeId: episodeId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        alertId: true,
+      },
+      limit: 1000,
+      skip: 0,
+    });
+
+    return members
+      .filter((m: Model) => {
+        return m.alertId;
+      })
+      .map((m: Model) => {
+        return m.alertId!;
+      });
+  }
+
+  @CaptureSpan()
+  public async isAlertInEpisode(
+    alertId: ObjectID,
+    episodeId: ObjectID,
+  ): Promise<boolean> {
+    const member: Model | null = await this.findOneBy({
+      query: {
+        alertId: alertId,
+        alertEpisodeId: episodeId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+      },
+    });
+
+    return member !== null;
+  }
+}
+
+export default new Service();

package/Server/Services/AlertEpisodeOwnerTeamService.ts

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

package/Server/Services/AlertEpisodeOwnerUserService.ts

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