@oneuptime/common 13.0.0 → 13.0.3

package/Tests/Server/Utils/EmailRollup/EmailRollupMetadataIntegration.test.ts

@@ -0,0 +1,246 @@
+import UserNotificationEmailRollupItem from "../../../../Models/DatabaseModels/UserNotificationEmailRollupItem";
+import UserNotificationEmailRollupItemService from "../../../../Server/Services/UserNotificationEmailRollupItemService";
+import UserNotificationEmailRollupSettingService from "../../../../Server/Services/UserNotificationEmailRollupSettingService";
+import CreateBy from "../../../../Server/Types/Database/CreateBy";
+import { BURST_THRESHOLD } from "../../../../Server/Utils/EmailRollup/EmailRollupConstants";
+import EmailRollupFlushRunner from "../../../../Server/Utils/EmailRollup/EmailRollupFlushRunner";
+import EmailRollupWriter from "../../../../Server/Utils/EmailRollup/EmailRollupWriter";
+import OneUptimeDate from "../../../../Types/Date";
+import Dictionary from "../../../../Types/Dictionary";
+import Email from "../../../../Types/Email";
+import { JSONObject } from "../../../../Types/JSON";
+import NotificationSettingEventType from "../../../../Types/NotificationSetting/NotificationSettingEventType";
+import ObjectID from "../../../../Types/ObjectID";
+import PositiveNumber from "../../../../Types/PositiveNumber";
+import {
+  FakeItemRow,
+  RollupHarness,
+  emptyRollupHarness,
+  installRollupHarness,
+  pendingItems,
+  seedItem,
+  seedProject,
+  seedVerifiedEmail,
+} from "./EmailRollupTestHarness";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const USER_ID: ObjectID = new ObjectID("22222222-2222-4222-8222-222222222222");
+const TO_EMAIL: Email = new Email("owner@example.com");
+const NOW: Date = new Date("2026-09-09T07:15:00.000Z");
+
+interface NotificationFamily {
+  name: string;
+  eventType: NotificationSettingEventType;
+  severityVar: string;
+  linkVar: string;
+}
+
+const FAMILIES: Array<NotificationFamily> = [
+  {
+    name: "alert",
+    eventType:
+      NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION,
+    severityVar: "alertSeverity",
+    linkVar: "alertViewLink",
+  },
+  {
+    name: "incident",
+    eventType:
+      NotificationSettingEventType.SEND_INCIDENT_STATE_CHANGED_OWNER_NOTIFICATION,
+    severityVar: "incidentSeverity",
+    linkVar: "incidentViewLink",
+  },
+  {
+    name: "alert episode",
+    eventType:
+      NotificationSettingEventType.SEND_ALERT_EPISODE_STATE_CHANGED_OWNER_NOTIFICATION,
+    severityVar: "episodeSeverity",
+    linkVar: "episodeViewLink",
+  },
+  {
+    name: "incident episode",
+    eventType:
+      NotificationSettingEventType.SEND_INCIDENT_EPISODE_STATE_CHANGED_OWNER_NOTIFICATION,
+    severityVar: "episodeSeverity",
+    linkVar: "episodeViewLink",
+  },
+];
+
+/*
+ * Real writer, flush runner and renderer with a projected in-memory database.
+ * The persisted copy is the only bridge between enqueue and flush, so omitting
+ * metadata from either the insert or the flush select loses these labels.
+ */
+describe("grouped email severity and state from enqueue through delivery", () => {
+  let harness: RollupHarness;
+  let queuedAt: Date;
+
+  beforeEach(() => {
+    harness = emptyRollupHarness();
+    installRollupHarness(harness);
+    seedProject(harness, { projectId: PROJECT_ID, name: "Acme" });
+    seedVerifiedEmail(harness, {
+      projectId: PROJECT_ID,
+      userId: USER_ID,
+      email: TO_EMAIL,
+    });
+    queuedAt = OneUptimeDate.addRemoveMinutes(NOW, -12);
+
+    jest.spyOn(OneUptimeDate, "getCurrentDate").mockImplementation((): Date => {
+      return queuedAt;
+    });
+    jest
+      .spyOn(UserNotificationEmailRollupItemService, "countBy")
+      .mockResolvedValue(new PositiveNumber(BURST_THRESHOLD));
+    jest
+      .spyOn(
+        UserNotificationEmailRollupSettingService,
+        "isRollupEnabledForUser",
+      )
+      .mockResolvedValue(true);
+    jest
+      .spyOn(UserNotificationEmailRollupItemService, "create")
+      .mockImplementation(
+        async (
+          args: CreateBy<UserNotificationEmailRollupItem>,
+        ): Promise<UserNotificationEmailRollupItem> => {
+          const item: UserNotificationEmailRollupItem = args.data;
+          seedItem(harness, {
+            projectId: item.projectId!,
+            userId: item.userId!,
+            toEmail: item.toEmail!,
+            eventType: item.eventType,
+            rollupCategory: item.rollupCategory,
+            subject: item.subject,
+            viewLink: item.viewLink,
+            severity: item.severity,
+            currentState: item.currentState,
+            sentAt: item.sentAt,
+            createdAt: queuedAt,
+          });
+          return item;
+        },
+      );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  async function enqueue(data: {
+    family: NotificationFamily;
+    subject: string;
+    severity: string;
+    state: string;
+  }): Promise<void> {
+    const vars: Dictionary<string | JSONObject> = {
+      [data.family.severityVar]: data.severity,
+      currentState: data.state,
+      [data.family.linkVar]: "https://oneuptime.com/dashboard/resource/1",
+    };
+
+    await EmailRollupWriter.sendOrRollup({
+      projectId: PROJECT_ID,
+      userId: USER_ID,
+      toEmail: TO_EMAIL,
+      eventType: data.family.eventType,
+      emailEnvelope: { subject: data.subject, vars: vars },
+      mailOptions: { projectId: PROJECT_ID, userId: USER_ID },
+    });
+
+    // Later changes to producer data must not alter the persisted snapshot.
+    vars[data.family.severityVar] = "Changed after enqueue";
+    vars["currentState"] = "Changed after enqueue";
+  }
+
+  test.each(FAMILIES)(
+    "delivers the latest $name severity and state after folding queued updates",
+    async (family: NotificationFamily) => {
+      await enqueue({
+        family: family,
+        subject: "Acknowledged notification",
+        severity: "Critical",
+        state: "Acknowledged",
+      });
+      queuedAt = OneUptimeDate.addRemoveMinutes(NOW, -10);
+      await enqueue({
+        family: family,
+        subject: "Resolved notification",
+        severity: "High",
+        state: "Resolved",
+      });
+
+      expect(harness.sent).toHaveLength(0);
+      expect(pendingItems(harness)).toHaveLength(2);
+      expect(
+        harness.items.map((item: FakeItemRow): Array<string | null> => {
+          return [item.severity, item.currentState];
+        }),
+      ).toEqual([
+        ["Critical", "Acknowledged"],
+        ["High", "Resolved"],
+      ]);
+
+      await EmailRollupFlushRunner.runSweep({ now: NOW });
+
+      expect(harness.sent).toHaveLength(1);
+      expect(pendingItems(harness)).toHaveLength(0);
+      const rows: Array<JSONObject> = harness.sent[0]!.vars[
+        "rows"
+      ] as unknown as Array<JSONObject>;
+      expect(rows).toHaveLength(1);
+      expect(rows[0]).toMatchObject({
+        title: "Resolved notification",
+        severity: "High",
+        currentState: "Resolved",
+        hasSeverity: "true",
+        hasCurrentState: "true",
+        hasDetails: "true",
+      });
+      expect(rows[0]!["metaLabel"]).toContain("2 updates");
+    },
+  );
+
+  test("delivers older pending items with null metadata alongside enriched notifications", async () => {
+    seedItem(harness, {
+      projectId: PROJECT_ID,
+      userId: USER_ID,
+      toEmail: TO_EMAIL,
+      subject: "Previously queued incident",
+      createdAt: OneUptimeDate.addRemoveMinutes(NOW, -15),
+    });
+    await enqueue({
+      family: FAMILIES[0]!,
+      subject: "New alert",
+      severity: "Critical",
+      state: "Investigating",
+    });
+
+    await EmailRollupFlushRunner.runSweep({ now: NOW });
+
+    expect(harness.sent).toHaveLength(1);
+    const rows: Array<JSONObject> = harness.sent[0]!.vars[
+      "rows"
+    ] as unknown as Array<JSONObject>;
+    expect(rows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          title: "Previously queued incident",
+          severity: "",
+          currentState: "",
+          hasDetails: "false",
+        }),
+        expect.objectContaining({
+          title: "New alert",
+          severity: "Critical",
+          currentState: "Investigating",
+          hasDetails: "true",
+        }),
+      ]),
+    );
+    expect(harness.errors).toEqual([]);
+  });
+});

package/Tests/Server/Utils/EmailRollup/EmailRollupRenderer.test.ts

@@ -63,6 +63,8 @@ interface ItemInput {
   eventType?: NotificationSettingEventType | undefined;
   viewLink?: string | undefined;
   rollupCategory?: RollupCategory | undefined;
+  severity?: string | undefined;
+  currentState?: string | undefined;
 }
 
 type MakeItemFunction = (input: ItemInput) => UserNotificationEmailRollupItem;
@@ -89,6 +91,14 @@ const makeItem: MakeItemFunction = (
     item.viewLink = input.viewLink;
   }
 
+  if (input.severity !== undefined) {
+    item.severity = input.severity;
+  }
+
+  if (input.currentState !== undefined) {
+    item.currentState = input.currentState;
+  }
+
   return item;
 };
 
@@ -344,6 +354,289 @@ describe("foldItems", () => {
   });
 });
 
+describe("foldItems notification details", () => {
+  const link: string =
+    "https://oneuptime.example.com/dashboard/p1/incidents/i1";
+
+  test.each([RollupCategory.Incidents, RollupCategory.Alerts])(
+    "%s details follow the newest notification even when input is unsorted",
+    (category: RollupCategory) => {
+      const rows: Array<RollupRow> = foldItems([
+        makeItem({
+          createdAt: at(120),
+          subject: "Checkout recovered",
+          viewLink: link,
+          rollupCategory: category,
+          severity: "SEV 2 — Degraded",
+          currentState: "Resolved",
+        }),
+        makeItem({
+          createdAt: at(0),
+          subject: "Checkout is down",
+          viewLink: link,
+          rollupCategory: category,
+          severity: "SEV 1 — Critical",
+          currentState: "Created",
+        }),
+        makeItem({
+          createdAt: at(60),
+          subject: "Checkout acknowledged",
+          viewLink: link,
+          rollupCategory: category,
+          severity: "SEV 1 — Critical",
+          currentState: "Investigating",
+        }),
+      ]);
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0]).toMatchObject({
+        title: "Checkout recovered",
+        severity: "SEV 2 — Degraded",
+        currentState: "Resolved",
+        category: category,
+        itemCount: 3,
+        firstAtMs: at(0).getTime(),
+        latestAtMs: at(120).getTime(),
+      });
+    },
+  );
+
+  test("the last notification wins both title and details when timestamps tie", () => {
+    const rows: Array<RollupRow> = foldItems([
+      makeItem({
+        createdAt: at(60),
+        subject: "Investigating",
+        viewLink: link,
+        severity: "Critical",
+        currentState: "Acknowledged",
+      }),
+      makeItem({
+        createdAt: at(60),
+        subject: "Recovered",
+        viewLink: link,
+        severity: "Warning",
+        currentState: "Resolved",
+      }),
+    ]);
+
+    expect(rows[0]).toMatchObject({
+      title: "Recovered",
+      severity: "Warning",
+      currentState: "Resolved",
+      itemCount: 2,
+    });
+  });
+
+  test.each([60, 120])(
+    "missing details on the latest notification clear older values at second %i",
+    (latestOffset: number) => {
+      const rows: Array<RollupRow> = foldItems([
+        makeItem({
+          createdAt: at(60),
+          subject: "Original notification",
+          viewLink: link,
+          severity: "Critical",
+          currentState: "Created",
+        }),
+        makeItem({
+          createdAt: at(latestOffset),
+          subject: "Latest notification without details",
+          viewLink: link,
+        }),
+      ]);
+
+      expect(rows[0]).toMatchObject({
+        title: "Latest notification without details",
+        severity: "",
+        currentState: "",
+      });
+    },
+  );
+
+  test("a latest state without severity does not inherit the previous severity", () => {
+    const rows: Array<RollupRow> = foldItems([
+      makeItem({
+        createdAt: at(0),
+        subject: "Original",
+        viewLink: link,
+        severity: "Critical",
+        currentState: "Created",
+      }),
+      makeItem({
+        createdAt: at(60),
+        subject: "Latest",
+        viewLink: link,
+        currentState: "Resolved",
+      }),
+    ]);
+
+    expect(rows[0]).toMatchObject({ severity: "", currentState: "Resolved" });
+  });
+
+  test("a latest severity without state does not inherit the previous state", () => {
+    const rows: Array<RollupRow> = foldItems([
+      makeItem({
+        createdAt: at(0),
+        subject: "Original",
+        viewLink: link,
+        severity: "Critical",
+        currentState: "Created",
+      }),
+      makeItem({
+        createdAt: at(60),
+        subject: "Latest",
+        viewLink: link,
+        severity: "Warning",
+      }),
+    ]);
+
+    expect(rows[0]).toMatchObject({ severity: "Warning", currentState: "" });
+  });
+
+  test("details remain attached to their own resource when rows are sorted and sectioned", () => {
+    const email: RollupEmail = build([
+      makeItem({
+        createdAt: at(0),
+        subject: "Database incident",
+        viewLink: link,
+        severity: "Critical",
+        currentState: "Investigating",
+      }),
+      makeItem({
+        createdAt: at(120),
+        subject: "Disk alert",
+        viewLink: "https://oneuptime.example.com/dashboard/p1/alerts/a1",
+        rollupCategory: RollupCategory.Alerts,
+        severity: "Warning",
+        currentState: "Resolved",
+      }),
+      makeItem({
+        createdAt: at(60),
+        subject: "API incident",
+        viewLink: "https://oneuptime.example.com/dashboard/p1/incidents/i2",
+        severity: "Major",
+        currentState: "Acknowledged",
+      }),
+    ]);
+
+    expect(varRows(email)).toMatchObject([
+      {
+        title: "API incident",
+        severity: "Major",
+        currentState: "Acknowledged",
+      },
+      {
+        title: "Database incident",
+        severity: "Critical",
+        currentState: "Investigating",
+      },
+      { title: "Disk alert", severity: "Warning", currentState: "Resolved" },
+    ]);
+  });
+});
+
+describe("buildRollupEmail notification details", () => {
+  test.each([RollupCategory.Incidents, RollupCategory.Alerts])(
+    "%s rows expose the exact custom labels as raw text for Handlebars escaping",
+    (category: RollupCategory) => {
+      const severity: string = 'P0 <urgent> & "customer-facing"';
+      const currentState: string = "L'équipe enquête — {{customState}}";
+      const email: RollupEmail = build([
+        makeItem({
+          createdAt: at(0),
+          subject: "Service update",
+          rollupCategory: category,
+          severity: severity,
+          currentState: currentState,
+        }),
+      ]);
+
+      expect(varRows(email)[0]).toMatchObject({
+        severity: severity,
+        currentState: currentState,
+        hasSeverity: "true",
+        hasCurrentState: "true",
+        hasDetails: "true",
+      });
+    },
+  );
+
+  test("a row with only a severity shows only the available detail", () => {
+    const email: RollupEmail = build([
+      makeItem({ createdAt: at(0), subject: "Alert", severity: "Critical" }),
+    ]);
+
+    expect(varRows(email)[0]).toMatchObject({
+      severity: "Critical",
+      currentState: "",
+      hasSeverity: "true",
+      hasCurrentState: "false",
+      hasDetails: "true",
+    });
+  });
+
+  test("a row with only a state shows only the available detail", () => {
+    const email: RollupEmail = build([
+      makeItem({
+        createdAt: at(0),
+        subject: "Alert",
+        currentState: "Resolved",
+      }),
+    ]);
+
+    expect(varRows(email)[0]).toMatchObject({
+      severity: "",
+      currentState: "Resolved",
+      hasSeverity: "false",
+      hasCurrentState: "true",
+      hasDetails: "true",
+    });
+  });
+
+  test.each(ROLLUP_CATEGORY_ORDER)(
+    "legacy %s rows without saved details omit the details block",
+    (category: RollupCategory) => {
+      const email: RollupEmail = build([
+        makeItem({
+          createdAt: at(0),
+          subject: "Legacy notification",
+          rollupCategory: category,
+        }),
+      ]);
+
+      expect(varRows(email)[0]).toMatchObject({
+        title: "Legacy notification",
+        severity: "",
+        currentState: "",
+        hasSeverity: "false",
+        hasCurrentState: "false",
+        hasDetails: "false",
+      });
+    },
+  );
+
+  test.each([null, "", "   \t\n"])(
+    "null or blank saved details (%j) do not produce empty metadata labels",
+    (detail: string | null) => {
+      const item: UserNotificationEmailRollupItem = makeItem({
+        createdAt: at(0),
+        subject: "Legacy notification",
+      });
+
+      // Nullable database columns can hydrate as null on older queued rows.
+      Object.assign(item, { severity: detail, currentState: detail });
+
+      expect(varRows(build([item]))[0]).toMatchObject({
+        severity: "",
+        currentState: "",
+        hasSeverity: "false",
+        hasCurrentState: "false",
+        hasDetails: "false",
+      });
+    },
+  );
+});
+
 describe("buildRollupEmail category counts", () => {
   test("counts every item, not the rendered slice: 300 items, 100 rows, 300 counted", () => {
     const items: Array<UserNotificationEmailRollupItem> = [];
@@ -792,7 +1085,7 @@ describe("buildRollupEmail singular and plural copy", () => {
 });
 
 describe("buildRollupEmail variable set", () => {
-  test("every variable the template needs is present, and rows carry exactly eight fields", () => {
+  test("every variable the template needs is present, including optional notification details", () => {
     const email: RollupEmail = build([
       makeItem({
         createdAt: at(0),
@@ -825,13 +1118,18 @@ describe("buildRollupEmail variable set", () => {
      */
     expect(Object.keys(varRows(email)[0]!).sort()).toEqual(
       [
+        "currentState",
+        "hasCurrentState",
+        "hasDetails",
         "hasLink",
+        "hasSeverity",
         "isSectionStart",
         "link",
         "metaLabel",
         "rowBackground",
         "sectionCount",
         "sectionLabel",
+        "severity",
         "title",
       ].sort(),
     );

package/Tests/Server/Utils/EmailRollup/EmailRollupTestHarness.ts

@@ -69,6 +69,8 @@ export interface FakeItemRow {
   eventType: NotificationSettingEventType;
   rollupCategory: RollupCategory;
   subject: string;
+  severity: string | null;
+  currentState: string | null;
   viewLink: string | null;
   sentAt: Date | null;
   rollupBatchId: ObjectID | null;
@@ -345,6 +347,8 @@ export function seedItem(
     toEmail: Email;
     createdAt: Date;
     subject?: string | undefined;
+    severity?: string | null | undefined;
+    currentState?: string | null | undefined;
     eventType?: NotificationSettingEventType | undefined;
     rollupCategory?: RollupCategory | undefined;
     viewLink?: string | null | undefined;
@@ -364,6 +368,8 @@ export function seedItem(
       NotificationSettingEventType.SEND_INCIDENT_CREATED_OWNER_NOTIFICATION,
     rollupCategory: data.rollupCategory ?? RollupCategory.Incidents,
     subject: data.subject ?? `Incident created ${id.toString()}`,
+    severity: data.severity ?? null,
+    currentState: data.currentState ?? null,
     viewLink: data.viewLink ?? null,
     sentAt: data.sentAt ?? null,
     rollupBatchId: data.rollupBatchId ?? null,