@oneuptime/common 9.4.9 → 9.4.12

package/Models/DatabaseModels/Alert.ts

@@ -1044,6 +1044,7 @@ export default class Alert extends BaseModel {
     required: false,
     type: TableColumnType.Number,
     computed: true,
+    canReadOnRelationQuery: true,
     title: "Alert Number",
     description: "Alert Number",
     example: 42,

package/Models/DatabaseModels/AlertFeed.ts

@@ -39,6 +39,7 @@ export enum AlertFeedEventType {
   OnCallPolicy = "OnCallPolicy",
   OnCallNotification = "OnCallNotification",
   AddedToEpisode = "AddedToEpisode",
+  RemovedFromEpisode = "RemovedFromEpisode",
 }
 
 @EnableDocumentation()

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/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/BillingConfig.ts

@@ -1,9 +1,12 @@
 const IsBillingEnabled: boolean = process.env["BILLING_ENABLED"] === "true";
 const BillingPublicKey: string = process.env["BILLING_PUBLIC_KEY"] || "";
 const BillingPrivateKey: string = process.env["BILLING_PRIVATE_KEY"] || "";
+const BillingWebhookSecret: string =
+  process.env["BILLING_WEBHOOK_SECRET"] || "";
 
 export default {
   IsBillingEnabled,
   BillingPublicKey,
   BillingPrivateKey,
+  BillingWebhookSecret,
 };

package/Server/EnvironmentConfig.ts

@@ -102,6 +102,7 @@ const parsePositiveNumberFromEnv: (
 export const IsBillingEnabled: boolean = BillingConfig.IsBillingEnabled;
 export const BillingPublicKey: string = BillingConfig.BillingPublicKey;
 export const BillingPrivateKey: string = BillingConfig.BillingPrivateKey;
+export const BillingWebhookSecret: string = BillingConfig.BillingWebhookSecret;
 
 export const DatabaseHost: Hostname = Hostname.fromString(
   process.env["DATABASE_HOST"] || "postgres",

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

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1769599843642 implements MigrationInterface {
+  public name = "MigrationName1769599843642";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "sendInvoicesByEmail" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Project" DROP COLUMN "sendInvoicesByEmail"`,
+    );
+  }
+}

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

@@ -236,6 +236,7 @@ import { MigrationName1769428619414 } from "./1769428619414-MigrationName";
 import { MigrationName1769428821686 } from "./1769428821686-MigrationName";
 import { MigrationName1769469813786 } from "./1769469813786-MigrationName";
 import { RenameNotificationRuleTypes1769517677937 } from "./1769517677937-RenameNotificationRuleTypes";
+import { MigrationName1769599843642 } from "./1769599843642-MigrationName";
 
 export default [
   InitialMigration,
@@ -476,4 +477,5 @@ export default [
   MigrationName1769428821686,
   MigrationName1769469813786,
   RenameNotificationRuleTypes1769517677937,
+  MigrationName1769599843642,
 ];

package/Server/Services/AIBillingService.ts

@@ -7,6 +7,7 @@ import BaseService from "./BaseService";
 import BillingService from "./BillingService";
 import ProjectService from "./ProjectService";
 import BadDataException from "../../Types/Exception/BadDataException";
+import Email from "../../Types/Email";
 import ObjectID from "../../Types/ObjectID";
 import Project from "../../Models/DatabaseModels/Project";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -39,6 +40,8 @@ export class AIBillingService extends BaseService {
         paymentProviderCustomerId: true,
         name: true,
         failedAiBalanceChargeNotificationSentToOwners: true,
+        sendInvoicesByEmail: true,
+        financeAccountingEmail: true,
       },
       props: {
         isRoot: true,
@@ -89,6 +92,13 @@ export class AIBillingService extends BaseService {
         project.paymentProviderCustomerId!,
         "AI Balance Recharge",
         amountInUSD,
+        {
+          sendInvoiceByEmail: project.sendInvoicesByEmail || false,
+          recipientEmail: project.financeAccountingEmail
+            ? new Email(project.financeAccountingEmail)
+            : undefined,
+          projectId: project.id || undefined,
+        },
       );
 
       await ProjectService.updateOneById({

package/Server/Services/AlertEpisodeMemberService.ts

@@ -6,11 +6,14 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import Model from "../../Models/DatabaseModels/AlertEpisodeMember";
 import Alert from "../../Models/DatabaseModels/Alert";
+import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
 import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import AlertFeedService from "./AlertFeedService";
 import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Yellow500, Green500 } from "../../Types/BrandColors";
 import OneUptimeDate from "../../Types/Date";
 import AlertService from "./AlertService";
@@ -124,7 +127,19 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
-    // Create feed item
+    // Get episode details for feed
+    const episode: AlertEpisode | null = await AlertEpisodeService.findOneById({
+      id: createdItem.alertEpisodeId,
+      select: {
+        episodeNumber: true,
+        title: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Create feed item on episode
     await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
       alertEpisodeId: createdItem.alertEpisodeId,
       projectId: createdItem.projectId,
@@ -134,6 +149,16 @@ export class Service extends DatabaseService<Model> {
       userId: createdItem.addedByUserId || undefined,
     });
 
+    // Create feed item on alert
+    await AlertFeedService.createAlertFeedItem({
+      alertId: createdItem.alertId,
+      projectId: createdItem.projectId,
+      alertFeedEventType: AlertFeedEventType.AddedToEpisode,
+      displayColor: Yellow500,
+      feedInfoInMarkdown: `Added to **Episode #${episode?.episodeNumber || "N/A"}**: ${episode?.title || "No title"}`,
+      userId: createdItem.addedByUserId || undefined,
+    });
+
     return createdItem;
   }
 
@@ -197,6 +222,20 @@ export class Service extends DatabaseService<Model> {
 
           // Create feed item for removal
           if (member.alertEpisodeId && member.projectId) {
+            // Get episode details for feed
+            const episode: AlertEpisode | null =
+              await AlertEpisodeService.findOneById({
+                id: member.alertEpisodeId,
+                select: {
+                  episodeNumber: true,
+                  title: true,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+
+            // Create feed item on episode
             await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
               alertEpisodeId: member.alertEpisodeId,
               projectId: member.projectId,
@@ -204,6 +243,15 @@ export class Service extends DatabaseService<Model> {
               displayColor: Green500,
               feedInfoInMarkdown: `**Alert #${alert?.alertNumber || "N/A"}** removed from episode: ${alert?.title || "No title"}`,
             });
+
+            // Create feed item on alert
+            await AlertFeedService.createAlertFeedItem({
+              alertId: member.alertId,
+              projectId: member.projectId,
+              alertFeedEventType: AlertFeedEventType.RemovedFromEpisode,
+              displayColor: Green500,
+              feedInfoInMarkdown: `Removed from **Episode #${episode?.episodeNumber || "N/A"}**: ${episode?.title || "No title"}`,
+            });
           }
         }
 

package/Server/Services/AlertGroupingEngineService.ts

@@ -21,10 +21,8 @@ import MonitorService from "./MonitorService";
 import ServiceMonitorService from "./ServiceMonitorService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
-import AlertFeedService from "./AlertFeedService";
 import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
-import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
-import { Green500, Purple500 } from "../../Types/BrandColors";
+import { Green500 } from "../../Types/BrandColors";
 
 export interface GroupingResult {
   grouped: boolean;
@@ -395,9 +393,6 @@ class AlertGroupingEngineServiceClass {
           existingEpisode.id,
           AlertEpisodeMemberAddedBy.Rule,
           rule.id!,
-          rule,
-          false, // isNewEpisode
-          false, // wasReopened
         );
 
         // Update episode severity if alert has higher severity
@@ -440,9 +435,6 @@ class AlertGroupingEngineServiceClass {
               recentlyResolvedEpisode.id,
               AlertEpisodeMemberAddedBy.Rule,
               rule.id!,
-              rule,
-              false, // isNewEpisode
-              true, // wasReopened
             );
 
             // Update episode severity if alert has higher severity
@@ -478,9 +470,6 @@ class AlertGroupingEngineServiceClass {
           newEpisode.id,
           AlertEpisodeMemberAddedBy.Rule,
           rule.id!,
-          rule,
-          true, // isNewEpisode
-          false, // wasReopened
         );
 
         return { grouped: true, episodeId: newEpisode.id, isNewEpisode: true };
@@ -894,9 +883,6 @@ class AlertGroupingEngineServiceClass {
     episodeId: ObjectID,
     addedBy: AlertEpisodeMemberAddedBy,
     ruleId?: ObjectID,
-    rule?: AlertGroupingRule,
-    isNewEpisode?: boolean,
-    wasReopened?: boolean,
   ): Promise<void> {
     const member: AlertEpisodeMember = new AlertEpisodeMember();
     member.projectId = alert.projectId!;
@@ -916,15 +902,7 @@ class AlertGroupingEngineServiceClass {
         },
       });
 
-      // Create feed entries for alert being added to episode
-      await this.createAlertAddedFeedEntries({
-        alert,
-        episodeId,
-        addedBy,
-        rule,
-        isNewEpisode,
-        wasReopened,
-      });
+      // Feed entries are created by AlertEpisodeMemberService.onCreateSuccess
     } catch (error) {
       // Check if it's a duplicate error (alert already in episode)
       if (
@@ -938,143 +916,6 @@ class AlertGroupingEngineServiceClass {
     }
   }
 
-  @CaptureSpan()
-  private async createAlertAddedFeedEntries(data: {
-    alert: Alert;
-    episodeId: ObjectID;
-    addedBy: AlertEpisodeMemberAddedBy;
-    rule?: AlertGroupingRule | undefined;
-    isNewEpisode?: boolean | undefined;
-    wasReopened?: boolean | undefined;
-    addedByUserId?: ObjectID | undefined;
-  }): Promise<void> {
-    const {
-      alert,
-      episodeId,
-      addedBy,
-      rule,
-      isNewEpisode,
-      wasReopened,
-      addedByUserId,
-    } = data;
-
-    // Fetch episode number for feed entry
-    const episode: AlertEpisode | null = await AlertEpisodeService.findOneById({
-      id: episodeId,
-      select: {
-        episodeNumber: true,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
-
-    const episodeNumber: number = episode?.episodeNumber || 0;
-    const alertNumber: number = alert.alertNumber || 0;
-
-    // Build explanation of why the alert was added
-    let matchReason: string = "";
-    let alertFeedMessage: string = "";
-    let episodeFeedMessage: string = "";
-
-    if (addedBy === AlertEpisodeMemberAddedBy.Rule && rule) {
-      const matchCriteria: Array<string> = [];
-
-      if (rule.monitors && rule.monitors.length > 0) {
-        matchCriteria.push("monitor matches rule criteria");
-      }
-      if (rule.alertSeverities && rule.alertSeverities.length > 0) {
-        matchCriteria.push("severity matches rule criteria");
-      }
-      if (rule.alertLabels && rule.alertLabels.length > 0) {
-        matchCriteria.push("alert labels match rule criteria");
-      }
-      if (rule.monitorLabels && rule.monitorLabels.length > 0) {
-        matchCriteria.push("monitor labels match rule criteria");
-      }
-      if (rule.alertTitlePattern) {
-        matchCriteria.push(
-          `alert title matches pattern \`${rule.alertTitlePattern}\``,
-        );
-      }
-      if (rule.alertDescriptionPattern) {
-        matchCriteria.push(
-          `alert description matches pattern \`${rule.alertDescriptionPattern}\``,
-        );
-      }
-      if (rule.monitorNamePattern) {
-        matchCriteria.push(
-          `monitor name matches pattern \`${rule.monitorNamePattern}\``,
-        );
-      }
-      if (rule.monitorDescriptionPattern) {
-        matchCriteria.push(
-          `monitor description matches pattern \`${rule.monitorDescriptionPattern}\``,
-        );
-      }
-
-      if (matchCriteria.length === 0) {
-        matchCriteria.push("all criteria matched (rule matches all alerts)");
-      }
-
-      matchReason = `**Match Criteria:**\n- ${matchCriteria.join("\n- ")}`;
-
-      if (wasReopened) {
-        alertFeedMessage = `➕ **Added to Episode #${episodeNumber}** (reopened) by rule **${rule.name || "Unnamed Rule"}**`;
-        episodeFeedMessage = `➕ **Alert #${alertNumber}** added (episode reopened) by rule **${rule.name || "Unnamed Rule"}**`;
-      } else if (isNewEpisode) {
-        alertFeedMessage = `➕ **Added to new Episode #${episodeNumber}** by rule **${rule.name || "Unnamed Rule"}**`;
-        episodeFeedMessage = `➕ **Alert #${alertNumber}** added (initial alert) by rule **${rule.name || "Unnamed Rule"}**`;
-      } else {
-        alertFeedMessage = `➕ **Added to Episode #${episodeNumber}** by rule **${rule.name || "Unnamed Rule"}**`;
-        episodeFeedMessage = `➕ **Alert #${alertNumber}** added by rule **${rule.name || "Unnamed Rule"}**`;
-      }
-    } else {
-      // Manual addition
-      alertFeedMessage = `➕ **Manually added to Episode #${episodeNumber}**`;
-      episodeFeedMessage = `➕ **Alert #${alertNumber}** manually added`;
-      matchReason = "**Reason:** Manually added by user";
-    }
-
-    // Create alert feed entry
-    try {
-      await AlertFeedService.createAlertFeedItem({
-        alertId: alert.id!,
-        projectId: alert.projectId!,
-        alertFeedEventType: AlertFeedEventType.AddedToEpisode,
-        displayColor: Purple500,
-        feedInfoInMarkdown: alertFeedMessage,
-        moreInformationInMarkdown: matchReason,
-        userId: addedByUserId,
-      });
-    } catch (feedError) {
-      logger.error(
-        `Error creating alert feed for alert added to episode: ${feedError}`,
-      );
-    }
-
-    // Create episode feed entry
-    try {
-      let moreInfo: string = `**Alert:** #${alertNumber}`;
-      if (alert.title) {
-        moreInfo += ` - ${alert.title}`;
-      }
-      moreInfo += `\n\n${matchReason}`;
-
-      await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
-        alertEpisodeId: episodeId,
-        projectId: alert.projectId!,
-        alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertAdded,
-        displayColor: Purple500,
-        feedInfoInMarkdown: episodeFeedMessage,
-        moreInformationInMarkdown: moreInfo,
-        userId: addedByUserId,
-      });
-    } catch (feedError) {
-      logger.error(`Error creating episode feed for alert added: ${feedError}`);
-    }
-  }
-
   @CaptureSpan()
   public async addAlertToEpisodeManually(
     alert: Alert,
@@ -1098,13 +939,7 @@ class AlertGroupingEngineServiceClass {
       },
     });
 
-    // Create feed entries for manual addition
-    await this.createAlertAddedFeedEntries({
-      alert,
-      episodeId,
-      addedBy: AlertEpisodeMemberAddedBy.Manual,
-      addedByUserId,
-    });
+    // Feed entries are created by AlertEpisodeMemberService.onCreateSuccess
 
     // Update episode severity if needed
     if (alert.alertSeverityId) {