@oneuptime/common 9.4.11 → 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/Project.ts

@@ -1105,6 +1105,35 @@ export default class Project extends TenantModel {
   })
   public enableAutoRechargeAiBalance?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [Permission.ProjectOwner, Permission.ManageProjectBilling],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProject,
+      Permission.UnAuthorizedSsoUser,
+      Permission.ProjectUser,
+    ],
+    update: [Permission.ProjectOwner, Permission.ManageProjectBilling],
+  })
+  @TableColumn({
+    required: true,
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Send Invoices by Email",
+    description:
+      "When enabled, invoices will be automatically sent to the finance/accounting email when they are generated.",
+    defaultValue: false,
+    example: true,
+  })
+  @Column({
+    nullable: false,
+    default: false,
+    type: ColumnType.Boolean,
+  })
+  public sendInvoicesByEmail?: boolean = 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/BillingAPI.ts

@@ -1,4 +1,5 @@
-import { IsBillingEnabled } from "../EnvironmentConfig";
+import { BillingWebhookSecret, IsBillingEnabled } from "../EnvironmentConfig";
+import Stripe from "stripe";
 import UserMiddleware from "../Middleware/UserAuthorization";
 import BillingService from "../Services/BillingService";
 import ProjectService from "../Services/ProjectService";
@@ -16,6 +17,7 @@ import Project from "../../Models/DatabaseModels/Project";
 import CommonAPI from "./CommonAPI";
 import ObjectID from "../../Types/ObjectID";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import logger from "../Utils/Logger";
 
 export default class BillingAPI {
   public router: ExpressRouter;
@@ -23,6 +25,81 @@ export default class BillingAPI {
   public constructor() {
     this.router = Express.getRouter();
 
+    // Stripe webhook endpoint - uses raw body captured by JSON parser for signature verification
+    this.router.post(
+      `/billing/webhook`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          logger.debug(
+            `[Invoice Email] Webhook endpoint hit - /billing/webhook`,
+          );
+
+          if (!IsBillingEnabled) {
+            logger.debug(
+              `[Invoice Email] Billing not enabled, returning early`,
+            );
+            return Response.sendJsonObjectResponse(req, res, {
+              message: "Billing is not enabled",
+            });
+          }
+
+          if (!BillingWebhookSecret) {
+            logger.error(
+              `[Invoice Email] Billing webhook secret is not configured`,
+            );
+            throw new BadDataException(
+              "Billing webhook secret is not configured",
+            );
+          }
+
+          const signature: string = req.headers["stripe-signature"] as string;
+          logger.debug(
+            `[Invoice Email] Stripe signature header present: ${Boolean(signature)}`,
+          );
+
+          if (!signature) {
+            logger.error(`[Invoice Email] Missing Stripe signature header`);
+            throw new BadDataException("Missing Stripe signature header");
+          }
+
+          const rawBody: string | undefined = (req as OneUptimeRequest).rawBody;
+          logger.debug(
+            `[Invoice Email] Raw body present: ${Boolean(rawBody)}, length: ${rawBody?.length || 0}`,
+          );
+
+          if (!rawBody) {
+            logger.error(
+              `[Invoice Email] Missing raw body for webhook verification`,
+            );
+            throw new BadDataException(
+              "Missing raw body for webhook verification",
+            );
+          }
+
+          logger.debug(`[Invoice Email] Verifying webhook signature...`);
+          const event: Stripe.Event = BillingService.verifyWebhookSignature(
+            rawBody,
+            signature,
+          );
+          logger.debug(
+            `[Invoice Email] Webhook signature verified successfully, event type: ${event.type}`,
+          );
+
+          // Handle the event asynchronously
+          logger.debug(`[Invoice Email] Handling webhook event...`);
+          await BillingService.handleWebhookEvent(event);
+          logger.debug(`[Invoice Email] Webhook event handled successfully`);
+
+          return Response.sendJsonObjectResponse(req, res, {
+            received: true,
+          });
+        } catch (err) {
+          logger.error(`[Invoice Email] Stripe webhook error: ${err}`);
+          next(err);
+        }
+      },
+    );
+
     this.router.get(
       `/billing/customer-balance`,
       UserMiddleware.getUserMiddleware,

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,
+    });
+  }
+}