@oneuptime/common 9.3.15 → 9.3.17

package/Models/DatabaseModels/Monitor.ts

@@ -20,6 +20,7 @@ import TableMetadata from "../../Types/Database/TableMetadata";
 import TenantColumn from "../../Types/Database/TenantColumn";
 import IconProp from "../../Types/Icon/IconProp";
 import { JSONObject } from "../../Types/JSON";
+import IncomingEmailMonitorRequest from "../../Types/Monitor/IncomingEmailMonitor/IncomingEmailMonitorRequest";
 import IncomingMonitorRequest from "../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import MonitorSteps from "../../Types/Monitor/MonitorSteps";
 import MonitorType from "../../Types/Monitor/MonitorType";
@@ -952,6 +953,114 @@ export default class Monitor extends BaseModel {
   })
   public incomingMonitorRequest?: IncomingMonitorRequest = undefined;
 
+  // Incoming Email Monitor fields
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectMonitor,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    isDefaultValueColumn: false,
+    computed: true,
+    title: "Incoming Email Secret Key",
+    description:
+      "This field is for Incoming Email Monitor only. Secret Key used to generate unique email address.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public incomingEmailSecretKey?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.Date,
+    required: false,
+    isDefaultValueColumn: false,
+    title: "Incoming Email Monitor Last Email Received At",
+    description:
+      "This field is for Incoming Email Monitor only. When was the last email received?",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public incomingEmailMonitorLastEmailReceivedAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    required: false,
+    title: "Incoming Email Monitor Request",
+    description:
+      "This field is for Incoming Email Monitor only. Last email data received.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public incomingEmailMonitorRequest?: IncomingEmailMonitorRequest = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.Date,
+    required: false,
+    isDefaultValueColumn: false,
+    title:
+      "When was the last time we checked the heartbeat for incoming email?",
+    description:
+      "This field is for Incoming Email monitor only. When was the last time we checked the heartbeat?",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public incomingEmailMonitorHeartbeatCheckedAt?: Date = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Server/EnvironmentConfig.ts

@@ -48,6 +48,7 @@ const FRONTEND_ENV_ALLOW_LIST: Array<string> = [
   "GITHUB_APP_NAME",
   "CAPTCHA_ENABLED",
   "CAPTCHA_SITE_KEY",
+  "INBOUND_EMAIL_DOMAIN",
 ];
 
 const FRONTEND_ENV_ALLOW_PREFIXES: Array<string> = [
@@ -527,3 +528,18 @@ export const VapidSubject: string =
 export const EnterpriseLicenseValidationUrl: URL = URL.fromString(
   "https://oneuptime.com/api/enterprise-license/validate",
 );
+
+// Inbound Email Configuration for Incoming Email Monitor
+export enum InboundEmailProviderType {
+  SendGrid = "SendGrid",
+}
+
+export const InboundEmailProvider: InboundEmailProviderType =
+  (process.env["INBOUND_EMAIL_PROVIDER"] as InboundEmailProviderType) ||
+  InboundEmailProviderType.SendGrid;
+
+export const InboundEmailDomain: string | undefined =
+  process.env["INBOUND_EMAIL_DOMAIN"] || undefined;
+
+export const InboundEmailWebhookSecret: string | undefined =
+  process.env["INBOUND_EMAIL_WEBHOOK_SECRET"] || undefined;

package/Server/Infrastructure/Postgres/SchemaMigrations/1768335589018-AddIncomingEmailMonitor.ts

@@ -0,0 +1,53 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddIncomingEmailMonitor1768335589018
+  implements MigrationInterface
+{
+  public name = "AddIncomingEmailMonitor1768335589018";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" ADD "incomingEmailSecretKey" uuid`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_Monitor_incomingEmailSecretKey" ON "Monitor" ("incomingEmailSecretKey")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" ADD "incomingEmailMonitorLastEmailReceivedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_Monitor_incomingEmailMonitorLastEmailReceivedAt" ON "Monitor" ("incomingEmailMonitorLastEmailReceivedAt")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" ADD "incomingEmailMonitorRequest" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" ADD "incomingEmailMonitorHeartbeatCheckedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_Monitor_incomingEmailMonitorHeartbeatCheckedAt" ON "Monitor" ("incomingEmailMonitorHeartbeatCheckedAt")`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "IDX_Monitor_incomingEmailMonitorHeartbeatCheckedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" DROP COLUMN "incomingEmailMonitorHeartbeatCheckedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" DROP COLUMN "incomingEmailMonitorRequest"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "IDX_Monitor_incomingEmailMonitorLastEmailReceivedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" DROP COLUMN "incomingEmailMonitorLastEmailReceivedAt"`,
+    );
+    await queryRunner.query(`DROP INDEX "IDX_Monitor_incomingEmailSecretKey"`);
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" DROP COLUMN "incomingEmailSecretKey"`,
+    );
+  }
+}

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

@@ -219,6 +219,7 @@ import { MigrationName1767979055522 } from "./1767979055522-MigrationName";
 import { MigrationName1767979448478 } from "./1767979448478-MigrationName";
 import { IncreaseClientSecretLength1768216593272 } from "./1768216593272-IncreaseClientSecretLength";
 import { AddOAuthProviderType1768217403078 } from "./1768217403078-AddOAuthProviderType";
+import { AddIncomingEmailMonitor1768335589018 } from "./1768335589018-AddIncomingEmailMonitor";
 
 export default [
   InitialMigration,
@@ -442,4 +443,5 @@ export default [
   MigrationName1767896933148,
   IncreaseClientSecretLength1768216593272,
   AddOAuthProviderType1768217403078,
+  AddIncomingEmailMonitor1768335589018,
 ];

package/Server/Middleware/MultipartFormData.ts

@@ -0,0 +1,17 @@
+import multer from "multer";
+import { RequestHandler } from "express";
+
+/*
+ * Configure multer for handling multipart/form-data
+ * Uses memory storage to store files in memory as Buffer objects
+ */
+const upload: multer.Multer = multer({ storage: multer.memoryStorage() });
+
+/*
+ * Middleware for handling any file uploads (multipart/form-data)
+ * This is useful for webhooks that send data as multipart/form-data (e.g., SendGrid inbound email)
+ */
+const MultipartFormDataMiddleware: RequestHandler =
+  upload.any() as unknown as RequestHandler;
+
+export default MultipartFormDataMiddleware;

package/Server/Services/InboundEmail/InboundEmailProvider.ts

@@ -0,0 +1,64 @@
+import { JSONObject } from "../../../Types/JSON";
+
+export interface ParsedInboundEmail {
+  from: string;
+  to: string;
+  subject: string;
+  body: string;
+  bodyHtml?: string | undefined;
+  headers?: Record<string, string> | undefined;
+  rawEmail?: string | undefined;
+  attachments?:
+    | Array<{
+        filename: string;
+        contentType: string;
+        size: number;
+      }>
+    | undefined;
+}
+
+export interface InboundEmailProviderConfig {
+  webhookSecret?: string | undefined;
+  inboundDomain: string;
+}
+
+export default abstract class InboundEmailProvider {
+  protected config: InboundEmailProviderConfig;
+
+  public constructor(config: InboundEmailProviderConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Parse raw webhook/request data into ParsedInboundEmail
+   */
+  public abstract parseInboundEmail(
+    rawData: JSONObject,
+  ): Promise<ParsedInboundEmail>;
+
+  /**
+   * Validate webhook signature/authentication
+   */
+  public abstract validateWebhook(data: {
+    headers: Record<string, string>;
+    body: JSONObject | string;
+  }): Promise<boolean>;
+
+  /**
+   * Extract monitor secret key from email address
+   * e.g., monitor-abc123@inbound.oneuptime.com -> abc123
+   */
+  public abstract extractSecretKeyFromEmail(email: string): string | null;
+
+  /**
+   * Generate inbound email address for a monitor
+   */
+  public abstract generateMonitorEmailAddress(secretKey: string): string;
+
+  /**
+   * Get the inbound domain
+   */
+  public getInboundDomain(): string {
+    return this.config.inboundDomain;
+  }
+}

package/Server/Services/InboundEmail/InboundEmailProviderFactory.ts

@@ -0,0 +1,80 @@
+import InboundEmailProvider from "./InboundEmailProvider";
+import SendGridInboundProvider from "./Providers/SendGridInboundProvider";
+import {
+  InboundEmailProviderType,
+  InboundEmailProvider as InboundEmailProviderConfig,
+  InboundEmailDomain,
+  InboundEmailWebhookSecret,
+} from "../../EnvironmentConfig";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+export default class InboundEmailProviderFactory {
+  private static instance: InboundEmailProvider | null = null;
+
+  public static getProvider(): InboundEmailProvider {
+    if (this.instance) {
+      return this.instance;
+    }
+
+    if (!InboundEmailDomain) {
+      throw new BadDataException(
+        "Inbound email is not configured. Please set the INBOUND_EMAIL_DOMAIN environment variable.",
+      );
+    }
+
+    switch (InboundEmailProviderConfig) {
+      case InboundEmailProviderType.SendGrid:
+        this.instance = new SendGridInboundProvider({
+          inboundDomain: InboundEmailDomain,
+          webhookSecret: InboundEmailWebhookSecret,
+        });
+        break;
+
+      default:
+        throw new BadDataException(
+          `Unknown inbound email provider: ${InboundEmailProviderConfig}`,
+        );
+    }
+
+    return this.instance;
+  }
+
+  /**
+   * Check if inbound email is configured
+   */
+  public static isConfigured(): boolean {
+    return Boolean(InboundEmailDomain);
+  }
+
+  /**
+   * Generate the email address for a monitor based on its secret key
+   */
+  public static generateMonitorEmailAddress(secretKey: string): string {
+    const provider: InboundEmailProvider = this.getProvider();
+
+    return provider.generateMonitorEmailAddress(secretKey);
+  }
+
+  /**
+   * Extract the secret key from an email address
+   */
+  public static extractSecretKeyFromEmail(email: string): string | null {
+    const provider: InboundEmailProvider = this.getProvider();
+
+    return provider.extractSecretKeyFromEmail(email);
+  }
+
+  /**
+   * Get the inbound domain
+   */
+  public static getInboundDomain(): string | undefined {
+    return InboundEmailDomain;
+  }
+
+  /**
+   * Reset the singleton instance (useful for testing)
+   */
+  public static resetInstance(): void {
+    this.instance = null;
+  }
+}

package/Server/Services/InboundEmail/Providers/SendGridInboundProvider.ts

@@ -0,0 +1,211 @@
+import InboundEmailProvider, {
+  InboundEmailProviderConfig,
+  ParsedInboundEmail,
+} from "../InboundEmailProvider";
+import { JSONObject } from "../../../../Types/JSON";
+
+// SendGrid uses the base config - add SendGrid-specific options here if needed in the future
+export type SendGridInboundConfig = InboundEmailProviderConfig;
+
+/**
+ * SendGrid Inbound Parse provider implementation
+ *
+ * This provider handles email parsing from SendGrid's Inbound Parse webhook.
+ * SendGrid sends emails to the webhook as multipart/form-data with the following fields:
+ * - from: Email sender
+ * - to: Email recipient(s)
+ * - subject: Email subject
+ * - text: Plain text body
+ * - html: HTML body
+ * - headers: Email headers as a string
+ * - envelope: JSON envelope with from/to addresses
+ * - attachments: Number of attachments
+ * - attachment-info: JSON with attachment metadata
+ */
+export default class SendGridInboundProvider extends InboundEmailProvider {
+  public constructor(config: SendGridInboundConfig) {
+    super(config);
+  }
+
+  public async parseInboundEmail(
+    rawData: JSONObject,
+  ): Promise<ParsedInboundEmail> {
+    /*
+     * SendGrid Inbound Parse webhook format
+     * Reference: https://docs.sendgrid.com/for-developers/parsing-email/setting-up-the-inbound-parse-webhook
+     */
+
+    const from: string = this.extractEmailAddress(
+      rawData["from"]?.toString() || "",
+    );
+    const to: string = this.extractEmailAddress(
+      rawData["to"]?.toString() || "",
+    );
+    const subject: string = rawData["subject"]?.toString() || "";
+    const body: string = rawData["text"]?.toString() || "";
+    const bodyHtml: string | undefined = rawData["html"]?.toString();
+    const headers: Record<string, string> | undefined = this.parseHeaders(
+      rawData["headers"]?.toString(),
+    );
+    const attachments:
+      | Array<{ filename: string; contentType: string; size: number }>
+      | undefined = this.parseAttachments(rawData);
+
+    return {
+      from,
+      to,
+      subject,
+      body,
+      bodyHtml,
+      headers,
+      attachments,
+    };
+  }
+
+  public async validateWebhook(data: {
+    headers: Record<string, string>;
+    body: JSONObject | string;
+  }): Promise<boolean> {
+    /*
+     * SendGrid Inbound Parse doesn't provide webhook signature verification by default
+     * We can optionally validate using a custom header if configured
+     */
+    if (this.config.webhookSecret) {
+      const providedSecret: string | undefined =
+        data.headers["x-oneuptime-webhook-secret"];
+
+      return providedSecret === this.config.webhookSecret;
+    }
+
+    /*
+     * If no webhook secret is configured, accept all requests
+     * This is acceptable for SendGrid as the webhook URL itself is a secret
+     */
+    return true;
+  }
+
+  public extractSecretKeyFromEmail(email: string): string | null {
+    /*
+     * Extract from: monitor-{secretKey}@inbound.domain.com
+     * Handle email formats like "name@domain" or "Name <name@domain>"
+     */
+    const emailAddress: string = this.extractEmailAddress(email);
+
+    /*
+     * Create regex pattern that matches the email prefix format
+     * The secret key is a UUID-like string
+     */
+    const pattern: RegExp = new RegExp(
+      `^monitor-([a-zA-Z0-9-]+)@${this.escapeRegex(this.config.inboundDomain)}$`,
+      "i",
+    );
+    const match: RegExpMatchArray | null = emailAddress.match(pattern);
+
+    return match ? match[1]! : null;
+  }
+
+  public generateMonitorEmailAddress(secretKey: string): string {
+    return `monitor-${secretKey}@${this.config.inboundDomain}`;
+  }
+
+  /**
+   * Extract email address from various formats
+   * Examples:
+   * - "user@domain.com" -> "user@domain.com"
+   * - "User Name <user@domain.com>" -> "user@domain.com"
+   * - "<user@domain.com>" -> "user@domain.com"
+   */
+  private extractEmailAddress(email: string): string {
+    const match: RegExpMatchArray | null = email.match(/<([^>]+)>/);
+
+    if (match && match[1]) {
+      return match[1].toLowerCase().trim();
+    }
+
+    return email.toLowerCase().trim();
+  }
+
+  /**
+   * Parse SendGrid headers string into a key-value object
+   * SendGrid sends headers as a string with each header on a new line
+   */
+  private parseHeaders(
+    headersString?: string,
+  ): Record<string, string> | undefined {
+    if (!headersString) {
+      return undefined;
+    }
+
+    const headers: Record<string, string> = {};
+    const lines: string[] = headersString.split("\n");
+
+    for (const line of lines) {
+      const colonIndex: number = line.indexOf(":");
+
+      if (colonIndex > 0) {
+        const key: string = line.substring(0, colonIndex).trim();
+        const value: string = line.substring(colonIndex + 1).trim();
+
+        headers[key] = value;
+      }
+    }
+
+    return Object.keys(headers).length > 0 ? headers : undefined;
+  }
+
+  /**
+   * Parse attachments from SendGrid webhook data
+   */
+  private parseAttachments(
+    rawData: JSONObject,
+  ):
+    | Array<{ filename: string; contentType: string; size: number }>
+    | undefined {
+    const attachmentCount: number = parseInt(
+      rawData["attachments"]?.toString() || "0",
+      10,
+    );
+
+    if (attachmentCount === 0) {
+      return undefined;
+    }
+
+    // Parse attachment-info JSON if available
+    const attachmentInfoStr: string | undefined =
+      rawData["attachment-info"]?.toString();
+
+    if (!attachmentInfoStr) {
+      return undefined;
+    }
+
+    try {
+      const attachmentInfo: JSONObject = JSON.parse(attachmentInfoStr);
+      const attachments: Array<{
+        filename: string;
+        contentType: string;
+        size: number;
+      }> = [];
+
+      for (const key of Object.keys(attachmentInfo)) {
+        const info: JSONObject = attachmentInfo[key] as JSONObject;
+
+        attachments.push({
+          filename: info["filename"]?.toString() || "unknown",
+          contentType: info["type"]?.toString() || "application/octet-stream",
+          size: parseInt(info["content-length"]?.toString() || "0", 10),
+        });
+      }
+
+      return attachments.length > 0 ? attachments : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Escape special regex characters in a string
+   */
+  private escapeRegex(str: string): string {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+}

package/Server/Services/MonitorService.ts

@@ -482,6 +482,10 @@ export class Service extends DatabaseService<Model> {
       createBy.data.incomingRequestSecretKey = ObjectID.generate();
     }
 
+    if (createBy.data.monitorType === MonitorType.IncomingEmail) {
+      createBy.data.incomingEmailSecretKey = ObjectID.generate();
+    }
+
     if (!createBy.props.tenantId) {
       throw new BadDataException("ProjectId required to create monitor.");
     }