@oneuptime/common 7.0.3480 → 7.0.3517

package/Server/Infrastructure/Postgres/SchemaMigrations/1736856662868-MigrationName.ts

@@ -0,0 +1,27 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1736856662868 implements MigrationInterface {
+  public name = "MigrationName1736856662868";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFeed" ADD "postedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertFeed" ADD "postedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceFeed" ADD "postedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceFeed" DROP COLUMN "postedAt"`,
+    );
+    await queryRunner.query(`ALTER TABLE "AlertFeed" DROP COLUMN "postedAt"`);
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFeed" DROP COLUMN "postedAt"`,
+    );
+  }
+}

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

@@ -88,6 +88,13 @@ import { MigrationName1736364478985 } from "./1736364478985-MigrationName";
 import { MigrationName1736364957990 } from "./1736364957990-MigrationName";
 import { MigrationName1736365532085 } from "./1736365532085-MigrationName";
 import { MigrationName1736675947746 } from "./1736675947746-MigrationName";
+import { MigrationName1736703138918 } from "./1736703138918-MigrationName";
+import { MigrationName1736780194077 } from "./1736780194077-MigrationName";
+import { MigrationName1736780194078 } from "./1736780194078-MigrationName";
+import { MigrationName1736787495707 } from "./1736787495707-MigrationName";
+import { MigrationName1736787985322 } from "./1736787985322-MigrationName";
+import { MigrationName1736788706141 } from "./1736788706141-MigrationName";
+import { MigrationName1736856662868 } from "./1736856662868-MigrationName";
 
 export default [
   InitialMigration,
@@ -180,4 +187,11 @@ export default [
   MigrationName1736364957990,
   MigrationName1736365532085,
   MigrationName1736675947746,
+  MigrationName1736703138918,
+  MigrationName1736780194077,
+  MigrationName1736780194078,
+  MigrationName1736787495707,
+  MigrationName1736787985322,
+  MigrationName1736788706141,
+  MigrationName1736856662868,
 ];

package/Server/Services/AlertFeedService.ts

@@ -0,0 +1,81 @@
+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 DatabaseService from "./DatabaseService";
+import Model, {
+  AlertFeedEventType,
+} from "Common/Models/DatabaseModels/AlertFeed";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
+  }
+
+  public async createAlertFeed(data: {
+    alertId: ObjectID;
+    feedInfoInMarkdown: string;
+    alertFeedEventType: AlertFeedEventType;
+    projectId: ObjectID;
+    moreInformationInMarkdown?: string | undefined;
+    displayColor?: Color | undefined;
+    userId?: ObjectID | undefined;
+    postedAt?: Date | undefined;
+  }): Promise<Model> {
+    if (!data.alertId) {
+      throw new BadDataException("Alert ID is required");
+    }
+
+    if (!data.feedInfoInMarkdown) {
+      throw new BadDataException("Log in markdown is required");
+    }
+
+    if (!data.alertFeedEventType) {
+      throw new BadDataException("Alert log event is required");
+    }
+
+    if (!data.projectId) {
+      throw new BadDataException("Project ID is required");
+    }
+
+    const alertFeed: Model = new Model();
+
+    if (!data.displayColor) {
+      data.displayColor = Blue500;
+    }
+
+    if (data.userId) {
+      alertFeed.userId = data.userId;
+    }
+
+    alertFeed.displayColor = data.displayColor;
+
+    alertFeed.alertId = data.alertId;
+    alertFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+    alertFeed.alertFeedEventType = data.alertFeedEventType;
+    alertFeed.projectId = data.projectId;
+
+    if (!data.postedAt) {
+      alertFeed.postedAt = OneUptimeDate.getCurrentDate();
+    }
+
+    if (data.moreInformationInMarkdown) {
+      alertFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+    }
+
+    return await this.create({
+      data: alertFeed,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentFeedService.ts

@@ -0,0 +1,89 @@
+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 IncidentFeed, {
+  IncidentFeedEventType,
+} from "Common/Models/DatabaseModels/IncidentFeed";
+
+export class Service extends DatabaseService<IncidentFeed> {
+  public constructor() {
+    super(IncidentFeed);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 120);
+    }
+  }
+
+  public async createIncidentFeed(data: {
+    incidentId: ObjectID;
+    feedInfoInMarkdown: string;
+    incidentFeedEventType: IncidentFeedEventType;
+    projectId: ObjectID;
+    moreInformationInMarkdown?: string | undefined;
+    displayColor?: Color | undefined;
+    userId?: ObjectID | undefined;
+    postedAt?: Date | undefined;
+  }): Promise<IncidentFeed> {
+    logger.debug("IncidentFeedService.createIncidentFeed");
+    logger.debug(data);
+
+    const incidentFeed: IncidentFeed = new IncidentFeed();
+
+    if (!data.incidentId) {
+      throw new BadDataException("Incident ID is required");
+    }
+
+    if (!data.feedInfoInMarkdown) {
+      throw new BadDataException("Log in markdown is required");
+    }
+
+    if (!data.incidentFeedEventType) {
+      throw new BadDataException("Incident log event is required");
+    }
+
+    if (!data.projectId) {
+      throw new BadDataException("Project ID is required");
+    }
+
+    if (!data.displayColor) {
+      data.displayColor = Blue500;
+    }
+
+    incidentFeed.displayColor = data.displayColor;
+    incidentFeed.incidentId = data.incidentId;
+    incidentFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+    incidentFeed.incidentFeedEventType = data.incidentFeedEventType;
+    incidentFeed.projectId = data.projectId;
+
+    if (!data.postedAt) {
+      incidentFeed.postedAt = OneUptimeDate.getCurrentDate();
+    }
+
+    if (data.userId) {
+      incidentFeed.userId = data.userId;
+    }
+
+    if (data.moreInformationInMarkdown) {
+      incidentFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+    }
+
+    const createdIncidentFeed: IncidentFeed = await this.create({
+      data: incidentFeed,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    logger.debug("Incident Feed created");
+    logger.debug(createdIncidentFeed);
+
+    return createdIncidentFeed;
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentInternalNoteService.ts

@@ -1,10 +1,38 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/IncidentInternalNote";
+import { OnCreate } from "../Types/Database/Hooks";
+import IncidentFeedService from "./IncidentFeedService";
+import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import { Blue500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await IncidentFeedService.createIncidentFeed({
+      incidentId: createdItem.incidentId!,
+      projectId: createdItem.projectId!,
+      incidentFeedEventType: IncidentFeedEventType.PrivateNote,
+      displayColor: Blue500,
+      userId: userId || undefined,
+
+      feedInfoInMarkdown: `**Posted Internal / Private Note**
+
+${createdItem.note}
+          `,
+    });
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentOwnerTeamService.ts

@@ -1,10 +1,122 @@
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/IncidentOwnerTeam";
+import IncidentFeedService from "./IncidentFeedService";
+import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import TeamService from "./TeamService";
+import Team from "../../Models/DatabaseModels/Team";
+import DeleteBy from "../Types/Database/DeleteBy";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        incidentId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const incidentId: ObjectID | undefined = item.incidentId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (incidentId && teamId && projectId) {
+        const team: Team | null = await TeamService.findOneById({
+          id: teamId,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (team && team.name) {
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: projectId,
+            incidentFeedEventType: IncidentFeedEventType.OwnerTeamRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**Team ${team.name}** was removed from the incident as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add incident feed.
+
+    const incidentId: ObjectID | undefined = createdItem.incidentId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (incidentId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await IncidentFeedService.createIncidentFeed({
+          incidentId: incidentId,
+          projectId: projectId,
+          incidentFeedEventType: IncidentFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**Team ${team.name}** was added to the incident as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentOwnerUserService.ts

@@ -1,10 +1,124 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/IncidentOwnerUser";
+import IncidentFeedService from "./IncidentFeedService";
+import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import User from "../../Models/DatabaseModels/User";
+import UserService from "./UserService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        incidentId: true,
+        projectId: true,
+        userId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const incidentId: ObjectID | undefined = item.incidentId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (incidentId && userId && projectId) {
+        const user: User | null = await UserService.findOneById({
+          id: userId,
+          select: {
+            name: true,
+            email: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (user && user.name) {
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: projectId,
+            incidentFeedEventType: IncidentFeedEventType.OwnerUserRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the incident as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add incident feed.
+
+    const incidentId: ObjectID | undefined = createdItem.incidentId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (incidentId && userId && projectId) {
+      const user: User | null = await UserService.findOneById({
+        id: userId,
+        select: {
+          name: true,
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (user && user.name) {
+        await IncidentFeedService.createIncidentFeed({
+          incidentId: incidentId,
+          projectId: projectId,
+          incidentFeedEventType: IncidentFeedEventType.OwnerUserAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the incident as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentPublicNoteService.ts

@@ -3,6 +3,10 @@ import { OnCreate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import Model from "Common/Models/DatabaseModels/IncidentPublicNote";
+import IncidentFeedService from "./IncidentFeedService";
+import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import { Indigo500 } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -21,6 +25,28 @@ export class Service extends DatabaseService<Model> {
       carryForward: null,
     };
   }
+
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await IncidentFeedService.createIncidentFeed({
+      incidentId: createdItem.incidentId!,
+      projectId: createdItem.projectId!,
+      incidentFeedEventType: IncidentFeedEventType.PublicNote,
+      displayColor: Indigo500,
+      userId: userId || undefined,
+      feedInfoInMarkdown: `**Posted public note for this incident on status page**
+
+${createdItem.note}
+          `,
+    });
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentService.ts

@@ -47,6 +47,9 @@ import logger from "../Utils/Logger";
 import Semaphore, {
   SemaphoreMutex,
 } from "Common/Server/Infrastructure/Semaphore";
+import IncidentFeedService from "./IncidentFeedService";
+import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -326,6 +329,28 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    const createdByUserId: ObjectID | undefined | null =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await IncidentFeedService.createIncidentFeed({
+      incidentId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      incidentFeedEventType: IncidentFeedEventType.IncidentCreated,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Incident #${createdItem.incidentNumber?.toString()} Created**: 
+      
+**Incident Title**:
+
+${createdItem.title || "No title provided."}
+
+**Description**:
+
+${createdItem.description || "No description provided."}
+
+      `,
+      userId: createdByUserId || undefined,
+    });
+
     if (!createdItem.currentIncidentStateId) {
       throw new BadDataException("currentIncidentStateId is required");
     }
@@ -366,6 +391,26 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
+    await IncidentFeedService.createIncidentFeed({
+      incidentId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      incidentFeedEventType: IncidentFeedEventType.RootCause,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Root Cause**
+
+${createdItem.rootCause || "No root cause provided."}`,
+    });
+
+    await IncidentFeedService.createIncidentFeed({
+      incidentId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      incidentFeedEventType: IncidentFeedEventType.RemediationNotes,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Remediation Notes**
+
+${createdItem.remediationNotes || "No remediation notes provided."}`,
+    });
+
     // add owners.
 
     if (
@@ -597,6 +642,82 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    if (updatedItemIds.length > 0) {
+      for (const incidentId of updatedItemIds) {
+        if (onUpdate.updateBy.data.title) {
+          // add incident feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Incident title was updated.** Here's the new title.
+
+${onUpdate.updateBy.data.title || "No title provided."}
+          `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.rootCause) {
+          // add incident feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Incident root cause was updated.** Here's the new root cause.
+      
+${onUpdate.updateBy.data.rootCause || "No root cause provided."}
+        `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.description) {
+          // add incident feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Incident description was updated.** Here's the new description.
+      
+${onUpdate.updateBy.data.description || "No description provided."}
+        `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.remediationNotes) {
+          // add incident feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: incidentId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Remediation notes were updated.** Here are the new notes.
+
+${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
+            `,
+            userId: createdByUserId || undefined,
+          });
+        }
+      }
+    }
+
     return onUpdate;
   }