@oneuptime/common 13.0.0 → 13.0.3

package/Tests/Types/OnCallDutyPolicy/OverrideProvenance.test.ts

@@ -0,0 +1,295 @@
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import ScheduleShiftUtil, {
+  OnCallShift,
+} from "../../../Types/OnCallDutyPolicy/ScheduleShiftUtil";
+import UserOverrideUtil, {
+  OverrideEventMeta,
+  UserOverrideRecord,
+} from "../../../Types/OnCallDutyPolicy/UserOverrideUtil";
+
+/*
+ * PROVENANCE: the two facts a screen needs before it can honestly describe a
+ * substitution, and which the engine used to drop on the floor.
+ *
+ * 1. WHICH override produced a segment - global, or scoped to one policy.
+ *    Without it a renderer can say "Bob is covering Alice" but not whether that
+ *    holds for the policy the reader actually cares about. A scoped override
+ *    re-routes exactly one policy's alerts; every OTHER policy escalating to
+ *    the same schedule still pages Alice. Presenting the two identically is the
+ *    difference between "you are covered" and "you are covered for one of your
+ *    four policies".
+ *
+ * 2. That an override window stays its OWN shift. The default grouping folds
+ *    consecutive segments of the same user together, and a shift inherits
+ *    metadata only from its first segment - so a substitute who is also on the
+ *    roster ends up with one merged block that either carries the wrong
+ *    override or none. https://github.com/OneUptime/oneuptime
+ */
+
+const POLICY_ID: string = "policy-database-oncall";
+
+function at(hours: number, minutes: number = 0): Date {
+  return new Date(2026, 0, 1, hours, minutes, 0, 0);
+}
+
+function event(
+  title: string,
+  startHour: number,
+  endHour: number,
+): CalendarEvent {
+  return {
+    id: 1,
+    title: title,
+    allDay: false,
+    start: at(startHour),
+    end: at(endHour),
+  };
+}
+
+function record(data: {
+  from: string;
+  to: string;
+  startHour: number;
+  endHour: number;
+  policyId?: string | null | undefined;
+}): UserOverrideRecord {
+  return {
+    overrideUserId: data.from,
+    routeAlertsToUserId: data.to,
+    startsAt: at(data.startHour),
+    endsAt: at(data.endHour),
+    onCallDutyPolicyId:
+      data.policyId === undefined ? null : (data.policyId as string | null),
+  };
+}
+
+function overriddenSegment(events: Array<CalendarEvent>): CalendarEvent {
+  const found: CalendarEvent | undefined = events.find(
+    (candidate: CalendarEvent) => {
+      return UserOverrideUtil.getOverrideMeta(candidate) !== null;
+    },
+  );
+
+  if (!found) {
+    throw new Error("expected at least one override segment");
+  }
+
+  return found;
+}
+
+describe("OverrideEventMeta carries the override's policy scope", () => {
+  test("a GLOBAL override stamps a null policy, not an absent key", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [record({ from: "A", to: "B", startHour: 9, endHour: 13 })],
+      });
+
+    const meta: OverrideEventMeta | null = UserOverrideUtil.getOverrideMeta(
+      overriddenSegment(events),
+    );
+
+    expect(meta).not.toBeNull();
+    /*
+     * Explicitly null rather than undefined so a consumer tests ONE value for
+     * "global". A key that is sometimes absent invites `meta.onCallDutyPolicyId
+     * === null` checks that silently fail for the undefined case and render the
+     * scoped wording for a global override.
+     */
+    expect(meta!.onCallDutyPolicyId).toBeNull();
+  });
+
+  test("a POLICY-SCOPED override stamps that policy's id", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [
+          record({
+            from: "A",
+            to: "B",
+            startHour: 9,
+            endHour: 13,
+            policyId: POLICY_ID,
+          }),
+        ],
+        currentOnCallDutyPolicyId: POLICY_ID,
+      });
+
+    const meta: OverrideEventMeta | null = UserOverrideUtil.getOverrideMeta(
+      overriddenSegment(events),
+    );
+
+    expect(meta!.onCallDutyPolicyId).toBe(POLICY_ID);
+  });
+
+  test("when a scoped and a global override compete, the meta names the one that actually won", () => {
+    /*
+     * applyOverridesToEvents sorts policy-scoped first so the scoped
+     * substitution claims the window. The stamped scope has to agree with that
+     * outcome: a segment routed by the scoped override that reported itself as
+     * global would tell the reader the swap covers every policy when it covers
+     * exactly one.
+     */
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [
+          record({ from: "A", to: "GLOBAL", startHour: 9, endHour: 13 }),
+          record({
+            from: "A",
+            to: "SCOPED",
+            startHour: 9,
+            endHour: 13,
+            policyId: POLICY_ID,
+          }),
+        ],
+        currentOnCallDutyPolicyId: POLICY_ID,
+      });
+
+    const segment: CalendarEvent = overriddenSegment(events);
+    expect(segment.title).toBe("SCOPED");
+    expect(UserOverrideUtil.getOverrideMeta(segment)!.onCallDutyPolicyId).toBe(
+      POLICY_ID,
+    );
+  });
+
+  test("the segments OUTSIDE the override window carry no meta at all", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [record({ from: "A", to: "B", startHour: 9, endHour: 13 })],
+      });
+
+    const untouched: Array<CalendarEvent> = events.filter(
+      (candidate: CalendarEvent) => {
+        return UserOverrideUtil.getOverrideMeta(candidate) === null;
+      },
+    );
+
+    // 08:00-09:00 and 13:00-14:00 are still plain A.
+    expect(untouched).toHaveLength(2);
+    for (const segment of untouched) {
+      expect(segment.title).toBe("A");
+    }
+  });
+});
+
+describe("ScheduleShiftUtil.groupKeyByUserAndOverride", () => {
+  test("keeps a substitute's own shift separate from the one they are covering", () => {
+    /*
+     * The regression this exists for. B is rostered 14:00-18:00 in their own
+     * right and is ALSO covering A from 12:00-14:00. The two segments touch and
+     * belong to the same user, so the default grouping merges them into one
+     * 12:00-18:00 block - and since a shift inherits metadata from its first
+     * segment only, the merged block claims to be four hours of cover when half
+     * of it is B's ordinary turn.
+     */
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14), { ...event("B", 14, 18), id: 2 }],
+        overrides: [record({ from: "A", to: "B", startHour: 12, endHour: 14 })],
+      });
+
+    const merged: Array<OnCallShift> =
+      ScheduleShiftUtil.groupEventsIntoShifts(events);
+    const split: Array<OnCallShift> = ScheduleShiftUtil.groupEventsIntoShifts(
+      events,
+      { groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride },
+    );
+
+    // The default grouping folds B's cover into B's own turn: one block.
+    const mergedB: Array<OnCallShift> = merged.filter((s: OnCallShift) => {
+      return s.userId === "B";
+    });
+    expect(mergedB).toHaveLength(1);
+    expect(mergedB[0]!.end).toEqual(at(18));
+
+    // The override-aware grouping keeps them apart.
+    const splitB: Array<OnCallShift> = split.filter((s: OnCallShift) => {
+      return s.userId === "B";
+    });
+    expect(splitB).toHaveLength(2);
+
+    const cover: OnCallShift = splitB[0]!;
+    const ownTurn: OnCallShift = splitB[1]!;
+
+    expect(cover.start).toEqual(at(12));
+    expect(cover.end).toEqual(at(14));
+    expect(cover.override).toBeDefined();
+    expect(cover.override!.originalUserId).toBe("A");
+
+    expect(ownTurn.start).toEqual(at(14));
+    expect(ownTurn.end).toEqual(at(18));
+    expect(ownTurn.override).toBeUndefined();
+  });
+
+  test("two consecutive windows covering DIFFERENT people stay two shifts", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 12), { ...event("C", 12, 16), id: 2 }],
+        overrides: [
+          record({ from: "A", to: "B", startHour: 8, endHour: 12 }),
+          record({ from: "C", to: "B", startHour: 12, endHour: 16 }),
+        ],
+      });
+
+    const shifts: Array<OnCallShift> = ScheduleShiftUtil.groupEventsIntoShifts(
+      events,
+      { groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride },
+    );
+
+    expect(shifts).toHaveLength(2);
+    expect(shifts[0]!.override!.originalUserId).toBe("A");
+    expect(shifts[1]!.override!.originalUserId).toBe("C");
+  });
+
+  test("an ordinary rotation is grouped exactly as the default key groups it", () => {
+    /*
+     * The new key must not fragment schedules that have no overrides at all -
+     * every "upcoming hand-offs" list in the dashboard is built from it, and a
+     * key that split on something invisible would show hand-offs that are not
+     * hand-offs.
+     */
+    const events: Array<CalendarEvent> = [
+      event("A", 8, 12),
+      { ...event("A", 12, 16), id: 2 },
+      { ...event("B", 16, 20), id: 3 },
+    ];
+
+    const withDefault: Array<OnCallShift> =
+      ScheduleShiftUtil.groupEventsIntoShifts(events);
+    const withOverrideKey: Array<OnCallShift> =
+      ScheduleShiftUtil.groupEventsIntoShifts(events, {
+        groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride,
+      });
+
+    expect(withOverrideKey).toEqual(withDefault);
+    expect(withOverrideKey).toHaveLength(2);
+  });
+
+  test("one override spanning a rotation boundary stays a single shift", () => {
+    /*
+     * Unlike groupKeyByUserOverrideAndLayer, this key deliberately ignores the
+     * rotation period: a person covering across a hand-over is doing one
+     * continuous stretch of cover, and splitting it would invent a hand-off the
+     * reader cannot act on.
+     */
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 12), { ...event("C", 12, 16), id: 2 }],
+        overrides: [record({ from: "A", to: "B", startHour: 8, endHour: 12 })],
+      });
+
+    const shifts: Array<OnCallShift> = ScheduleShiftUtil.groupEventsIntoShifts(
+      events,
+      { groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride },
+    );
+
+    const bShifts: Array<OnCallShift> = shifts.filter((s: OnCallShift) => {
+      return s.userId === "B";
+    });
+    expect(bShifts).toHaveLength(1);
+    expect(bShifts[0]!.start).toEqual(at(8));
+    expect(bShifts[0]!.end).toEqual(at(12));
+  });
+});

package/Tests/Types/Rum/SessionReplayApiContracts.test.ts

@@ -10,6 +10,7 @@ import {
   SessionReplayExceptionSessionDto,
   SessionReplayForExceptionResponseDto,
   SessionReplayHeartbeatResponseDto,
+  SessionReplayListFiltersDto,
   SessionReplayListItemDto,
   SessionReplayListRequestDto,
   SessionReplayListResponseDto,
@@ -17,6 +18,11 @@ import {
   SessionReplayManifestRequestDto,
   SessionReplayManifestResponseDto,
   SessionReplayManifestTabDto,
+  SessionReplayUserKind,
+  SessionReplayUserRollupDto,
+  SessionReplayUsersCursorDto,
+  SessionReplayUsersRequestDto,
+  SessionReplayUsersResponseDto,
   SessionReplayViewDto,
   SessionReplayViewsRequestDto,
   SessionReplayViewsResponseDto,
@@ -32,7 +38,10 @@ import {
   readDtoStringMap,
   readDtoUnixMs,
 } from "../../../Types/Rum/SessionReplayApi";
-import { SessionReplayChunkManifestEntry } from "../../../Types/Rum/SessionReplay";
+import {
+  SESSION_REPLAY_VISITOR_ID_PATTERN,
+  SessionReplayChunkManifestEntry,
+} from "../../../Types/Rum/SessionReplay";
 
 /*
  * The DTOs are the wire between the Dashboard and TelemetryAPI's
@@ -54,6 +63,9 @@ import { SessionReplayChunkManifestEntry } from "../../../Types/Rum/SessionRepla
 const START_ISO: string = "2026-09-04T10:00:00.000Z";
 const END_ISO: string = "2026-09-04T10:04:12.000Z";
 
+/* A visitor id as the recorder mints it: 32 lowercase hex characters. */
+const VISITOR_ID: string = "0123456789abcdef0123456789abcdef";
+
 /* One row of /list as listSessions builds it, serialised. */
 const legacyListItem: SessionReplayListItemDto = {
   sessionId: "sess-1",
@@ -357,6 +369,173 @@ describe("SessionReplayApi - the additive contracts the surfaces already ship",
     expect(withNoneIgnored.ignoredFilters).not.toBeUndefined();
   });
 
+  /*
+   * The recorder-minted per-browser visitor id: an exact-match list filter
+   * ("every session from this browser") and a projection on every row.
+   * Neither is identity-gated - it is a random token the list already
+   * returns to every caller - and both are additive: an older server
+   * answers rows without it, which parse as "not measured".
+   */
+  it("/list: filters.visitorId and the visitorId projection are additive and shaped like the recorder mints them", () => {
+    expect(legacyListItem.visitorId).toBeUndefined();
+
+    const filters: SessionReplayListFiltersDto = { visitorId: VISITOR_ID };
+    const request: SessionReplayListRequestDto = {
+      rumApplicationId: "app-1",
+      filters: filters,
+    };
+
+    const withVisitor: SessionReplayListItemDto = {
+      ...legacyListItem,
+      visitorId: VISITOR_ID,
+    };
+    /* An older recorder's session: "", so the table has one branch. */
+    const fromOlderRecorder: SessionReplayListItemDto = {
+      ...legacyListItem,
+      visitorId: "",
+    };
+
+    expect(request.filters?.visitorId).toMatch(
+      SESSION_REPLAY_VISITOR_ID_PATTERN,
+    );
+    expect(withVisitor.visitorId).toBe(VISITOR_ID);
+    expect(fromOlderRecorder.visitorId).toBe("");
+  });
+
+  /*
+   * The manifest header carries the pseudonymous digest and the visitor
+   * id so the player can ask /list for this person's other sessions.
+   * Both are additive, and both are present WITHOUT the identity pair:
+   * neither names anyone, so neither is gated.
+   */
+  it("/manifest: identifiedUserKey and visitorId on the header are additive and independent of the identity pair", () => {
+    expect(legacyHeader.identifiedUserKey).toBeUndefined();
+    expect(legacyHeader.visitorId).toBeUndefined();
+
+    const withKeys: SessionReplayManifestHeaderDto = {
+      ...legacyHeader,
+      identifiedUserKey: "hmac-1",
+      visitorId: VISITOR_ID,
+    };
+    const neverIdentified: SessionReplayManifestHeaderDto = {
+      ...legacyHeader,
+      identifiedUserKey: "",
+      visitorId: "",
+    };
+
+    expect(withKeys.identifiedUserKey).toBe("hmac-1");
+    expect(withKeys.visitorId).toBe(VISITOR_ID);
+    expect(withKeys.identifiedUserLabel).toBeUndefined();
+    expect(withKeys.identifiedUserTraits).toBeUndefined();
+    expect(neverIdentified.identifiedUserKey).toBe("");
+    expect(neverIdentified.visitorId).toBe("");
+  });
+
+  /*
+   * POST /telemetry/rum/session-replay/users: the list rolled up by
+   * person. Its own route because a keyset page of sessions cannot be
+   * grouped client-side without lying at the page boundary. One row per
+   * identified user, one per linked browser, and at most one anonymous
+   * bucket whose key is "" - a row like any other, and a valid cursor
+   * tiebreak.
+   */
+  it("/users: the request is the list's window plus its own cursor, the response is one row per person with the identity pair gated", () => {
+    const cursor: SessionReplayUsersCursorDto = {
+      lastSeenUnixMs: Date.parse(END_ISO),
+      groupKey: "u:hmac-1",
+    };
+    const request: SessionReplayUsersRequestDto = {
+      rumApplicationId: "app-1",
+      startTime: START_ISO,
+      endTime: END_ISO,
+      limit: 50,
+      cursor: cursor,
+    };
+    const minimalRequest: SessionReplayUsersRequestDto = {
+      rumApplicationId: "app-1",
+    };
+
+    const identified: SessionReplayUserRollupDto = {
+      groupKey: "u:hmac-1",
+      kind: "identified",
+      identifiedUserKey: "hmac-1",
+      visitorId: VISITOR_ID,
+      sessionCount: 3,
+      liveSessionCount: 1,
+      firstSeenUnixMs: Date.parse(START_ISO),
+      lastSeenUnixMs: Date.parse(END_ISO),
+      totalDurationMs: 180000,
+      errorCount: 2,
+      frustrationCount: 4,
+      errorSessionCount: 1,
+      pageCount: 9,
+      lastSessionId: "sess-3",
+      lastEntryUrl: "https://acme.com/checkout",
+      browserName: "Chrome",
+      browserVersion: "128",
+      osName: "macOS",
+      deviceType: "desktop",
+      countryCode: "US",
+    };
+    const withLabel: SessionReplayUserRollupDto = {
+      ...identified,
+      identifiedUserLabel: "jane@acme.com",
+      identifiedUserTraits: { plan: "pro" },
+    };
+    const visitor: SessionReplayUserRollupDto = {
+      ...identified,
+      groupKey: `v:${VISITOR_ID}`,
+      kind: "visitor",
+      identifiedUserKey: "",
+    };
+    const anonymous: SessionReplayUserRollupDto = {
+      ...identified,
+      groupKey: "",
+      kind: "anonymous",
+      identifiedUserKey: "",
+      visitorId: "",
+    };
+
+    const page: SessionReplayUsersResponseDto = {
+      users: [withLabel, visitor, anonymous],
+      nextCursor: { lastSeenUnixMs: Date.parse(START_ISO), groupKey: "" },
+    };
+    const lastPage: SessionReplayUsersResponseDto = {
+      users: [identified],
+      nextCursor: null,
+    };
+
+    const kinds: Array<SessionReplayUserKind> = page.users.map(
+      (user: SessionReplayUserRollupDto): SessionReplayUserKind => {
+        return user.kind;
+      },
+    );
+
+    expect(kinds).toEqual(["identified", "visitor", "anonymous"]);
+    expect(request.cursor?.groupKey).toBe("u:hmac-1");
+    expect(minimalRequest.cursor).toBeUndefined();
+    expect(minimalRequest.limit).toBeUndefined();
+
+    /* The identity pair is absent unless the caller may read it. */
+    expect(identified.identifiedUserLabel).toBeUndefined();
+    expect(identified.identifiedUserTraits).toBeUndefined();
+    expect(withLabel.identifiedUserTraits?.["plan"]).toBe("pro");
+
+    /* The digest is "" unless identified; the visitor id may be "" too. */
+    expect(visitor.identifiedUserKey).toBe("");
+    expect(visitor.visitorId).toBe(VISITOR_ID);
+    expect(anonymous.visitorId).toBe("");
+
+    /* The bucket's own key is "", and it can be the cursor tiebreak. */
+    expect(anonymous.groupKey).toBe("");
+    expect(page.nextCursor?.groupKey).toBe("");
+    expect(lastPage.nextCursor).toBeNull();
+
+    /* Prefixes are opaque to the client: the row key and nothing more. */
+    expect(visitor.groupKey.startsWith("v:")).toBe(true);
+    expect(identified.groupKey.startsWith("u:")).toBe(true);
+  });
+
   /*
    * POST /telemetry/rum/session-replay/views: "who watched this
    * recording", off the audit rows every manifest read has written.

package/Tests/Types/Runner/RunnerLiveStatus.test.ts

@@ -225,8 +225,8 @@ describe("getRunnerLiveStatusLabel", () => {
 
   /*
    * "Connected" and "Disconnected" are pre-existing i18next keys, translated
-   * in all sixteen locale files for the probe pages. Changing the casing or
-   * wording here would silently drop fifteen translations back to English.
+   * in all seventeen locale files for the probe pages. Changing the casing or
+   * wording here would silently drop sixteen translations back to English.
    */
   test("it reuses the exact pre-existing locale keys", () => {
     expect(getRunnerLiveStatusLabel(RunnerLiveStatus.Connected)).not.toBe(