@oneuptime/common 11.5.11 → 11.5.13

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

@@ -0,0 +1,216 @@
+import CompareBase, { CompareType } from "../../../Types/Database/CompareBase";
+import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
+import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
+import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
+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 JSONFunctions from "../../../Types/JSONFunctions";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Pins the WIRE CONTRACT of the comparison query operators end to end:
+ *
+ *   browser:  JSONFunctions.serialize(query)  ->  operator.toJSON()
+ *   HTTP:     JSON.stringify / JSON.parse     (a raw Date becomes its full ISO string)
+ *   server:   JSONFunctions.deserialize       ->  Dictionary[_type].fromJSON
+ *   SQL bind: operator.toString()             ->  QueryHelper.<op>(value)
+ *
+ * The bug this file guards against: toJSON used to serialize Date values via
+ * toString(), which collapses them to a DATE-ONLY string in the BROWSER'S LOCAL
+ * TIMEZONE (OneUptimeDate.asDateForDatabaseQuery). A bound of "now" therefore
+ * arrived at the server as midnight of the viewer's calendar date, and every
+ * row from later that day was silently excluded from the query - e.g. the
+ * Monitor View page dropped a monitor's current open status row whenever the
+ * status had changed the same day. Serializing the RAW value (exactly what
+ * InBetween always did) keeps the full timestamp across the wire in every
+ * timezone.
+ *
+ * The legacy date-only wire format must STAY accepted: an old client (or a
+ * saved query serialized before this change) sends value: "YYYY-MM-DD", and
+ * the server must keep treating it as an opaque string bound.
+ */
+
+const FULL_ISO_TIMESTAMP: string = "2026-07-21T14:35:12.345Z";
+const LEGACY_DATE_ONLY: string = "2026-07-21";
+
+type OperatorFactory = (value: CompareType) => CompareBase<CompareType>;
+
+type OperatorCase = {
+  name: string;
+  type: unknown;
+  create: OperatorFactory;
+};
+
+const OPERATOR_CASES: Array<OperatorCase> = [
+  {
+    name: "LessThan",
+    type: LessThan,
+    create: (value: CompareType) => {
+      return new LessThan(value);
+    },
+  },
+  {
+    name: "LessThanOrEqual",
+    type: LessThanOrEqual,
+    create: (value: CompareType) => {
+      return new LessThanOrEqual(value);
+    },
+  },
+  {
+    name: "LessThanOrNull",
+    type: LessThanOrNull,
+    create: (value: CompareType) => {
+      return new LessThanOrNull(value);
+    },
+  },
+  {
+    name: "GreaterThan",
+    type: GreaterThan,
+    create: (value: CompareType) => {
+      return new GreaterThan(value);
+    },
+  },
+  {
+    name: "GreaterThanOrEqual",
+    type: GreaterThanOrEqual,
+    create: (value: CompareType) => {
+      return new GreaterThanOrEqual(value);
+    },
+  },
+  {
+    name: "GreaterThanOrNull",
+    type: GreaterThanOrNull,
+    create: (value: CompareType) => {
+      return new GreaterThanOrNull(value);
+    },
+  },
+];
+
+type SimulateHttpHopFunction = (query: JSONObject) => JSONObject;
+
+/*
+ * What actually happens between ModelAPI.getList and BaseAPI: the serialized
+ * query is JSON.stringify'd into the request body and JSON.parse'd on the
+ * server. This is the step that turns a raw Date into its full ISO string.
+ */
+const simulateHttpHop: SimulateHttpHopFunction = (
+  query: JSONObject,
+): JSONObject => {
+  return JSON.parse(JSON.stringify(JSONFunctions.serialize(query)));
+};
+
+for (const operatorCase of OPERATOR_CASES) {
+  describe(`${operatorCase.name} wire serialization`, () => {
+    it("sends a Date bound as its full ISO timestamp, not a local date-only string", () => {
+      const query: JSONObject = {
+        startsAt: operatorCase.create(new Date(FULL_ISO_TIMESTAMP)),
+      } as unknown as JSONObject;
+
+      const wire: JSONObject = simulateHttpHop(query);
+
+      expect((wire["startsAt"] as JSONObject)["_type"]).toBe(operatorCase.name);
+      /*
+       * The critical assertion: the full timestamp survives. Under the old
+       * toString()-based toJSON this was "2026-07-21" (or "2026-07-22" east
+       * of UTC) regardless of the time component.
+       */
+      expect((wire["startsAt"] as JSONObject)["value"]).toBe(
+        FULL_ISO_TIMESTAMP,
+      );
+    });
+
+    it("deserializes on the server to the operator with the full-precision bound", () => {
+      const query: JSONObject = {
+        startsAt: operatorCase.create(new Date(FULL_ISO_TIMESTAMP)),
+      } as unknown as JSONObject;
+
+      const deserialized: JSONObject = JSONFunctions.deserialize(
+        simulateHttpHop(query),
+      );
+
+      expect(deserialized["startsAt"]).toBeInstanceOf(operatorCase.type);
+
+      /*
+       * toString() is exactly what QueryUtil passes into QueryHelper as the
+       * SQL bind value, so this string IS the query bound. It must be the
+       * full ISO timestamp, passed through untouched.
+       */
+      const operator: CompareBase<CompareType> = deserialized[
+        "startsAt"
+      ] as unknown as CompareBase<CompareType>;
+
+      expect(operator.toString()).toBe(FULL_ISO_TIMESTAMP);
+    });
+
+    it("still accepts the legacy date-only wire format as an opaque string", () => {
+      const legacyWire: JSONObject = {
+        startsAt: {
+          _type: operatorCase.name,
+          value: LEGACY_DATE_ONLY,
+        },
+      };
+
+      const deserialized: JSONObject = JSONFunctions.deserialize(legacyWire);
+
+      expect(deserialized["startsAt"]).toBeInstanceOf(operatorCase.type);
+
+      const operator: CompareBase<CompareType> = deserialized[
+        "startsAt"
+      ] as unknown as CompareBase<CompareType>;
+
+      expect(operator.toString()).toBe(LEGACY_DATE_ONLY);
+    });
+
+    it("round-trips a number bound unchanged", () => {
+      const query: JSONObject = {
+        priority: operatorCase.create(42),
+      } as unknown as JSONObject;
+
+      const wire: JSONObject = simulateHttpHop(query);
+
+      expect((wire["priority"] as JSONObject)["value"]).toBe(42);
+
+      const deserialized: JSONObject = JSONFunctions.deserialize(wire);
+
+      const operator: CompareBase<CompareType> = deserialized[
+        "priority"
+      ] as unknown as CompareBase<CompareType>;
+
+      expect(operator.toString()).toBe("42");
+    });
+  });
+}
+
+describe("InBetween wire serialization (the reference behavior)", () => {
+  it("has always sent full ISO timestamps for both bounds - the operators above now match it", () => {
+    const startBound: string = "2026-04-22T00:30:00.000Z";
+
+    const query: JSONObject = {
+      createdAt: new InBetween(
+        new Date(startBound),
+        new Date(FULL_ISO_TIMESTAMP),
+      ),
+    } as unknown as JSONObject;
+
+    const wire: JSONObject = simulateHttpHop(query);
+
+    expect((wire["createdAt"] as JSONObject)["startValue"]).toBe(startBound);
+    expect((wire["createdAt"] as JSONObject)["endValue"]).toBe(
+      FULL_ISO_TIMESTAMP,
+    );
+
+    const deserialized: JSONObject = JSONFunctions.deserialize(wire);
+
+    expect(deserialized["createdAt"]).toBeInstanceOf(InBetween);
+
+    const operator: InBetween<CompareType> = deserialized[
+      "createdAt"
+    ] as unknown as InBetween<CompareType>;
+
+    expect(operator.toStartValueString()).toBe(startBound);
+    expect(operator.toEndValueString()).toBe(FULL_ISO_TIMESTAMP);
+  });
+});

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

@@ -25,7 +25,11 @@ describe("GreaterThan", () => {
     const obj: GreaterThan<number> = new GreaterThan<number>(42);
     const expectedJSON: JSONObject = {
       _type: "GreaterThan",
-      value: "42",
+      /*
+       * toJSON carries the RAW value (like InBetween), not a stringified one -
+       * see the comment on toJSON. For numbers that means the number itself.
+       */
+      value: 42,
     };
     expect(obj.toJSON()).toEqual(expectedJSON);
   });

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

@@ -27,7 +27,11 @@ describe("GreaterThanOrEqual", () => {
     const obj: GreaterThanOrEqual<number> = new GreaterThanOrEqual<number>(42);
     const expectedJSON: JSONObject = {
       _type: "GreaterThanOrEqual",
-      value: "42",
+      /*
+       * toJSON carries the RAW value (like InBetween), not a stringified one -
+       * see the comment on toJSON. For numbers that means the number itself.
+       */
+      value: 42,
     };
     expect(obj.toJSON()).toEqual(expectedJSON);
   });

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

@@ -23,13 +23,36 @@ describe("GreaterThanOrNull", () => {
 
   it("should generate the correct JSON representation using toJSON", () => {
     const obj: GreaterThanOrNull<number> = new GreaterThanOrNull<number>(42);
+    /*
+     * toJSON carries the RAW value (like InBetween), not a stringified one -
+     * see the comment on toJSON. For numbers that means the number itself.
+     */
     const expectedJSON: JSONObject = {
       _type: "GreaterThanOrNull",
-      value: "42",
+      value: 42,
     };
     expect(obj.toJSON()).toEqual(expectedJSON);
   });
 
+  it("keeps the full timestamp when serializing a Date value", () => {
+    const value: Date = new Date("2026-07-21T14:35:12.345Z");
+    const obj: GreaterThanOrNull<Date> = new GreaterThanOrNull<Date>(value);
+
+    /*
+     * The raw Date is serialized, so JSON.stringify emits the full ISO
+     * timestamp. The old toString()-based toJSON collapsed it to a
+     * local-timezone date-only string, which shifted query bounds sent from
+     * the browser by up to a day and silently dropped same-day rows.
+     */
+    expect(obj.toJSON()).toEqual({
+      _type: "GreaterThanOrNull",
+      value: value,
+    });
+    expect(JSON.parse(JSON.stringify(obj.toJSON()))["value"]).toBe(
+      "2026-07-21T14:35:12.345Z",
+    );
+  });
+
   it("should create a GreaterThanOrNull object from valid JSON input", () => {
     const jsonInput: JSONObject = {
       _type: "GreaterThanOrNull",

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

@@ -25,7 +25,11 @@ describe("LessThan", () => {
     const obj: LessThan<number> = new LessThan<number>(42);
     const expectedJSON: JSONObject = {
       _type: "LessThan",
-      value: "42",
+      /*
+       * toJSON carries the RAW value (like InBetween), not a stringified one -
+       * see the comment on toJSON. For numbers that means the number itself.
+       */
+      value: 42,
     };
     expect(obj.toJSON()).toEqual(expectedJSON);
   });

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

@@ -23,13 +23,36 @@ describe("LessThanOrEqual", () => {
 
   it("should generate the correct JSON representation using toJSON", () => {
     const obj: LessThanOrEqual<number> = new LessThanOrEqual<number>(42);
+    /*
+     * toJSON carries the RAW value (like InBetween), not a stringified one -
+     * see the comment on toJSON. For numbers that means the number itself.
+     */
     const expectedJSON: JSONObject = {
       _type: "LessThanOrEqual",
-      value: "42",
+      value: 42,
     };
     expect(obj.toJSON()).toEqual(expectedJSON);
   });
 
+  it("keeps the full timestamp when serializing a Date value", () => {
+    const value: Date = new Date("2026-07-21T14:35:12.345Z");
+    const obj: LessThanOrEqual<Date> = new LessThanOrEqual<Date>(value);
+
+    /*
+     * The raw Date is serialized, so JSON.stringify emits the full ISO
+     * timestamp. The old toString()-based toJSON collapsed it to a
+     * local-timezone date-only string, which shifted query bounds sent from
+     * the browser by up to a day and silently dropped same-day rows.
+     */
+    expect(obj.toJSON()).toEqual({
+      _type: "LessThanOrEqual",
+      value: value,
+    });
+    expect(JSON.parse(JSON.stringify(obj.toJSON()))["value"]).toBe(
+      "2026-07-21T14:35:12.345Z",
+    );
+  });
+
   it("should create a LessThanOrEqual object from valid JSON input", () => {
     const jsonInput: JSONObject = {
       _type: "LessThanOrEqual",

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

@@ -25,7 +25,11 @@ describe("LessThanOrNull", () => {
     const obj: LessThanOrNull<number> = new LessThanOrNull<number>(42);
     const expectedJSON: JSONObject = {
       _type: "LessThanOrNull",
-      value: "42",
+      /*
+       * toJSON carries the RAW value (like InBetween), not a stringified one -
+       * see the comment on toJSON. For numbers that means the number itself.
+       */
+      value: 42,
     };
     expect(obj.toJSON()).toEqual(expectedJSON);
   });

package/Tests/UI/Components/ModelTableSelectFromColumns.test.ts

@@ -0,0 +1,259 @@
+import Columns from "../../../UI/Components/ModelTable/Columns";
+import {
+  getRelationSelectFromColumns,
+  getSelectFromColumns,
+} from "../../../UI/Components/ModelTable/SelectFromColumns";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import Alert from "../../../Models/DatabaseModels/Alert";
+import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ModelTable SelectFromColumns", () => {
+  describe("getSelectFromColumns", () => {
+    test("it selects every field a column declares, not just the first", () => {
+      /*
+       * Regression for OneUptime/oneuptime#2756: the Proxmox clusters list
+       * rendered "0/3 online" for a fully online cluster because only the
+       * first key of the column's field map was selected, leaving
+       * onlineNodeCount undefined on every row.
+       */
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBe(true);
+    });
+
+    test("it always selects _id", () => {
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: [],
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["_id"]).toBe(true);
+    });
+
+    test("it merges fields across multiple columns", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { name: true },
+          title: "Name",
+          type: FieldType.Text,
+        },
+        {
+          field: { guestCount: true, storageCount: true },
+          title: "Inventory",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["name"]).toBe(true);
+      expect(select["guestCount"]).toBe(true);
+      expect(select["storageCount"]).toBe(true);
+    });
+
+    test("it skips columns that declare no field", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: undefined as never,
+          title: "Actions",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(Object.keys(select)).toEqual(["_id"]);
+    });
+
+    test("it throws when the primary field is not a column on the model", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { notARealColumn: true } as never,
+          title: "Nope",
+          type: FieldType.Text,
+        },
+      ];
+
+      expect(() => {
+        return getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("it ignores a non-column secondary field rather than blanking the page", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { nodeCount: true, notARealColumn: true } as never,
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const consoleError: jest.SpyInstance = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["notARealColumn"]).toBeUndefined();
+      // It must not drop the field silently — that is how #2756 hid.
+      expect(consoleError).toHaveBeenCalled();
+
+      consoleError.mockRestore();
+    });
+
+    test("it drops a secondary field the user cannot read, so the API does not reject the whole request", () => {
+      /*
+       * checkSelectPermission throws NotAuthorizedException for the entire
+       * request when the select names an unreadable column, so widening the
+       * select must never add one.
+       */
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+          hasPermissionToReadField: (field: string): boolean => {
+            return field !== "onlineNodeCount";
+          },
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBeUndefined();
+    });
+
+    test("it keeps the primary field even when the permission callback rejects it, preserving prior behaviour", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { nodeCount: true, onlineNodeCount: true },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+          hasPermissionToReadField: (): boolean => {
+            return false;
+          },
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBeUndefined();
+    });
+  });
+
+  describe("getRelationSelectFromColumns", () => {
+    test("it selects every relation a column declares, not just the first", () => {
+      const columns: Columns<Alert> = [
+        {
+          field: {
+            monitor: { name: true, _id: true },
+            labels: { name: true, color: true },
+          },
+          title: "Resource",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<Alert>({
+          columns: columns,
+          model: new Alert(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect["monitor"]).toEqual({ name: true, _id: true });
+      expect(relationSelect["labels"]).toEqual({ name: true, color: true });
+    });
+
+    test("it leaves non-entity fields out of the relation select", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect).toEqual({});
+    });
+
+    test("it merges the same relation declared by two columns", () => {
+      const columns: Columns<Alert> = [
+        {
+          field: { monitor: { name: true } },
+          title: "Monitor",
+          type: FieldType.Element,
+        },
+        {
+          field: { monitor: { _id: true } },
+          title: "Monitor Id",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<Alert>({
+          columns: columns,
+          model: new Alert(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect["monitor"]).toEqual({ name: true, _id: true });
+    });
+  });
+});