@oneuptime/common 12.0.14 → 12.0.15

package/Tests/Server/Types/Database/SelectUtil.test.ts

@@ -0,0 +1,348 @@
+import BaseModel from "../../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import OnCallDutyPolicyEscalationRuleSchedule from "../../../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleSchedule";
+import RelationSelect from "../../../../Server/Types/Database/RelationSelect";
+import Select from "../../../../Server/Types/Database/Select";
+import SelectUtil from "../../../../Server/Types/Database/SelectUtil";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * SelectUtil.sanitizeSelect walks the top level of a caller-supplied select and
+ * splits it into two shapes TypeORM needs kept apart: the scalar `select` (left
+ * as-is) and a `relationSelect` naming which relations to join. A key is a
+ * relation when model.isEntityColumn(key) is true - that is, its column
+ * metadata type is Entity or EntityArray.
+ *
+ * For every relation key it does two things regardless of what the caller
+ * asked for:
+ *   - records `relationSelect[key] = true`, and
+ *   - rewrites `select[key]` to an object that ALWAYS carries `_id: true`.
+ *
+ * The forced `_id: true` is deliberate and security-relevant: the source
+ * comment says a whole-object relation select is narrowed to just the id, and
+ * the id is merged in AFTER the caller's own keys so it cannot be turned off.
+ * Non-relation keys are never touched and never appear in relationSelect. The
+ * `select` object is MUTATED in place and returned; relationSelect is fresh.
+ *
+ * These models are used as fixtures because their column metadata is stable:
+ *   - OnCallDutyPolicyEscalationRuleSchedule: `project` /
+ *     `onCallDutyPolicySchedule` are Entity relations, `projectId` /
+ *     `onCallDutyPolicyScheduleId` / `_id` are scalar ObjectID columns. It has
+ *     no `name` column, so `name` is used below only as the unknown-column case.
+ *   - Monitor: `labels` / `dependsOnMonitors` are EntityArray relations and
+ *     `name` is a real scalar column, covering the second entity enum value.
+ */
+
+type SanitizeResult<TBaseModel extends BaseModel> = {
+  select: Select<TBaseModel>;
+  relationSelect: RelationSelect<TBaseModel>;
+};
+
+describe("SelectUtil.sanitizeSelect - relation key set to a boolean", () => {
+  it("replaces `true` on a relation with an id-only object", () => {
+    /*
+     * The else branch: the value is not an object, so spreading it contributes
+     * nothing and the relation collapses to exactly `{ _id: true }`.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      project: true,
+    };
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({ project: { _id: true } });
+  });
+
+  it("names that relation in relationSelect", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      project: true,
+    };
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.relationSelect).toEqual({ project: true });
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - relation key set to an object", () => {
+  it("keeps the caller's inner keys and adds _id", () => {
+    /*
+     * The object branch: the requested inner keys survive and `_id: true` is
+     * merged alongside them. Inner keys are never validated by sanitizeSelect -
+     * only top-level keys are checked against the model - so `name` here rides
+     * through untouched even on a model whose relation happens to expose it.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      onCallDutyPolicySchedule: { name: true },
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({
+      onCallDutyPolicySchedule: { name: true, _id: true },
+    });
+    expect(result.relationSelect).toEqual({ onCallDutyPolicySchedule: true });
+  });
+
+  it("forces _id back on even when the caller set it false", () => {
+    /*
+     * Precedence: `_id: true` is spread in AFTER the caller's object, so an
+     * explicit `_id: false` is overwritten rather than honoured. This is the
+     * security guarantee - a relation read cannot suppress the joined id.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      onCallDutyPolicySchedule: { _id: false },
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({
+      onCallDutyPolicySchedule: { _id: true },
+    });
+  });
+
+  it("leaves an already-correct id-only object idempotent", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      onCallDutyPolicySchedule: { _id: true },
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({
+      onCallDutyPolicySchedule: { _id: true },
+    });
+    expect(result.relationSelect).toEqual({ onCallDutyPolicySchedule: true });
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - non-relation keys", () => {
+  it("leaves scalar columns exactly as passed", () => {
+    /*
+     * projectId and _id are ObjectID columns, not Entity/EntityArray, so
+     * isEntityColumn is false and the branch is skipped entirely.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      projectId: true,
+      _id: true,
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({ projectId: true, _id: true });
+  });
+
+  it("never lists a scalar column in relationSelect", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      projectId: true,
+      _id: true,
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.relationSelect).toEqual({});
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - empty and mixed selects", () => {
+  it("returns empty shapes for an empty select", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {};
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({});
+    expect(result.relationSelect).toEqual({});
+  });
+
+  it("transforms relations and passes scalars through in one call", () => {
+    /*
+     * A realistic select: a scalar, a boolean relation, and an object relation
+     * together. Each key follows its own branch and the results coexist.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      projectId: true,
+      project: true,
+      onCallDutyPolicySchedule: { _id: false },
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({
+      projectId: true,
+      project: { _id: true },
+      onCallDutyPolicySchedule: { _id: true },
+    });
+    expect(result.relationSelect).toEqual({
+      project: true,
+      onCallDutyPolicySchedule: true,
+    });
+  });
+
+  it("lists exactly the relation keys, and only those, in relationSelect", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      projectId: true,
+      project: true,
+      onCallDutyPolicyScheduleId: true,
+      onCallDutyPolicySchedule: { _id: true },
+    } as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    const relationKeys: Array<string> = Object.keys(
+      result.relationSelect as Record<string, unknown>,
+    ).sort();
+
+    expect(relationKeys).toEqual(["onCallDutyPolicySchedule", "project"]);
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - object identity and mutation", () => {
+  it("mutates and returns the very select object it was handed", () => {
+    /*
+     * The returned `select` is the same reference, not a copy - callers rely on
+     * the input being rewritten in place.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      project: true,
+    };
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toBe(input);
+    expect((input as Record<string, unknown>)["project"]).toEqual({
+      _id: true,
+    });
+  });
+
+  it("builds relationSelect as a fresh object distinct from select", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      project: true,
+    };
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.relationSelect).not.toBe(result.select);
+    expect(result.relationSelect).not.toBe(input);
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - typeof edge cases on relation values", () => {
+  it("treats a null relation value as the object branch", () => {
+    /*
+     * `typeof null === "object"`, so null takes the object branch. Spreading
+     * null yields nothing, leaving `{ _id: true }` - the relation is still
+     * joined, not dropped.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      project: null,
+    } as unknown as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({ project: { _id: true } });
+    expect(result.relationSelect).toEqual({ project: true });
+  });
+
+  it("treats a numeric relation value as the non-object branch", () => {
+    /*
+     * `typeof 5 === "number"` takes the else branch; spreading a number adds no
+     * keys, so the result is the same id-only object as the boolean case.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      project: 5,
+    } as unknown as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    const result: SanitizeResult<OnCallDutyPolicyEscalationRuleSchedule> =
+      SelectUtil.sanitizeSelect(OnCallDutyPolicyEscalationRuleSchedule, input);
+
+    expect(result.select).toEqual({ project: { _id: true } });
+    expect(result.relationSelect).toEqual({ project: true });
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - EntityArray relations", () => {
+  it("handles a boolean EntityArray relation like any other relation", () => {
+    /*
+     * `labels` is an EntityArray column on Monitor. isEntityColumn returns true
+     * for both Entity and EntityArray, so the same collapse-to-id happens.
+     */
+    const input: Select<Monitor> = {
+      name: true,
+      labels: true,
+    } as Select<Monitor>;
+
+    const result: SanitizeResult<Monitor> = SelectUtil.sanitizeSelect(
+      Monitor,
+      input,
+    );
+
+    expect(result.select).toEqual({
+      name: true,
+      labels: { _id: true },
+    });
+    expect(result.relationSelect).toEqual({ labels: true });
+  });
+
+  it("merges _id into an object-valued EntityArray relation", () => {
+    const input: Select<Monitor> = {
+      dependsOnMonitors: { name: true },
+    } as Select<Monitor>;
+
+    const result: SanitizeResult<Monitor> = SelectUtil.sanitizeSelect(
+      Monitor,
+      input,
+    );
+
+    expect(result.select).toEqual({
+      dependsOnMonitors: { name: true, _id: true },
+    });
+    expect(result.relationSelect).toEqual({ dependsOnMonitors: true });
+  });
+});
+
+describe("SelectUtil.sanitizeSelect - unknown column error path", () => {
+  it("throws BadDataException for a key that is not a column on the model", () => {
+    /*
+     * isEntityColumn throws when a key has no column metadata, and
+     * sanitizeSelect checks every top-level key, so an unknown column fails the
+     * whole call. `name` is not a column on this model, which makes it the
+     * unknown-key case here.
+     */
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      name: true,
+    } as unknown as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    expect(() => {
+      return SelectUtil.sanitizeSelect(
+        OnCallDutyPolicyEscalationRuleSchedule,
+        input,
+      );
+    }).toThrow(BadDataException);
+  });
+
+  it("reports the offending column name in the error message", () => {
+    const input: Select<OnCallDutyPolicyEscalationRuleSchedule> = {
+      totallyMadeUpColumn: true,
+    } as unknown as Select<OnCallDutyPolicyEscalationRuleSchedule>;
+
+    expect(() => {
+      return SelectUtil.sanitizeSelect(
+        OnCallDutyPolicyEscalationRuleSchedule,
+        input,
+      );
+    }).toThrow("TableColumnMetadata not found for totallyMadeUpColumn column");
+  });
+});

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

@@ -41,4 +41,120 @@ describe("CronTab", () => {
       CronTab.getNextExecutionTime(crontab);
     }).toThrowError(`Invalid cron expression: ${crontab}`);
   });
+
+  /*
+   * getIntervalInSeconds answers "how long can a monitor go between checks",
+   * which is what over-time criteria use to tell a window that is genuinely
+   * all-breaching from one that has simply not filled up yet.
+   */
+  describe("getIntervalInSeconds", () => {
+    // Fixed so the walk over upcoming executions never touches the wall clock.
+    const referenceDate: Date = new Date("2026-08-20T12:00:00.000Z");
+
+    it("returns 60 seconds for an every-minute schedule", () => {
+      expect(CronTab.getIntervalInSeconds("* * * * *", referenceDate)).toBe(60);
+    });
+
+    it("returns 300 seconds for an every-five-minute schedule", () => {
+      expect(CronTab.getIntervalInSeconds("*/5 * * * *", referenceDate)).toBe(
+        300,
+      );
+    });
+
+    it("returns 3600 seconds for an hourly schedule", () => {
+      expect(CronTab.getIntervalInSeconds("0 * * * *", referenceDate)).toBe(
+        3600,
+      );
+    });
+
+    it("returns a day for a daily schedule", () => {
+      expect(CronTab.getIntervalInSeconds("0 0 * * *", referenceDate)).toBe(
+        24 * 60 * 60,
+      );
+    });
+
+    /*
+     * An irregular schedule has both short and long gaps. The longest one is
+     * what callers need: demanding data at the shortest cadence would make
+     * them wait for samples the schedule never produces.
+     */
+    it("reports the longest gap for an irregular schedule", () => {
+      // Fires at :00 :01 :30 - gaps of 1, 29 and 30 minutes.
+      expect(
+        CronTab.getIntervalInSeconds("0,1,30 * * * *", referenceDate),
+      ).toBe(30 * 60);
+    });
+
+    it("is unaffected by which point in the schedule it starts from", () => {
+      const fromMidCycle: number | null = CronTab.getIntervalInSeconds(
+        "*/5 * * * *",
+        new Date("2026-08-20T12:02:37.000Z"),
+      );
+
+      expect(fromMidCycle).toBe(300);
+    });
+
+    it("handles a schedule that wraps the hour", () => {
+      /*
+       * An every-seven-minute schedule fires at :00 :07 ... :56 and then
+       * :00 of the next hour, so the wrap gap is only four minutes - the
+       * seven minute gap still governs.
+       */
+      expect(CronTab.getIntervalInSeconds("*/7 * * * *", referenceDate)).toBe(
+        7 * 60,
+      );
+    });
+
+    /*
+     * Every preset the monitoring-interval picker offers, so a new one added
+     * to the dropdown without a matching gap here shows up as a failure
+     * rather than as silently unknown cadence.
+     */
+    it("resolves every interval the monitor picker offers", () => {
+      const presets: Record<string, number> = {
+        "* * * * *": 60,
+        "*/2 * * * *": 120,
+        "*/5 * * * *": 300,
+        "*/10 * * * *": 600,
+        "*/15 * * * *": 900,
+        "*/30 * * * *": 1800,
+        "0 * * * *": 3600,
+        "0 0 * * *": 24 * 60 * 60,
+        "0 0 * * 0": 7 * 24 * 60 * 60,
+      };
+
+      for (const expression of Object.keys(presets)) {
+        expect(CronTab.getIntervalInSeconds(expression, referenceDate)).toBe(
+          presets[expression],
+        );
+      }
+    });
+
+    /*
+     * monitoringInterval is free text and this repo's own Terraform examples
+     * write the human label, so the label form must degrade to "unknown"
+     * rather than throwing on the criteria hot path.
+     */
+    it("returns null for the human label form", () => {
+      expect(
+        CronTab.getIntervalInSeconds("Every 5 minutes", referenceDate),
+      ).toBeNull();
+    });
+
+    it("returns null for an unparseable expression", () => {
+      expect(
+        CronTab.getIntervalInSeconds("not-a-cron", referenceDate),
+      ).toBeNull();
+    });
+
+    it("returns null when no schedule is configured", () => {
+      expect(CronTab.getIntervalInSeconds(undefined)).toBeNull();
+      expect(CronTab.getIntervalInSeconds(null)).toBeNull();
+      expect(CronTab.getIntervalInSeconds("")).toBeNull();
+    });
+
+    it("falls back to the wall clock when no reference date is given", () => {
+      expect(CronTab.getIntervalInSeconds("*/5 * * * *")).toBe(300);
+    });
+  });
 });