@oneuptime/common 12.0.5 → 12.0.7

package/Tests/Types/DataSource/DataSourceType.test.ts

@@ -0,0 +1,181 @@
+import DataSourceType, {
+  DataSourceTypeCategories,
+  DataSourceTypeCategory,
+  DataSourceTypeProps,
+  DataSourceTypeUtil,
+} from "../../../Types/DataSource/DataSourceType";
+
+describe("DataSourceTypeUtil", () => {
+  describe("getAllDataSourceTypes", () => {
+    test("returns every declared DataSourceType exactly once", () => {
+      const all: Array<DataSourceType> =
+        DataSourceTypeUtil.getAllDataSourceTypes();
+
+      // Must match the enum members one-for-one — no missing, no duplicates.
+      const enumMembers: Array<DataSourceType> = Object.values(DataSourceType);
+      expect([...all].sort()).toEqual([...enumMembers].sort());
+      expect(new Set(all).size).toBe(all.length);
+    });
+
+    test("returns a fresh array each call (callers may mutate it)", () => {
+      const first: Array<DataSourceType> =
+        DataSourceTypeUtil.getAllDataSourceTypes();
+      const second: Array<DataSourceType> =
+        DataSourceTypeUtil.getAllDataSourceTypes();
+      expect(first).not.toBe(second);
+      expect(first).toEqual(second);
+    });
+  });
+
+  describe("isHttpBasedType / isDatabaseType partition", () => {
+    test("every type is exactly one of HTTP-based or database", () => {
+      for (const type of DataSourceTypeUtil.getAllDataSourceTypes()) {
+        const http: boolean = DataSourceTypeUtil.isHttpBasedType(type);
+        const db: boolean = DataSourceTypeUtil.isDatabaseType(type);
+        // Exactly one of the two must be true — they partition the set.
+        expect(http).not.toEqual(db);
+      }
+    });
+
+    test("HTTP-based types are the metrics/logs/search/api connectors", () => {
+      expect(
+        DataSourceTypeUtil.isHttpBasedType(DataSourceType.Prometheus),
+      ).toBe(true);
+      expect(DataSourceTypeUtil.isHttpBasedType(DataSourceType.Loki)).toBe(
+        true,
+      );
+      expect(
+        DataSourceTypeUtil.isHttpBasedType(DataSourceType.Elasticsearch),
+      ).toBe(true);
+      expect(DataSourceTypeUtil.isHttpBasedType(DataSourceType.RestApi)).toBe(
+        true,
+      );
+      expect(
+        DataSourceTypeUtil.isHttpBasedType(DataSourceType.PostgreSQL),
+      ).toBe(false);
+    });
+
+    test("database types are the SQL-driver connectors", () => {
+      expect(DataSourceTypeUtil.isDatabaseType(DataSourceType.PostgreSQL)).toBe(
+        true,
+      );
+      expect(DataSourceTypeUtil.isDatabaseType(DataSourceType.MySQL)).toBe(
+        true,
+      );
+      expect(
+        DataSourceTypeUtil.isDatabaseType(DataSourceType.MicrosoftSqlServer),
+      ).toBe(true);
+      expect(DataSourceTypeUtil.isDatabaseType(DataSourceType.ClickHouse)).toBe(
+        true,
+      );
+      expect(DataSourceTypeUtil.isDatabaseType(DataSourceType.Prometheus)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("getDefaultPort", () => {
+    test("database types seed the well-known driver port", () => {
+      expect(DataSourceTypeUtil.getDefaultPort(DataSourceType.PostgreSQL)).toBe(
+        5432,
+      );
+      expect(DataSourceTypeUtil.getDefaultPort(DataSourceType.MySQL)).toBe(
+        3306,
+      );
+      expect(
+        DataSourceTypeUtil.getDefaultPort(DataSourceType.MicrosoftSqlServer),
+      ).toBe(1433);
+      // ClickHouse is queried over its HTTP interface, not the native 9000.
+      expect(DataSourceTypeUtil.getDefaultPort(DataSourceType.ClickHouse)).toBe(
+        8123,
+      );
+    });
+
+    test("HTTP-based types have no default port (they carry a full URL)", () => {
+      expect(
+        DataSourceTypeUtil.getDefaultPort(DataSourceType.Prometheus),
+      ).toBeNull();
+      expect(DataSourceTypeUtil.getDefaultPort(DataSourceType.Loki)).toBeNull();
+      expect(
+        DataSourceTypeUtil.getDefaultPort(DataSourceType.Elasticsearch),
+      ).toBeNull();
+      expect(
+        DataSourceTypeUtil.getDefaultPort(DataSourceType.RestApi),
+      ).toBeNull();
+    });
+
+    test("a default port is defined for exactly the database types", () => {
+      for (const type of DataSourceTypeUtil.getAllDataSourceTypes()) {
+        const hasPort: boolean =
+          DataSourceTypeUtil.getDefaultPort(type) !== null;
+        expect(hasPort).toBe(DataSourceTypeUtil.isDatabaseType(type));
+      }
+    });
+  });
+
+  describe("getProps", () => {
+    test("every type gets self-consistent, non-empty display props", () => {
+      for (const type of DataSourceTypeUtil.getAllDataSourceTypes()) {
+        const props: DataSourceTypeProps = DataSourceTypeUtil.getProps(type);
+
+        // The props describe the very type they were requested for.
+        expect(props.dataSourceType).toBe(type);
+        expect(props.title.length).toBeGreaterThan(0);
+        expect(props.description.length).toBeGreaterThan(0);
+        expect(props.queryLanguageTitle.length).toBeGreaterThan(0);
+        expect(props.queryPlaceholder.length).toBeGreaterThan(0);
+        // The category must be one the picker knows how to render.
+        expect(DataSourceTypeCategories).toContain(props.category);
+      }
+    });
+
+    test("getCategory agrees with getProps().category", () => {
+      for (const type of DataSourceTypeUtil.getAllDataSourceTypes()) {
+        expect(DataSourceTypeUtil.getCategory(type)).toBe(
+          DataSourceTypeUtil.getProps(type).category,
+        );
+      }
+    });
+
+    test("all four database types are categorised as Databases", () => {
+      for (const type of DataSourceTypeUtil.getAllDataSourceTypes()) {
+        if (DataSourceTypeUtil.isDatabaseType(type)) {
+          expect(DataSourceTypeUtil.getCategory(type)).toBe(
+            DataSourceTypeCategory.Databases,
+          );
+        }
+      }
+    });
+
+    test("the connector categories land in their expected sections", () => {
+      expect(DataSourceTypeUtil.getCategory(DataSourceType.Prometheus)).toBe(
+        DataSourceTypeCategory.Metrics,
+      );
+      expect(DataSourceTypeUtil.getCategory(DataSourceType.Loki)).toBe(
+        DataSourceTypeCategory.Logs,
+      );
+      expect(DataSourceTypeUtil.getCategory(DataSourceType.Elasticsearch)).toBe(
+        DataSourceTypeCategory.Search,
+      );
+      expect(DataSourceTypeUtil.getCategory(DataSourceType.RestApi)).toBe(
+        DataSourceTypeCategory.Api,
+      );
+    });
+  });
+
+  describe("DataSourceTypeCategories ordering", () => {
+    test("lists every category once, in the picker's display order", () => {
+      expect(DataSourceTypeCategories).toEqual([
+        DataSourceTypeCategory.Metrics,
+        DataSourceTypeCategory.Logs,
+        DataSourceTypeCategory.Databases,
+        DataSourceTypeCategory.Search,
+        DataSourceTypeCategory.Api,
+      ]);
+      // No category is missing and none is listed twice.
+      expect(new Set(DataSourceTypeCategories).size).toBe(
+        Object.values(DataSourceTypeCategory).length,
+      );
+    });
+  });
+});

package/Tests/Types/DateClickhouseFormat.test.ts

@@ -0,0 +1,192 @@
+import OneUptimeDate from "../../Types/Date";
+import moment from "moment-timezone";
+import { afterAll, describe, expect, test } from "@jest/globals";
+
+/*
+ * Run the whole suite in a non-UTC, DST-observing zone. Under TZ=UTC the
+ * local and UTC Date getters agree, so a getUTC* -> get* regression in the
+ * hand-rolled formatter would be invisible to every parity assertion below.
+ * America/New_York makes any local-getter mutation diverge from the
+ * moment-UTC oracle deterministically (including across DST transitions in
+ * the fuzz sweep). Node re-reads process.env.TZ on Date operations; the
+ * original value is restored afterAll so co-resident suites in the same
+ * worker keep the process default.
+ */
+const ORIGINAL_TZ: string | undefined = process.env["TZ"];
+process.env["TZ"] = "America/New_York";
+
+afterAll(() => {
+  if (ORIGINAL_TZ === undefined) {
+    delete process.env["TZ"];
+  } else {
+    process.env["TZ"] = ORIGINAL_TZ;
+  }
+});
+
+/*
+ * Contract under test — the ClickHouse DateTime formatters that stamp every
+ * ingested telemetry row (createdAt, time, retentionDate, startTime/endTime).
+ *
+ * These used to be moment(...).utc().format("YYYY-MM-DD HH:mm:ss"), which
+ * allocates a moment wrapper and parses a format-token string PER CALL — and
+ * they are called several times per log record / span / metric datapoint.
+ * They are now a hand-rolled UTC formatter. The replacement must be
+ * byte-identical to what moment produced, because these strings are written
+ * straight into ClickHouse DateTime columns and compared/parsed downstream.
+ *
+ * The parity tests below therefore compare the new implementation against a
+ * live moment call, not against hardcoded strings, across edge cases and a
+ * deterministic fuzz sweep.
+ */
+
+function momentReference(date: Date): string {
+  return moment(date).utc().format("YYYY-MM-DD HH:mm:ss");
+}
+
+describe("OneUptimeDate.toClickhouseDateTime", () => {
+  const edgeCases: Array<{ name: string; date: Date }> = [
+    { name: "unix epoch", date: new Date(0) },
+    { name: "one ms before epoch", date: new Date(-1) },
+    { name: "one second before epoch", date: new Date(-1000) },
+    {
+      name: "pre-1970 date",
+      date: new Date(Date.UTC(1955, 10, 5, 6, 15, 30, 123)),
+    },
+    {
+      name: "leap day",
+      date: new Date(Date.UTC(2024, 1, 29, 23, 59, 59, 999)),
+    },
+    {
+      name: "year rollover instant",
+      date: new Date(Date.UTC(2025, 11, 31, 23, 59, 59, 999)),
+    },
+    {
+      name: "first instant of a year",
+      date: new Date(Date.UTC(2026, 0, 1, 0, 0, 0, 0)),
+    },
+    {
+      name: "single-digit month/day/hour/minute/second",
+      date: new Date(Date.UTC(2026, 2, 4, 5, 6, 7, 8)),
+    },
+    {
+      name: "three-digit year pads to 4 digits",
+      date: new Date(Date.UTC(999, 0, 2, 3, 4, 5)),
+    },
+    {
+      name: "far future",
+      date: new Date(Date.UTC(2999, 11, 31, 12, 0, 0)),
+    },
+  ];
+
+  for (const { name, date } of edgeCases) {
+    test(`matches the moment implementation it replaced: ${name}`, () => {
+      expect(OneUptimeDate.toClickhouseDateTime(date)).toBe(
+        momentReference(date),
+      );
+    });
+  }
+
+  test("fuzz sweep: parity with moment across ±100 years", () => {
+    /*
+     * Deterministic LCG so a failure is reproducible. 2000 samples spread
+     * across ~200 years of epoch millis, including sub-second components.
+     */
+    let seed: number = 42;
+    const nextRandom: () => number = (): number => {
+      seed = (seed * 1103515245 + 12345) % 2147483648;
+      return seed / 2147483648;
+    };
+
+    const hundredYearsMs: number = 100 * 365.25 * 24 * 3600 * 1000;
+
+    for (let i: number = 0; i < 2000; i++) {
+      const ms: number = Math.floor((nextRandom() * 2 - 1) * hundredYearsMs);
+      const date: Date = new Date(ms);
+      expect(OneUptimeDate.toClickhouseDateTime(date)).toBe(
+        momentReference(date),
+      );
+    }
+  });
+
+  test("accepts ISO string input like the moment version did", () => {
+    const iso: string = "2026-08-10T13:45:59.500Z";
+    expect(OneUptimeDate.toClickhouseDateTime(iso)).toBe(
+      momentReference(new Date(iso)),
+    );
+  });
+
+  test("keeps moment's 'Invalid date' sentinel for NaN dates", () => {
+    const invalid: Date = new Date(NaN);
+    expect(OneUptimeDate.toClickhouseDateTime(invalid)).toBe(
+      momentReference(invalid),
+    );
+    expect(OneUptimeDate.toClickhouseDateTime(invalid)).toBe("Invalid date");
+  });
+
+  test("output is always UTC regardless of process timezone", () => {
+    // 2026-06-15T00:30:00Z is a different calendar day in UTC-negative zones.
+    const date: Date = new Date(Date.UTC(2026, 5, 15, 0, 30, 0));
+    expect(OneUptimeDate.toClickhouseDateTime(date)).toBe(
+      "2026-06-15 00:30:00",
+    );
+  });
+});
+
+describe("OneUptimeDate.toClickhouseDateTime64", () => {
+  /*
+   * Nano timestamps arrive as JS numbers, so a modern epoch date times 1e6
+   * exceeds Number.MAX_SAFE_INTEGER and the sub-second digits are already
+   * imprecise before this function sees them (pre-existing caller
+   * behavior). Exercise the extraction arithmetic with early-epoch dates
+   * whose nano values are exactly representable.
+   */
+  test("extracts sub-second nanos from the unix-nano timestamp", () => {
+    const date: Date = new Date(Date.UTC(1970, 0, 20, 12, 0, 5, 0));
+    // 123456789 sub-second nanoseconds — exactly representable here.
+    const nano: number = date.getTime() * 1_000_000 + 123_456_789;
+    expect(OneUptimeDate.toClickhouseDateTime64(date, nano)).toBe(
+      "1970-01-20 12:00:05.123456789",
+    );
+  });
+
+  test("pads short sub-second nano fractions to 9 digits", () => {
+    const date: Date = new Date(Date.UTC(1970, 0, 20, 12, 0, 5, 0));
+    const nano: number = date.getTime() * 1_000_000 + 7;
+    expect(OneUptimeDate.toClickhouseDateTime64(date, nano)).toBe(
+      "1970-01-20 12:00:05.000000007",
+    );
+  });
+
+  test("falls back to Date milliseconds when nano timestamp is absent", () => {
+    const date: Date = new Date(Date.UTC(2026, 7, 10, 12, 0, 5, 123));
+    expect(OneUptimeDate.toClickhouseDateTime64(date)).toBe(
+      "2026-08-10 12:00:05.123000000",
+    );
+  });
+
+  test("falls back to Date milliseconds when nano timestamp is zero", () => {
+    // The implementation treats only nanoTimestamp > 0 as authoritative.
+    const date: Date = new Date(Date.UTC(2026, 7, 10, 12, 0, 5, 42));
+    expect(OneUptimeDate.toClickhouseDateTime64(date, 0)).toBe(
+      "2026-08-10 12:00:05.042000000",
+    );
+  });
+
+  test("base portion matches the moment implementation it replaced", () => {
+    const date: Date = new Date(Date.UTC(1999, 11, 31, 23, 59, 59, 999));
+    const formatted: string = OneUptimeDate.toClickhouseDateTime64(date);
+    expect(formatted.slice(0, 19)).toBe(momentReference(date));
+  });
+});
+
+describe("OneUptimeDate.getCurrentDate", () => {
+  test("returns the current wall-clock time as a plain Date", () => {
+    const before: number = Date.now();
+    const current: Date = OneUptimeDate.getCurrentDate();
+    const after: number = Date.now();
+
+    expect(current).toBeInstanceOf(Date);
+    expect(current.getTime()).toBeGreaterThanOrEqual(before);
+    expect(current.getTime()).toBeLessThanOrEqual(after);
+  });
+});

package/Tests/Types/DomainSubdomainValidation.test.ts

@@ -0,0 +1,90 @@
+import Domain from "../../Types/Domain";
+import URL from "../../Types/API/URL";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * StatusPageDomain.subdomain and DashboardDomain.subdomain are ShortText that
+ * used to be trimmed and lower-cased and nothing else. Both services build
+ * fullDomain as `${subdomain}.${baseDomain}` and then interpolate it into
+ * "https://" + fullDomain + "/status-page-api/...", which the certificate
+ * cron fetches unattended every 15 minutes. Because URL parsing takes
+ * everything before the first "/" as the host, a subdomain carrying a "/"
+ * gave an attacker the host, the port and the path of that request.
+ */
+
+describe("Domain.isValidSubdomain accepts ordinary subdomains", () => {
+  const valid: Array<string> = [
+    "status",
+    "dashboard",
+    "status-page",
+    "eu-west-1",
+    "a",
+    "status.eu",
+    "deep.nested.label",
+    "s1",
+    "1status",
+  ];
+
+  test.each(valid)("accepts %s", (subdomain: string) => {
+    expect(Domain.isValidSubdomain(subdomain)).toBe(true);
+  });
+});
+
+describe("Domain.isValidSubdomain rejects anything that is not a DNS label", () => {
+  const invalid: Array<string> = [
+    // The metadata-endpoint injection this exists to stop.
+    "169.254.169.254/latest/meta-data/#",
+    "169.254.169.254/latest/meta-data/iam/security-credentials/#",
+    "status/../../admin",
+    "status/path",
+    // Scheme, port, credentials, query, fragment.
+    "http://169.254.169.254",
+    "169.254.169.254:80",
+    "user@169.254.169.254",
+    "status?x=1",
+    "status#frag",
+    "status\\evil",
+    // Structural junk.
+    "-status",
+    "status-",
+    "sta tus",
+    "",
+    "@",
+    ".",
+    "status..double",
+    ".status",
+    "status.",
+  ];
+
+  test.each(invalid)("rejects %s", (subdomain: string) => {
+    expect(Domain.isValidSubdomain(subdomain)).toBe(false);
+  });
+
+  test("rejects a label longer than 63 characters", () => {
+    expect(Domain.isValidSubdomain("a".repeat(63))).toBe(true);
+    expect(Domain.isValidSubdomain("a".repeat(64))).toBe(false);
+  });
+});
+
+describe("the injection this blocks, end to end", () => {
+  test("an unvalidated subdomain would have redirected the cert check to metadata", () => {
+    /*
+     * Demonstrates why a subdomain check is the fix rather than trusting the
+     * URL builder: with the malicious label in place, the host of the
+     * resulting URL is the metadata endpoint and the base domain has been
+     * demoted into the path.
+     */
+    const maliciousSubdomain: string = "169.254.169.254/latest/meta-data/#";
+    const baseDomain: string = "example.com";
+    const fullDomain: string = `${maliciousSubdomain}.${baseDomain}`;
+
+    const url: URL = URL.fromString(
+      "https://" + fullDomain + "/status-page-api/cname-verification/token",
+    );
+
+    expect(url.hostname.hostname).toBe("169.254.169.254");
+
+    // And the validator refuses to let that subdomain be stored at all.
+    expect(Domain.isValidSubdomain(maliciousSubdomain)).toBe(false);
+  });
+});