@oneuptime/common 9.4.12 → 9.4.13

package/Models/DatabaseModels/Index.ts

@@ -198,6 +198,15 @@ import AlertEpisodeInternalNote from "./AlertEpisodeInternalNote";
 import AlertEpisodeFeed from "./AlertEpisodeFeed";
 import AlertGroupingRule from "./AlertGroupingRule";
 
+import IncidentEpisode from "./IncidentEpisode";
+import IncidentEpisodeMember from "./IncidentEpisodeMember";
+import IncidentEpisodeStateTimeline from "./IncidentEpisodeStateTimeline";
+import IncidentEpisodeOwnerUser from "./IncidentEpisodeOwnerUser";
+import IncidentEpisodeOwnerTeam from "./IncidentEpisodeOwnerTeam";
+import IncidentEpisodeInternalNote from "./IncidentEpisodeInternalNote";
+import IncidentEpisodeFeed from "./IncidentEpisodeFeed";
+import IncidentGroupingRule from "./IncidentGroupingRule";
+
 import TableView from "./TableView";
 import Dashboard from "./Dashboard";
 
@@ -291,6 +300,15 @@ const AllModelTypes: Array<{
   AlertEpisodeFeed,
   AlertGroupingRule,
 
+  IncidentEpisode,
+  IncidentEpisodeMember,
+  IncidentEpisodeStateTimeline,
+  IncidentEpisodeOwnerUser,
+  IncidentEpisodeOwnerTeam,
+  IncidentEpisodeInternalNote,
+  IncidentEpisodeFeed,
+  IncidentGroupingRule,
+
   MonitorStatusTimeline,
 
   File,

package/Models/DatabaseModels/OnCallDutyPolicyExecutionLog.ts

@@ -26,6 +26,7 @@ import UserNotificationEventType from "../../Types/UserNotification/UserNotifica
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import Alert from "./Alert";
 import AlertEpisode from "./AlertEpisode";
+import IncidentEpisode from "./IncidentEpisode";
 import EnableWorkflow from "../../Types/Database/EnableWorkflow";
 
 @TableBillingAccessControl({
@@ -412,6 +413,75 @@ export default class OnCallDutyPolicyExecutionLog extends BaseModel {
   })
   public triggeredByAlertEpisodeId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectOnCallDutyPolicyExecutionLog,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicyExecutionLog,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "triggeredByIncidentEpisodeId",
+    type: TableColumnType.Entity,
+    modelType: IncidentEpisode,
+    title: "Triggered By Incident Episode",
+    description:
+      "Relation to the incident episode which triggered this on-call escalation policy.",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentEpisode;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "triggeredByIncidentEpisodeId" })
+  public triggeredByIncidentEpisode?: IncidentEpisode = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectOnCallDutyPolicyExecutionLog,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicyExecutionLog,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Triggered By Incident Episode ID",
+    description:
+      "ID of the incident episode which triggered this on-call escalation policy.",
+    example: "a7b8c9d0-e1f2-3456-0123-567890123456",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public triggeredByIncidentEpisodeId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/OnCallDutyPolicyExecutionLogTimeline.ts

@@ -28,6 +28,7 @@ import UserNotificationEventType from "../../Types/UserNotification/UserNotifica
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import Alert from "./Alert";
 import AlertEpisode from "./AlertEpisode";
+import IncidentEpisode from "./IncidentEpisode";
 
 @TableBillingAccessControl({
   create: PlanType.Growth,
@@ -347,6 +348,64 @@ export default class OnCallDutyPolicyExecutionLogTimeline extends BaseModel {
   })
   public triggeredByAlertEpisodeId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicyExecutionLogTimeline,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "triggeredByIncidentEpisodeId",
+    type: TableColumnType.Entity,
+    modelType: IncidentEpisode,
+    title: "Incident Episode",
+    description:
+      "Relation to Incident Episode Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentEpisode;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "triggeredByIncidentEpisodeId" })
+  public triggeredByIncidentEpisode?: IncidentEpisode = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicyExecutionLogTimeline,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Incident Episode ID",
+    description:
+      "ID of your OneUptime Incident Episode in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public triggeredByIncidentEpisodeId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

package/Models/DatabaseModels/UserOnCallLog.ts

@@ -29,6 +29,7 @@ import UserNotificationEventType from "../../Types/UserNotification/UserNotifica
 import UserNotificationExecutionStatus from "../../Types/UserNotification/UserNotificationExecutionStatus";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import AlertEpisode from "./AlertEpisode";
+import IncidentEpisode from "./IncidentEpisode";
 import Alert from "./Alert";
 
 @EnableDocumentation()
@@ -481,6 +482,53 @@ export default class UserOnCallLog extends BaseModel {
   })
   public triggeredByAlertEpisodeId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "triggeredByIncidentEpisodeId",
+    type: TableColumnType.Entity,
+    modelType: IncidentEpisode,
+    title: "Triggered By Incident Episode",
+    description:
+      "Relation to Incident Episode which triggered this on-call duty policy.",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentEpisode;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "triggeredByIncidentEpisodeId" })
+  public triggeredByIncidentEpisode?: IncidentEpisode = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Triggered By Incident Episode ID",
+    required: false,
+    description:
+      "ID of the Incident Episode which triggered this on-call escalation policy.",
+    example: "3c4d5e6f-7a8b-9c0d-1e2f-3a4b5c6d7e8f",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public triggeredByIncidentEpisodeId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [Permission.CurrentUser],

package/Models/DatabaseModels/UserOnCallLogTimeline.ts

@@ -1,6 +1,7 @@
 import Incident from "./Incident";
 import Alert from "./Alert";
 import AlertEpisode from "./AlertEpisode";
+import IncidentEpisode from "./IncidentEpisode";
 import OnCallDutyPolicy from "./OnCallDutyPolicy";
 import OnCallDutyPolicyEscalationRule from "./OnCallDutyPolicyEscalationRule";
 import OnCallDutyPolicyExecutionLog from "./OnCallDutyPolicyExecutionLog";
@@ -438,6 +439,54 @@ export default class UserOnCallLogTimeline extends BaseModel {
   })
   public triggeredByAlertEpisodeId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "triggeredByIncidentEpisodeId",
+    type: TableColumnType.Entity,
+    modelType: IncidentEpisode,
+    title: "Incident Episode",
+    description:
+      "Relation to Incident Episode Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentEpisode;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "triggeredByIncidentEpisodeId" })
+  public triggeredByIncidentEpisode?: IncidentEpisode = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Incident Episode ID",
+    description:
+      "ID of your OneUptime Incident Episode in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public triggeredByIncidentEpisodeId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [Permission.CurrentUser],

package/Models/DatabaseModels/WorkspaceNotificationLog.ts

@@ -2,6 +2,7 @@ import Project from "./Project";
 import Incident from "./Incident";
 import Alert from "./Alert";
 import AlertEpisode from "./AlertEpisode";
+import IncidentEpisode from "./IncidentEpisode";
 import ScheduledMaintenance from "./ScheduledMaintenance";
 import StatusPage from "./StatusPage";
 import StatusPageAnnouncement from "./StatusPageAnnouncement";
@@ -539,6 +540,62 @@ export default class WorkspaceNotificationLog extends BaseModel {
   })
   public alertEpisodeId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadPushLog,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "incidentEpisodeId",
+    type: TableColumnType.Entity,
+    modelType: IncidentEpisode,
+    title: "Incident Episode",
+    description: "Incident Episode associated with this message (if any)",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentEpisode;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "incidentEpisodeId" })
+  public incidentEpisode?: IncidentEpisode = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadPushLog,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Incident Episode ID",
+    description: "ID of Incident Episode associated with this message (if any)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public incidentEpisodeId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

package/Server/API/IncidentEpisodeAPI.ts

@@ -0,0 +1,150 @@
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
+import BadDataException from "../../Types/Exception/BadDataException";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import ObjectID from "../../Types/ObjectID";
+import IncidentEpisodeService, {
+  Service as IncidentEpisodeServiceType,
+} from "../Services/IncidentEpisodeService";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import AIService, { AILogRequest, AILogResponse } from "../Services/AIService";
+import IncidentEpisodeAIContextBuilder, {
+  IncidentEpisodeContextData,
+} from "../Utils/AI/IncidentEpisodeAIContextBuilder";
+import { AIGenerationContext } from "../Utils/AI/IncidentAIContextBuilder";
+import JSONFunctions from "../../Types/JSONFunctions";
+import Permission from "../../Types/Permission";
+
+export default class IncidentEpisodeAPI extends BaseAPI<
+  IncidentEpisode,
+  IncidentEpisodeServiceType
+> {
+  public constructor() {
+    super(IncidentEpisode, IncidentEpisodeService);
+
+    // Generate postmortem from AI
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/generate-postmortem-from-ai/:episodeId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.generatePostmortemFromAI(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  private async generatePostmortemFromAI(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const episodeIdParam: string | undefined = req.params["episodeId"];
+
+    if (!episodeIdParam) {
+      throw new BadDataException("Episode ID is required");
+    }
+
+    let episodeId: ObjectID;
+
+    try {
+      episodeId = new ObjectID(episodeIdParam);
+    } catch {
+      throw new BadDataException("Invalid Episode ID");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    // Verify user has permission to edit the episode
+    const permissions: Array<Permission> | undefined = props
+      .userTenantAccessPermission?.["permissions"] as
+      | Array<Permission>
+      | undefined;
+
+    const hasPermission: boolean = permissions
+      ? permissions.some((p: Permission) => {
+          return (
+            p === Permission.ProjectOwner ||
+            p === Permission.ProjectAdmin ||
+            p === Permission.EditIncidentEpisode
+          );
+        })
+      : false;
+
+    if (!hasPermission && !props.isMasterAdmin) {
+      throw new BadDataException(
+        "You do not have permission to generate postmortem for this episode. You need to have one of these permissions: Project Owner, Project Admin, Edit Incident Episode.",
+      );
+    }
+
+    // Get the template from request body if provided
+    const template: string | undefined = JSONFunctions.getJSONValueInPath(
+      req.body,
+      "template",
+    ) as string | undefined;
+
+    // Always include workspace messages for comprehensive context
+    const includeWorkspaceMessages: boolean = true;
+
+    // Get the episode to verify it exists and get the project ID
+    const episode: IncidentEpisode | null = await this.service.findOneById({
+      id: episodeId,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      props,
+    });
+
+    if (!episode || !episode.projectId) {
+      throw new NotFoundException("Episode not found");
+    }
+
+    // Build episode context
+    const contextData: IncidentEpisodeContextData =
+      await IncidentEpisodeAIContextBuilder.buildEpisodeContext({
+        episodeId,
+        includeWorkspaceMessages,
+        workspaceMessageLimit: 500,
+      });
+
+    // Format context for postmortem generation
+    const aiContext: AIGenerationContext =
+      IncidentEpisodeAIContextBuilder.formatEpisodeContextForPostmortem(
+        contextData,
+        template,
+      );
+
+    // Generate postmortem using AIService (handles billing and logging)
+    const aiLogRequest: AILogRequest = {
+      projectId: episode.projectId,
+      feature: "Incident Episode Postmortem",
+      messages: aiContext.messages,
+      maxTokens: 8192,
+      temperature: 0.7,
+    };
+
+    if (props.userId) {
+      aiLogRequest.userId = props.userId;
+    }
+
+    const response: AILogResponse =
+      await AIService.executeWithLogging(aiLogRequest);
+
+    return Response.sendJsonObjectResponse(req, res, {
+      postmortemNote: response.content,
+    });
+  }
+}

package/Server/API/SlackAPI.ts

@@ -32,6 +32,7 @@ import SlackAuthAction, {
 import SlackIncidentActions from "../Utils/Workspace/Slack/Actions/Incident";
 import SlackAlertActions from "../Utils/Workspace/Slack/Actions/Alert";
 import SlackAlertEpisodeActions from "../Utils/Workspace/Slack/Actions/AlertEpisode";
+import SlackIncidentEpisodeActions from "../Utils/Workspace/Slack/Actions/IncidentEpisode";
 import SlackScheduledMaintenanceActions from "../Utils/Workspace/Slack/Actions/ScheduledMaintenance";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import SlackMonitorActions from "../Utils/Workspace/Slack/Actions/Monitor";
@@ -647,6 +648,19 @@ export default class SlackAPI {
             });
           }
 
+          if (
+            SlackIncidentEpisodeActions.isIncidentEpisodeAction({
+              actionType: action.actionType,
+            })
+          ) {
+            return SlackIncidentEpisodeActions.handleIncidentEpisodeAction({
+              slackRequest: authResult,
+              action: action,
+              req: req,
+              res: res,
+            });
+          }
+
           if (
             SlackMonitorActions.isMonitorAction({
               actionType: action.actionType,
@@ -837,6 +851,15 @@ export default class SlackAPI {
               logger.error(err);
             }
 
+            try {
+              await SlackIncidentEpisodeActions.handleEmojiReaction(
+                reactionData,
+              );
+            } catch (err) {
+              logger.error("Error handling incident episode emoji reaction:");
+              logger.error(err);
+            }
+
             try {
               await SlackScheduledMaintenanceActions.handleEmojiReaction(
                 reactionData,

package/Server/API/UserOnCallLogTimelineAPI.ts

@@ -142,6 +142,11 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                   title: true,
                   description: true,
                 },
+                triggeredByIncidentEpisodeId: true,
+                triggeredByIncidentEpisode: {
+                  title: true,
+                  description: true,
+                },
               },
               props: {
                 isRoot: true,
@@ -158,12 +163,15 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
 
           const notificationType: string = timelineItem.triggeredByIncidentId
             ? "Incident"
-            : timelineItem.triggeredByAlertEpisodeId
-              ? "Alert Episode"
-              : "Alert";
+            : timelineItem.triggeredByIncidentEpisodeId
+              ? "Incident Episode"
+              : timelineItem.triggeredByAlertEpisodeId
+                ? "Alert Episode"
+                : "Alert";
 
           const notificationTitle: string =
             timelineItem.triggeredByIncident?.title ||
+            timelineItem.triggeredByIncidentEpisode?.title ||
             timelineItem.triggeredByAlertEpisode?.title ||
             timelineItem.triggeredByAlert?.title ||
             "";
@@ -222,6 +230,7 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                 triggeredByIncidentId: true,
                 triggeredByAlertId: true,
                 triggeredByAlertEpisodeId: true,
+                triggeredByIncidentEpisodeId: true,
                 triggeredByAlert: {
                   title: true,
                 },
@@ -231,6 +240,9 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                 triggeredByAlertEpisode: {
                   title: true,
                 },
+                triggeredByIncidentEpisode: {
+                  title: true,
+                },
                 acknowledgedAt: true,
                 isAcknowledged: true,
               },
@@ -267,10 +279,18 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                 title: timelineItem.triggeredByIncident?.title || "",
               };
             }
+            if (timelineItem.triggeredByIncidentEpisodeId) {
+              return {
+                type: "Incident Episode",
+                path: "incidents/episodes",
+                id: timelineItem.triggeredByIncidentEpisodeId,
+                title: timelineItem.triggeredByIncidentEpisode?.title || "",
+              };
+            }
             if (timelineItem.triggeredByAlertEpisodeId) {
               return {
                 type: "Alert Episode",
-                path: "alert-episodes",
+                path: "alerts/episodes",
                 id: timelineItem.triggeredByAlertEpisodeId,
                 title: timelineItem.triggeredByAlertEpisode?.title || "",
               };