@oneuptime/common 9.4.11 → 9.4.12

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

@@ -1,8 +1,15 @@
-import { BillingPrivateKey, IsBillingEnabled } from "../EnvironmentConfig";
+import {
+  BillingPrivateKey,
+  BillingWebhookSecret,
+  IsBillingEnabled,
+  DashboardClientUrl,
+} from "../EnvironmentConfig";
+import Project from "../../Models/DatabaseModels/Project";
 import ServerMeteredPlan from "../Types/Billing/MeteredPlan/ServerMeteredPlan";
 import Errors from "../Utils/Errors";
 import logger from "../Utils/Logger";
 import BaseService from "./BaseService";
+import MailService from "./MailService";
 import SubscriptionPlan from "../../Types/Billing/SubscriptionPlan";
 import SubscriptionStatus, {
   SubscriptionStatusUtil,
@@ -10,6 +17,7 @@ import SubscriptionStatus, {
 import OneUptimeDate from "../../Types/Date";
 import Dictionary from "../../Types/Dictionary";
 import Email from "../../Types/Email";
+import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import APIException from "../../Types/Exception/ApiException";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ProductType from "../../Types/MeteredPlan/ProductType";
@@ -86,8 +94,16 @@ export class BillingService extends BaseService {
     businessDetails: string,
     countryCode?: string | null,
     financeAccountingEmail?: string | null,
+    sendInvoicesByEmail?: boolean | null,
   ): Promise<void> {
+    logger.debug(
+      `[Invoice Email] updateCustomerBusinessDetails called - customerId: ${id}, sendInvoicesByEmail: ${sendInvoicesByEmail}`,
+    );
+
     if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, skipping updateCustomerBusinessDetails for customer ${id}`,
+      );
       throw new BadDataException(Errors.BillingService.BILLING_NOT_ENABLED);
     }
     /*
@@ -133,6 +149,14 @@ export class BillingService extends BaseService {
       // Remove if cleared
       metadata["finance_accounting_email"] = "";
     }
+    if (sendInvoicesByEmail !== undefined && sendInvoicesByEmail !== null) {
+      metadata["send_invoices_by_email"] = sendInvoicesByEmail
+        ? "true"
+        : "false";
+      logger.debug(
+        `[Invoice Email] Setting send_invoices_by_email metadata to "${metadata["send_invoices_by_email"]}" for customer ${id}`,
+      );
+    }
 
     const updateParams: Stripe.CustomerUpdateParams = {
       metadata,
@@ -169,7 +193,11 @@ export class BillingService extends BaseService {
       } as any;
     }
 
+    logger.debug(
+      `[Invoice Email] Updating Stripe customer ${id} with metadata: ${JSON.stringify(metadata)}`,
+    );
     await this.stripe.customers.update(id, updateParams);
+    logger.debug(`[Invoice Email] Successfully updated Stripe customer ${id}`);
   }
 
   @CaptureSpan()
@@ -924,12 +952,169 @@ export class BillingService extends BaseService {
     return billingInvoices;
   }
 
+  @CaptureSpan()
+  public async sendInvoiceByEmail(
+    invoiceId: string,
+    recipientEmail?: Email,
+    projectId?: ObjectID,
+  ): Promise<void> {
+    logger.debug(
+      `[Invoice Email] sendInvoiceByEmail called for invoice: ${invoiceId}, recipientEmail: ${recipientEmail?.toString()}`,
+    );
+
+    if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, skipping send for invoice: ${invoiceId}`,
+      );
+      throw new BadDataException(Errors.BillingService.BILLING_NOT_ENABLED);
+    }
+
+    try {
+      // Fetch invoice details from Stripe
+      logger.debug(
+        `[Invoice Email] Fetching invoice ${invoiceId} details from Stripe`,
+      );
+      const stripeInvoice: Stripe.Invoice =
+        await this.stripe.invoices.retrieve(invoiceId);
+
+      if (!stripeInvoice) {
+        logger.error(
+          `[Invoice Email] Invoice ${invoiceId} not found in Stripe`,
+        );
+        return;
+      }
+
+      // Determine recipient email
+      let toEmail: Email | undefined = recipientEmail;
+      if (!toEmail && stripeInvoice.customer_email) {
+        toEmail = new Email(stripeInvoice.customer_email);
+      }
+
+      if (!toEmail) {
+        logger.error(
+          `[Invoice Email] No recipient email found for invoice ${invoiceId}`,
+        );
+        return;
+      }
+
+      // Format invoice data for email
+      const invoiceNumber: string = stripeInvoice.number || invoiceId;
+      const invoiceDate: string = stripeInvoice.created
+        ? OneUptimeDate.getDateAsFormattedString(
+            new Date(stripeInvoice.created * 1000),
+          )
+        : OneUptimeDate.getDateAsFormattedString(
+            OneUptimeDate.getCurrentDate(),
+          );
+      const amount: string = `${(stripeInvoice.amount_due / 100).toFixed(2)} ${stripeInvoice.currency?.toUpperCase() || "USD"}`;
+      const invoicePdfUrl: string | undefined =
+        stripeInvoice.invoice_pdf || undefined;
+      const description: string | undefined =
+        stripeInvoice.description || undefined;
+
+      // Build dashboard link
+      let dashboardLink: string | undefined = undefined;
+      if (projectId && DashboardClientUrl) {
+        dashboardLink = `${DashboardClientUrl.toString()}/dashboard/${projectId.toString()}/settings/billing`;
+      }
+
+      logger.debug(
+        `[Invoice Email] Sending invoice email to ${toEmail.toString()} - Invoice #${invoiceNumber}, Amount: ${amount}`,
+      );
+
+      // Send email via OneUptime MailService
+      await MailService.sendMail(
+        {
+          toEmail: toEmail,
+          templateType: EmailTemplateType.Invoice,
+          vars: {
+            invoiceNumber: invoiceNumber,
+            invoiceDate: invoiceDate,
+            amount: amount,
+            description: description || "",
+            invoicePdfUrl: invoicePdfUrl || "",
+            dashboardLink: dashboardLink || "",
+          },
+          subject: `Invoice #${invoiceNumber} from OneUptime`,
+        },
+        {
+          projectId: projectId,
+        },
+      );
+
+      logger.debug(
+        `[Invoice Email] Successfully sent invoice ${invoiceId} email to ${toEmail.toString()}`,
+      );
+    } catch (err) {
+      logger.error(
+        `[Invoice Email] Failed to send invoice ${invoiceId} by email: ${err}`,
+      );
+      // Don't throw - sending email is not critical
+    }
+  }
+
+  @CaptureSpan()
+  public async shouldSendInvoicesByEmail(customerId: string): Promise<boolean> {
+    logger.debug(
+      `[Invoice Email] shouldSendInvoicesByEmail called for customer: ${customerId}`,
+    );
+
+    if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, returning false for customer: ${customerId}`,
+      );
+      return false;
+    }
+
+    try {
+      logger.debug(
+        `[Invoice Email] Retrieving customer ${customerId} from Stripe to check preference`,
+      );
+      const customer: Stripe.Response<
+        Stripe.Customer | Stripe.DeletedCustomer
+      > = await this.stripe.customers.retrieve(customerId);
+
+      if (!customer || customer.deleted) {
+        logger.debug(
+          `[Invoice Email] Customer ${customerId} not found or deleted, returning false`,
+        );
+        return false;
+      }
+
+      const metadata: Stripe.Metadata = (customer as Stripe.Customer).metadata;
+      const sendInvoicesByEmail: boolean =
+        metadata?.["send_invoices_by_email"] === "true";
+      logger.debug(
+        `[Invoice Email] Customer ${customerId} metadata.send_invoices_by_email = "${metadata?.["send_invoices_by_email"]}", result: ${sendInvoicesByEmail}`,
+      );
+      return sendInvoicesByEmail;
+    } catch (err) {
+      logger.error(
+        `[Invoice Email] Failed to check invoice email preference for customer ${customerId}: ${err}`,
+      );
+      return false;
+    }
+  }
+
   @CaptureSpan()
   public async generateInvoiceAndChargeCustomer(
     customerId: string,
     itemText: string,
     amountInUsd: number,
+    options?: {
+      sendInvoiceByEmail?: boolean | undefined;
+      recipientEmail?: Email | undefined;
+      projectId?: ObjectID | undefined;
+    },
   ): Promise<void> {
+    const sendInvoiceByEmail: boolean = options?.sendInvoiceByEmail || false;
+    const recipientEmail: Email | undefined = options?.recipientEmail;
+    const projectId: ObjectID | undefined = options?.projectId;
+
+    logger.debug(
+      `[Invoice Email] generateInvoiceAndChargeCustomer called - customer: ${customerId}, amount: $${amountInUsd}, sendInvoiceByEmail: ${sendInvoiceByEmail}, recipientEmail: ${recipientEmail?.toString()}, projectId: ${projectId?.toString()}`,
+    );
+
     const invoice: Stripe.Invoice = await this.stripe.invoices.create({
       customer: customerId,
       auto_advance: true, // do not automatically charge.
@@ -937,9 +1122,16 @@ export class BillingService extends BaseService {
     });
 
     if (!invoice || !invoice.id) {
+      logger.error(
+        `[Invoice Email] Failed to create invoice for customer ${customerId}`,
+      );
       throw new APIException(Errors.BillingService.INVOICE_NOT_GENERATED);
     }
 
+    logger.debug(
+      `[Invoice Email] Created invoice ${invoice.id} for customer ${customerId}`,
+    );
+
     await this.stripe.invoiceItems.create({
       invoice: invoice.id,
       amount: amountInUsd * 100,
@@ -947,11 +1139,32 @@ export class BillingService extends BaseService {
       customer: customerId,
     });
 
+    logger.debug(
+      `[Invoice Email] Added invoice item to invoice ${invoice.id}: ${itemText}, $${amountInUsd}`,
+    );
+
     await this.stripe.invoices.finalizeInvoice(invoice.id!);
+    logger.debug(`[Invoice Email] Finalized invoice ${invoice.id}`);
 
     try {
       await this.payInvoice(customerId, invoice.id!);
+      logger.debug(`[Invoice Email] Paid invoice ${invoice.id}`);
+
+      // Send invoice by email if requested
+      if (sendInvoiceByEmail) {
+        logger.debug(
+          `[Invoice Email] sendInvoiceByEmail is true, sending invoice ${invoice.id} by email`,
+        );
+        await this.sendInvoiceByEmail(invoice.id!, recipientEmail, projectId);
+      } else {
+        logger.debug(
+          `[Invoice Email] sendInvoiceByEmail is false, skipping email for invoice ${invoice.id}`,
+        );
+      }
     } catch (err) {
+      logger.error(
+        `[Invoice Email] Failed to pay invoice ${invoice.id}, voiding: ${err}`,
+      );
       // mark invoice as failed and do not collect payment.
       await this.voidInvoice(invoice.id!);
       throw err;
@@ -1035,6 +1248,143 @@ export class BillingService extends BaseService {
       "Plan with productType " + productType + " not found",
     );
   }
+
+  @CaptureSpan()
+  public verifyWebhookSignature(
+    payload: string | Buffer,
+    signature: string,
+  ): Stripe.Event {
+    logger.debug(`[Invoice Email] verifyWebhookSignature called`);
+
+    if (!BillingWebhookSecret) {
+      logger.error(`[Invoice Email] Billing webhook secret is not configured`);
+      throw new BadDataException("Billing webhook secret is not configured");
+    }
+
+    logger.debug(
+      `[Invoice Email] Verifying webhook signature with secret (length: ${BillingWebhookSecret.length})`,
+    );
+    const event: Stripe.Event = this.stripe.webhooks.constructEvent(
+      payload,
+      signature,
+      BillingWebhookSecret,
+    );
+    logger.debug(
+      `[Invoice Email] Webhook signature verified, event type: ${event.type}, event id: ${event.id}`,
+    );
+    return event;
+  }
+
+  @CaptureSpan()
+  public async handleWebhookEvent(event: Stripe.Event): Promise<void> {
+    logger.debug(
+      `[Invoice Email] handleWebhookEvent called - event type: ${event.type}, event id: ${event.id}`,
+    );
+
+    if (!this.isBillingEnabled()) {
+      logger.debug(
+        `[Invoice Email] Billing not enabled, ignoring webhook event ${event.id}`,
+      );
+      return;
+    }
+
+    // Handle invoice.finalized event to send invoice by email if customer has opted in
+    if (event.type === "invoice.finalized") {
+      logger.debug(
+        `[Invoice Email] Processing invoice.finalized event ${event.id}`,
+      );
+      const invoice: Stripe.Invoice = event.data.object as Stripe.Invoice;
+
+      logger.debug(
+        `[Invoice Email] Invoice details - id: ${invoice.id}, number: ${invoice.number}, customer: ${invoice.customer}, status: ${invoice.status}`,
+      );
+
+      if (!invoice.customer) {
+        logger.debug(
+          `[Invoice Email] No customer on invoice ${invoice.id}, skipping`,
+        );
+        return;
+      }
+
+      const customerId: string =
+        typeof invoice.customer === "string"
+          ? invoice.customer
+          : invoice.customer.id;
+
+      logger.debug(
+        `[Invoice Email] Extracted customer ID: ${customerId} from invoice ${invoice.id}`,
+      );
+
+      try {
+        logger.debug(
+          `[Invoice Email] Checking if customer ${customerId} has invoice emails enabled`,
+        );
+        const shouldSend: boolean =
+          await this.shouldSendInvoicesByEmail(customerId);
+
+        if (shouldSend && invoice.id) {
+          logger.debug(
+            `[Invoice Email] Customer ${customerId} has invoice emails enabled, looking up project`,
+          );
+
+          // Lazy import to avoid circular dependency
+          const { default: ProjectService } = await import("./ProjectService");
+
+          // Find the project by Stripe customer ID
+          const project: Project | null = await ProjectService.findOneBy({
+            query: {
+              paymentProviderCustomerId: customerId,
+            },
+            select: {
+              _id: true,
+              financeAccountingEmail: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          let recipientEmail: Email | undefined = undefined;
+          let projectId: ObjectID | undefined = undefined;
+
+          if (project) {
+            projectId = project.id || undefined;
+            if (project.financeAccountingEmail) {
+              recipientEmail = new Email(project.financeAccountingEmail);
+            }
+            logger.debug(
+              `[Invoice Email] Found project ${projectId?.toString()}, financeAccountingEmail: ${recipientEmail?.toString()}`,
+            );
+          } else {
+            logger.debug(
+              `[Invoice Email] No project found for customer ${customerId}, will use Stripe customer email`,
+            );
+          }
+
+          logger.debug(
+            `[Invoice Email] Sending invoice ${invoice.id} by email`,
+          );
+          await this.sendInvoiceByEmail(invoice.id, recipientEmail, projectId);
+          logger.debug(
+            `[Invoice Email] Successfully processed invoice.finalized - sent invoice ${invoice.id} by email`,
+          );
+        } else {
+          logger.debug(
+            `[Invoice Email] Customer ${customerId} has invoice emails disabled (shouldSend: ${shouldSend}), skipping email for invoice ${invoice.id}`,
+          );
+        }
+      } catch (err) {
+        logger.error(
+          `[Invoice Email] Failed to send invoice by email for invoice ${invoice.id}: ${err}`,
+        );
+        // Don't throw - webhook should still return success
+      }
+    } else {
+      logger.debug(
+        `[Invoice Email] Ignoring event type ${event.type}, not invoice.finalized`,
+      );
+    }
+  }
 }
 
 export default new BillingService();

package/Server/Services/NotificationService.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";
@@ -35,6 +36,8 @@ export class NotificationService extends BaseService {
         paymentProviderCustomerId: true,
         name: true,
         failedCallAndSMSBalanceChargeNotificationSentToOwners: true,
+        sendInvoicesByEmail: true,
+        financeAccountingEmail: true,
       },
       props: {
         isRoot: true,
@@ -85,6 +88,13 @@ export class NotificationService extends BaseService {
         project.paymentProviderCustomerId!,
         "SMS or Call Balance Recharge",
         amountInUSD,
+        {
+          sendInvoiceByEmail: project.sendInvoicesByEmail || false,
+          recipientEmail: project.financeAccountingEmail
+            ? new Email(project.financeAccountingEmail)
+            : undefined,
+          projectId: project.id || undefined,
+        },
       );
 
       await ProjectService.updateOneById({