@oneuptime/common 11.6.1 → 11.6.2

package/Tests/Server/Utils/WhatsAppTemplateUtil.test.ts

@@ -0,0 +1,199 @@
+import {
+  appendRecipientToWhatsAppMessage,
+  createWhatsAppMessageFromTemplate,
+  getWhatsAppTemplateIdForEventType,
+  getWhatsAppTemplateStringForEventType,
+} from "../../../Server/Utils/WhatsAppTemplateUtil";
+import NotificationSettingEventType from "../../../Types/NotificationSetting/NotificationSettingEventType";
+import Phone from "../../../Types/Phone";
+import WhatsAppMessage, {
+  WhatsAppMessagePayload,
+} from "../../../Types/WhatsApp/WhatsAppMessage";
+import {
+  WhatsAppTemplateIds,
+  WhatsAppTemplateMessages,
+} from "../../../Types/WhatsApp/WhatsAppTemplates";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * WhatsAppTemplateUtil turns an event type + variables into a rendered
+ * WhatsApp template payload. The two behaviors most worth guarding:
+ *
+ *   1. Variable substitution is strict — a missing {{var}} throws rather than
+ *      silently shipping a broken "{{alert_link}}" literal to a customer.
+ *   2. The dashboard-link injection defaults the template's link variable to
+ *      the action link (or the hard-coded dashboard URL) when the caller does
+ *      not supply one, so link-bearing templates never render an empty URL.
+ */
+
+describe("getWhatsAppTemplateIdForEventType", () => {
+  test("maps a known event type to its template id", () => {
+    expect(
+      getWhatsAppTemplateIdForEventType(
+        NotificationSettingEventType.SEND_INCIDENT_CREATED_OWNER_NOTIFICATION,
+      ),
+    ).toBe(WhatsAppTemplateIds.IncidentCreatedOwnerNotification);
+  });
+
+  test("throws for an event type that has no WhatsApp template", () => {
+    expect(() => {
+      return getWhatsAppTemplateIdForEventType(
+        "not-a-real-event" as unknown as NotificationSettingEventType,
+      );
+    }).toThrow("WhatsApp template is not defined for event type");
+  });
+});
+
+describe("getWhatsAppTemplateStringForEventType", () => {
+  test("returns the template content string for a known event type", () => {
+    const content: string = getWhatsAppTemplateStringForEventType(
+      NotificationSettingEventType.SEND_MONITOR_CREATED_OWNER_NOTIFICATION,
+    );
+
+    expect(content).toBe(
+      WhatsAppTemplateMessages[
+        WhatsAppTemplateIds.MonitorCreatedOwnerNotification
+      ],
+    );
+    expect(content).toContain("{{monitor_name}}");
+  });
+
+  test("throws for an unknown event type", () => {
+    expect(() => {
+      return getWhatsAppTemplateStringForEventType(
+        "nope" as unknown as NotificationSettingEventType,
+      );
+    }).toThrow("WhatsApp template is not defined for event type");
+  });
+});
+
+describe("createWhatsAppMessageFromTemplate", () => {
+  test("renders variables from a supplied template string", () => {
+    const payload: WhatsAppMessagePayload = createWhatsAppMessageFromTemplate({
+      templateKey: WhatsAppTemplateIds.VerificationCode,
+      templateString: "{{1}} is your code.",
+      templateVariables: { "1": "123456" },
+    });
+
+    expect(payload.body).toBe("123456 is your code.");
+    expect(payload.templateKey).toBe(WhatsAppTemplateIds.VerificationCode);
+    expect(payload.templateLanguageCode).toBe("en");
+  });
+
+  test("resolves the template id from an event type", () => {
+    const payload: WhatsAppMessagePayload = createWhatsAppMessageFromTemplate({
+      eventType:
+        NotificationSettingEventType.SEND_MONITOR_CREATED_OWNER_NOTIFICATION,
+      templateVariables: {
+        monitor_name: "API Monitor",
+        monitor_link: "https://oneuptime.com/monitor/1",
+      },
+    });
+
+    expect(payload.templateKey).toBe(
+      WhatsAppTemplateIds.MonitorCreatedOwnerNotification,
+    );
+    expect(payload.body).toContain("API Monitor");
+    expect(payload.body).toContain("https://oneuptime.com/monitor/1");
+  });
+
+  test("defaults the dashboard link variable to the provided action link", () => {
+    const payload: WhatsAppMessagePayload = createWhatsAppMessageFromTemplate({
+      templateKey: WhatsAppTemplateIds.MonitorCreatedOwnerNotification,
+      actionLink: "https://oneuptime.com/dashboard/monitor/42",
+      templateVariables: {
+        monitor_name: "DB Monitor",
+        // monitor_link intentionally omitted — should be injected
+      },
+    });
+
+    expect(payload.templateVariables?.["monitor_link"]).toBe(
+      "https://oneuptime.com/dashboard/monitor/42",
+    );
+    expect(payload.body).toContain(
+      "https://oneuptime.com/dashboard/monitor/42",
+    );
+  });
+
+  test("falls back to the default dashboard URL when no action link given", () => {
+    const payload: WhatsAppMessagePayload = createWhatsAppMessageFromTemplate({
+      templateKey: WhatsAppTemplateIds.MonitorCreatedOwnerNotification,
+      templateVariables: {
+        monitor_name: "DB Monitor",
+      },
+    });
+
+    expect(payload.templateVariables?.["monitor_link"]).toBe(
+      "https://oneuptime.com/dashboard",
+    );
+  });
+
+  test("a caller-supplied link variable wins over the action link", () => {
+    const payload: WhatsAppMessagePayload = createWhatsAppMessageFromTemplate({
+      templateKey: WhatsAppTemplateIds.MonitorCreatedOwnerNotification,
+      actionLink: "https://oneuptime.com/dashboard/fallback",
+      templateVariables: {
+        monitor_name: "DB Monitor",
+        monitor_link: "https://oneuptime.com/explicit",
+      },
+    });
+
+    expect(payload.templateVariables?.["monitor_link"]).toBe(
+      "https://oneuptime.com/explicit",
+    );
+  });
+
+  test("trims whitespace around the resolved link", () => {
+    const payload: WhatsAppMessagePayload = createWhatsAppMessageFromTemplate({
+      templateKey: WhatsAppTemplateIds.MonitorCreatedOwnerNotification,
+      actionLink: "   https://oneuptime.com/trimmed   ",
+      templateVariables: {
+        monitor_name: "DB Monitor",
+      },
+    });
+
+    expect(payload.templateVariables?.["monitor_link"]).toBe(
+      "https://oneuptime.com/trimmed",
+    );
+  });
+
+  test("throws when a required template variable is missing", () => {
+    expect(() => {
+      return createWhatsAppMessageFromTemplate({
+        templateKey: WhatsAppTemplateIds.VerificationCode,
+        templateString: "{{1}} is your code for {{app_name}}.",
+        templateVariables: { "1": "123456" }, // app_name missing
+      });
+    }).toThrow('Missing variable "app_name"');
+  });
+
+  test("throws when neither template key nor event type is provided", () => {
+    expect(() => {
+      return createWhatsAppMessageFromTemplate({
+        templateVariables: {},
+      });
+    }).toThrow("WhatsApp template key or event type must be provided");
+  });
+});
+
+describe("appendRecipientToWhatsAppMessage", () => {
+  test("attaches the recipient phone without mutating other fields", () => {
+    const payload: WhatsAppMessagePayload = {
+      body: "hello",
+      templateKey: WhatsAppTemplateIds.VerificationCode,
+      templateVariables: { "1": "1" },
+      templateLanguageCode: "en",
+    };
+
+    const to: Phone = new Phone("+15551234567");
+    const message: WhatsAppMessage = appendRecipientToWhatsAppMessage(
+      payload,
+      to,
+    );
+
+    expect(message.to).toBe(to);
+    expect(message.body).toBe("hello");
+    expect(message.templateKey).toBe(WhatsAppTemplateIds.VerificationCode);
+    expect(message.templateLanguageCode).toBe("en");
+  });
+});

package/Tests/Types/Database/CompareOperatorWireSerialization.test.ts

@@ -1,4 +1,6 @@
 import CompareBase, { CompareType } from "../../../Types/Database/CompareBase";
+import EqualTo from "../../../Types/BaseDatabase/EqualTo";
+import EqualToOrNull from "../../../Types/BaseDatabase/EqualToOrNull";
 import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
@@ -6,6 +8,7 @@ import InBetween from "../../../Types/BaseDatabase/InBetween";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
+import NotEqual from "../../../Types/BaseDatabase/NotEqual";
 import JSONFunctions from "../../../Types/JSONFunctions";
 import { JSONObject } from "../../../Types/JSON";
 import { describe, expect, it } from "@jest/globals";
@@ -87,6 +90,36 @@ const OPERATOR_CASES: Array<OperatorCase> = [
       return new GreaterThanOrNull(value);
     },
   },
+  /*
+   * The equality operators were missed when the six ordering operators above
+   * were converted, and kept serializing via toString(). That made them the
+   * only type-lossy path left: `new EqualTo(42)` came back as the string
+   * "42", and a Date came back as a locale string such as
+   * "Wed Jul 01 2026 13:34:56 GMT+0100 (British Summer Time)" — timezone
+   * dependent and missing milliseconds. Both broke as soon as a filter had to
+   * survive a round trip through the URL.
+   */
+  {
+    name: "EqualTo",
+    type: EqualTo,
+    create: (value: CompareType) => {
+      return new EqualTo(value);
+    },
+  },
+  {
+    name: "EqualToOrNull",
+    type: EqualToOrNull,
+    create: (value: CompareType) => {
+      return new EqualToOrNull(value);
+    },
+  },
+  {
+    name: "NotEqual",
+    type: NotEqual,
+    create: (value: CompareType) => {
+      return new NotEqual(value);
+    },
+  },
 ];
 
 type SimulateHttpHopFunction = (query: JSONObject) => JSONObject;

package/Tests/Types/Email.test.ts

@@ -0,0 +1,198 @@
+import Email from "../../Types/Email";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { ObjectType } from "../../Types/JSON";
+
+describe("Email", () => {
+  describe("isValid", () => {
+    test("should accept well formed addresses", () => {
+      const valid: Array<string> = [
+        "user@example.com",
+        "user.name+tag@example.co.uk",
+        "user_name@sub.domain.example.com",
+        "user-name@example.io",
+        "u@e.co",
+      ];
+
+      for (const value of valid) {
+        expect(Email.isValid(value)).toBe(true);
+      }
+    });
+
+    test("should reject malformed addresses", () => {
+      const invalid: Array<string> = [
+        "",
+        "userexample.com",
+        "@example.com",
+        "user@",
+        "user@@example.com",
+        "user @example.com",
+      ];
+
+      for (const value of invalid) {
+        expect(Email.isValid(value)).toBe(false);
+      }
+    });
+  });
+
+  describe("constructor", () => {
+    test("should trim and lowercase the address", () => {
+      expect(new Email("  User.Name@Example.COM  ").toString()).toEqual(
+        "user.name@example.com",
+      );
+    });
+
+    test("should throw BadDataException for an invalid address", () => {
+      expect(() => {
+        return new Email("not-an-email");
+      }).toThrow(BadDataException);
+    });
+
+    test("should throw BadDataException for an empty address", () => {
+      expect(() => {
+        return new Email("");
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("fromString", () => {
+    test("should build an Email instance", () => {
+      const email: Email = Email.fromString("user@example.com");
+
+      expect(email).toBeInstanceOf(Email);
+      expect(email.toString()).toEqual("user@example.com");
+    });
+  });
+
+  describe("getEmailDomain", () => {
+    test("should return the hostname after the @", () => {
+      expect(
+        new Email("user@sub.example.com").getEmailDomain().hostname,
+      ).toEqual("sub.example.com");
+    });
+  });
+
+  describe("isBusinessEmail", () => {
+    test("should return false for well known consumer providers", () => {
+      const consumer: Array<string> = [
+        "user@gmail.com",
+        "user@yahoo.com",
+        "user@hotmail.com",
+        "user@outlook.com",
+        "user@icloud.com",
+        "user@protonmail.com",
+        "user@yandex.com",
+      ];
+
+      for (const value of consumer) {
+        expect(new Email(value).isBusinessEmail()).toBe(false);
+      }
+    });
+
+    test("should return true for company domains", () => {
+      expect(new Email("user@oneuptime.com").isBusinessEmail()).toBe(true);
+      expect(new Email("user@acme.io").isBusinessEmail()).toBe(true);
+    });
+  });
+
+  describe("parseList", () => {
+    test("should return an empty list for null, undefined and empty input", () => {
+      expect(Email.parseList(null)).toEqual([]);
+      expect(Email.parseList(undefined)).toEqual([]);
+      expect(Email.parseList("")).toEqual([]);
+    });
+
+    test("should split on commas, semicolons and whitespace", () => {
+      const emails: Array<Email> = Email.parseList(
+        "a@example.com, b@example.com; c@example.com d@example.com",
+      );
+
+      expect(
+        emails.map((e: Email) => {
+          return e.toString();
+        }),
+      ).toEqual([
+        "a@example.com",
+        "b@example.com",
+        "c@example.com",
+        "d@example.com",
+      ]);
+    });
+
+    test("should de-duplicate addresses case insensitively", () => {
+      const emails: Array<Email> = Email.parseList(
+        "a@example.com, A@Example.com, b@example.com",
+      );
+
+      expect(emails.length).toEqual(2);
+      expect(emails[0]!.toString()).toEqual("a@example.com");
+      expect(emails[1]!.toString()).toEqual("b@example.com");
+    });
+
+    test("should throw when any entry in the list is invalid", () => {
+      expect(() => {
+        return Email.parseList("a@example.com, not-an-email");
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("isValidList", () => {
+    test("should treat null, undefined and empty input as valid", () => {
+      expect(Email.isValidList(null)).toBe(true);
+      expect(Email.isValidList(undefined)).toBe(true);
+      expect(Email.isValidList("")).toBe(true);
+    });
+
+    test("should return false when the input has only separators", () => {
+      expect(Email.isValidList(" , ; ")).toBe(false);
+    });
+
+    test("should validate every entry", () => {
+      expect(Email.isValidList("a@example.com; b@example.com")).toBe(true);
+      expect(Email.isValidList("a@example.com, bad")).toBe(false);
+    });
+  });
+
+  describe("toJSON / fromJSON", () => {
+    test("should round trip through JSON", () => {
+      const email: Email = new Email("user@example.com");
+      const json: ReturnType<Email["toJSON"]> = email.toJSON();
+
+      expect(json).toEqual({
+        _type: ObjectType.Email,
+        value: "user@example.com",
+      });
+      expect(Email.fromJSON(json).toString()).toEqual("user@example.com");
+    });
+
+    test("should throw when the JSON is not an Email object", () => {
+      expect(() => {
+        return Email.fromJSON({ _type: "SomethingElse", value: "x@y.com" });
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("toDatabase / fromDatabase", () => {
+    test("should convert to a plain string for the database", () => {
+      expect(Email.toDatabase(new Email("user@example.com"))).toEqual(
+        "user@example.com",
+      );
+    });
+
+    test("should accept a raw string and normalize it", () => {
+      expect(Email.toDatabase("User@Example.com" as unknown as Email)).toEqual(
+        "user@example.com",
+      );
+    });
+
+    test("should return null for empty database values", () => {
+      expect(Email.toDatabase(null as unknown as Email)).toBeNull();
+      expect(Email.fromDatabase("")).toBeNull();
+    });
+
+    test("should hydrate from a database string", () => {
+      expect(Email.fromDatabase("user@example.com")?.toString()).toEqual(
+        "user@example.com",
+      );
+    });
+  });
+});

package/Tests/Types/Kubernetes/KubernetesObjectParser.test.ts

@@ -0,0 +1,177 @@
+import { JSONObject } from "../../../Types/JSON";
+import {
+  extractObjectFromLogBody,
+  getArrayValues,
+  getKvListAsRecord,
+  getKvStringValue,
+  getKvValue,
+  getNestedKvValue,
+  kvListToPlainObject,
+} from "../../../Types/Kubernetes/KubernetesObjectParser";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * KubernetesObjectParser decodes OTLP kvlistValue payloads (the wire shape the
+ * agent ships k8s objects in) into plain values. The OTLP encoding carries the
+ * SAME field under camelCase (JSON transport) and snake_case (protobufjs
+ * transport), and the parser must accept both — a regression that handled only
+ * one encoding would silently drop half the fleet's data. These tests cover the
+ * low-level kv helpers on both encodings plus the log-body entrypoint.
+ */
+
+// Build an OTLP kvlist from a list of [key, valueWrapper] pairs.
+function kvList(entries: Array<[string, JSONObject]>): JSONObject {
+  return {
+    values: entries.map(([key, value]: [string, JSONObject]) => {
+      return { key, value };
+    }),
+  };
+}
+
+describe("getKvValue", () => {
+  test("reads a camelCase stringValue", () => {
+    const list: JSONObject = kvList([["name", { stringValue: "web-1" }]]);
+    expect(getKvValue(list, "name")).toBe("web-1");
+  });
+
+  test("reads a snake_case string_value", () => {
+    const list: JSONObject = kvList([["name", { string_value: "web-1" }]]);
+    expect(getKvValue(list, "name")).toBe("web-1");
+  });
+
+  test("stringifies int and bool values", () => {
+    expect(
+      getKvValue(kvList([["replicas", { intValue: 3 }]]), "replicas"),
+    ).toBe("3");
+    expect(getKvValue(kvList([["ready", { boolValue: true }]]), "ready")).toBe(
+      "true",
+    );
+  });
+
+  test("returns a nested kvlist as an object", () => {
+    const nested: JSONObject = kvList([["app", { stringValue: "api" }]]);
+    const list: JSONObject = kvList([["labels", { kvlistValue: nested }]]);
+    expect(getKvValue(list, "labels")).toEqual(nested);
+  });
+
+  test("returns null for a missing key, missing values, or undefined list", () => {
+    expect(getKvValue(kvList([["a", { stringValue: "1" }]]), "b")).toBeNull();
+    expect(getKvValue({}, "a")).toBeNull();
+    expect(getKvValue(undefined, "a")).toBeNull();
+  });
+});
+
+describe("getKvStringValue", () => {
+  test("returns the string value", () => {
+    expect(getKvStringValue(kvList([["k", { stringValue: "v" }]]), "k")).toBe(
+      "v",
+    );
+  });
+
+  test("returns empty string when the value is a nested object or missing", () => {
+    const list: JSONObject = kvList([["k", { kvlistValue: kvList([]) }]]);
+    expect(getKvStringValue(list, "k")).toBe("");
+    expect(getKvStringValue(list, "missing")).toBe("");
+  });
+});
+
+describe("getNestedKvValue", () => {
+  test("reads parent -> child", () => {
+    const child: JSONObject = kvList([["name", { stringValue: "prod" }]]);
+    const list: JSONObject = kvList([["metadata", { kvlistValue: child }]]);
+    expect(getNestedKvValue(list, "metadata", "name")).toBe("prod");
+  });
+
+  test("returns empty string when the parent is absent or a string", () => {
+    const list: JSONObject = kvList([["metadata", { stringValue: "flat" }]]);
+    expect(getNestedKvValue(list, "metadata", "name")).toBe("");
+    expect(getNestedKvValue(list, "missing", "name")).toBe("");
+  });
+});
+
+describe("getKvListAsRecord", () => {
+  test("flattens mixed scalar entries into a string record", () => {
+    const list: JSONObject = kvList([
+      ["app", { stringValue: "api" }],
+      ["replicas", { intValue: 2 }],
+      ["ready", { boolValue: false }],
+    ]);
+    expect(getKvListAsRecord(list)).toEqual({
+      app: "api",
+      replicas: "2",
+      ready: "false",
+    });
+  });
+
+  test("skips entries without a key or value and handles undefined", () => {
+    expect(getKvListAsRecord(undefined)).toEqual({});
+    const list: JSONObject = {
+      values: [{ key: "", value: { stringValue: "x" } }],
+    };
+    expect(getKvListAsRecord(list)).toEqual({});
+  });
+});
+
+describe("getArrayValues", () => {
+  test("extracts kvlistValue items from an OTLP arrayValue", () => {
+    const item1: JSONObject = kvList([["name", { stringValue: "c1" }]]);
+    const item2: JSONObject = kvList([["name", { stringValue: "c2" }]]);
+    const arrayValue: JSONObject = {
+      values: [{ kvlistValue: item1 }, { kvlistValue: item2 }],
+    };
+    expect(getArrayValues(arrayValue)).toEqual([item1, item2]);
+  });
+
+  test("returns an empty array for undefined or empty input", () => {
+    expect(getArrayValues(undefined)).toEqual([]);
+    expect(getArrayValues({})).toEqual([]);
+  });
+});
+
+describe("kvListToPlainObject", () => {
+  test("converts values to their native JS types", () => {
+    const list: JSONObject = kvList([
+      ["name", { stringValue: "api" }],
+      ["replicas", { intValue: "3" }],
+      ["enabled", { boolValue: true }],
+    ]);
+    const plain: Record<string, unknown> = kvListToPlainObject(list);
+    expect(plain["name"]).toBe("api");
+    expect(plain["replicas"]).toBe(3); // number, not string
+    expect(plain["enabled"]).toBe(true);
+  });
+
+  test("returns an empty object for undefined input", () => {
+    expect(kvListToPlainObject(undefined)).toEqual({});
+  });
+});
+
+describe("extractObjectFromLogBody", () => {
+  test("returns null for invalid JSON", () => {
+    expect(extractObjectFromLogBody("{ not json")).toBeNull();
+  });
+
+  test("returns null when there is no top-level kvlist", () => {
+    expect(extractObjectFromLogBody(JSON.stringify({ foo: "bar" }))).toBeNull();
+  });
+
+  test("extracts the nested object under the 'object' key (watch mode)", () => {
+    const inner: JSONObject = kvList([["kind", { stringValue: "Pod" }]]);
+    const body: JSONObject = {
+      kvlistValue: kvList([["object", { kvlistValue: inner }]]),
+    };
+    expect(extractObjectFromLogBody(JSON.stringify(body))).toEqual(inner);
+  });
+
+  test("treats the kvlist itself as the object when it has a kind (pull mode)", () => {
+    const topList: JSONObject = kvList([["kind", { stringValue: "Node" }]]);
+    const body: JSONObject = { kvlistValue: topList };
+    expect(extractObjectFromLogBody(JSON.stringify(body))).toEqual(topList);
+  });
+
+  test("accepts the snake_case kvlist_value transport", () => {
+    const topList: JSONObject = kvList([["kind", { string_value: "Pod" }]]);
+    const body: JSONObject = { kvlist_value: topList };
+    expect(extractObjectFromLogBody(JSON.stringify(body))).toEqual(topList);
+  });
+});