@oneuptime/common 12.0.29 → 12.0.30

package/build/dist/Server/Utils/OnCall/OnCallShiftMaterializer.js

@@ -0,0 +1,752 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import crypto from "crypto";
+import OnCallDutyPolicyScheduleService from "../../Services/OnCallDutyPolicyScheduleService";
+import OnCallDutyPolicyScheduleLayerUserService from "../../Services/OnCallDutyPolicyScheduleLayerUserService";
+import OnCallDutyPolicyUserOverrideService from "../../Services/OnCallDutyPolicyUserOverrideService";
+import ProjectService from "../../Services/ProjectService";
+import UserService from "../../Services/UserService";
+import QueryHelper from "../../Types/Database/QueryHelper";
+import CaptureSpan from "../Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+import OneUptimeDate from "../../../Types/Date";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { FEED_SIMULATION_ITERATION_CAP } from "../../../Types/OnCallDutyPolicy/CalendarFeedWindow";
+import MaterializedShiftUtil from "../../../Types/OnCallDutyPolicy/MaterializedShift";
+import OnCallCalendarFeedUtil from "../../../Types/OnCallDutyPolicy/OnCallCalendarFeedUtil";
+import ScheduleShiftUtil from "../../../Types/OnCallDutyPolicy/ScheduleShiftUtil";
+import ShiftSeamUtil from "../../../Types/OnCallDutyPolicy/ShiftSeamUtil";
+export default class OnCallShiftMaterializer {
+    // -- Entry points -----------------------------------------------------
+    static async materializeForSchedule(options) {
+        return await OnCallShiftMaterializer.materializeForSchedules({
+            scheduleIds: [options.scheduleId],
+            windowStart: options.windowStart,
+            windowEnd: options.windowEnd,
+            now: options.now,
+            maxSimulationIterations: options.maxSimulationIterations,
+        });
+    }
+    static async materializeForSchedules(options) {
+        var _a;
+        OnCallShiftMaterializer.validateWindow(options.windowStart, options.windowEnd);
+        const now = options.now || OneUptimeDate.getCurrentDate();
+        const scheduleIds = OnCallShiftMaterializer.dedupeIds(options.scheduleIds);
+        if (scheduleIds.length === 0) {
+            return OnCallShiftMaterializer.emptyResult(now);
+        }
+        const resolved = await OnCallDutyPolicyScheduleService.getResolvedShiftSegmentsForSchedules({
+            scheduleIds,
+            windowStart: options.windowStart,
+            windowEnd: options.windowEnd,
+            maxSimulationIterations: (_a = options.maxSimulationIterations) !== null && _a !== void 0 ? _a : FEED_SIMULATION_ITERATION_CAP,
+        });
+        if (resolved.length === 0) {
+            return OnCallShiftMaterializer.emptyResult(now);
+        }
+        const users = await OnCallShiftMaterializer.loadUsers(OnCallShiftMaterializer.collectUserIds(resolved));
+        const projectNames = await OnCallShiftMaterializer.loadProjectNames(resolved.map((item) => {
+            return item.schedule.projectId;
+        }));
+        const shifts = [];
+        const schedules = [];
+        let truncated = false;
+        for (const item of resolved) {
+            const projectName = projectNames.get(item.schedule.projectId);
+            shifts.push(...OnCallShiftMaterializer.materializeResolved(item, {
+                now,
+                users,
+                projectName,
+            }));
+            const info = {
+                scheduleId: item.schedule.id,
+                scheduleName: item.schedule.name,
+                projectId: item.schedule.projectId,
+                shiftConfigVersion: item.schedule.shiftConfigVersion,
+                lastModifiedAt: item.lastModifiedAt,
+                truncated: item.truncated,
+                attachedPolicies: item.attachedPolicies,
+                layerProps: item.layerProps,
+                scheduleUserIds: item.scheduleUserIds,
+            };
+            if (projectName !== undefined) {
+                info.projectName = projectName;
+            }
+            if (item.schedule.timezone !== undefined) {
+                info.scheduleTimezone = item.schedule.timezone;
+            }
+            schedules.push(info);
+            truncated = truncated || item.truncated;
+        }
+        return {
+            shifts: MaterializedShiftUtil.sortByStart(shifts),
+            truncated,
+            schedules,
+            users: Array.from(users.values()),
+            generatedAt: now,
+        };
+    }
+    static async materializeForUser(options) {
+        OnCallShiftMaterializer.validateWindow(options.windowStart, options.windowEnd);
+        const now = options.now || OneUptimeDate.getCurrentDate();
+        const candidateScheduleIds = await OnCallShiftMaterializer.getCandidateScheduleIdsForUser({
+            userId: options.userId,
+            projectIds: options.projectIds,
+            scheduleId: options.scheduleId,
+            windowStart: options.windowStart,
+            windowEnd: options.windowEnd,
+            includeCoveringShifts: options.includeCoveringShifts,
+        });
+        if (candidateScheduleIds.length === 0) {
+            return OnCallShiftMaterializer.emptyResult(now);
+        }
+        const result = await OnCallShiftMaterializer.materializeForSchedules({
+            scheduleIds: candidateScheduleIds,
+            windowStart: options.windowStart,
+            windowEnd: options.windowEnd,
+            now,
+            maxSimulationIterations: options.maxSimulationIterations,
+        });
+        return Object.assign(Object.assign({}, result), { shifts: OnCallShiftMaterializer.filterShiftsForUser(result.shifts, options.userId) });
+    }
+    static async materializeForProject(options) {
+        OnCallShiftMaterializer.validateWindow(options.windowStart, options.windowEnd);
+        const now = options.now || OneUptimeDate.getCurrentDate();
+        const schedules = await OnCallDutyPolicyScheduleService.findBy({
+            query: {
+                projectId: options.projectId,
+            },
+            select: {
+                _id: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const scheduleIds = schedules
+            .map((schedule) => {
+            return schedule.id;
+        })
+            .filter((id) => {
+            return Boolean(id);
+        });
+        if (scheduleIds.length === 0) {
+            return OnCallShiftMaterializer.emptyResult(now);
+        }
+        return await OnCallShiftMaterializer.materializeForSchedules({
+            scheduleIds,
+            windowStart: options.windowStart,
+            windowEnd: options.windowEnd,
+            now,
+            maxSimulationIterations: options.maxSimulationIterations,
+        });
+    }
+    // -- Candidate schedules ----------------------------------------------
+    /**
+     * The schedules whose materialization can contain the user's shifts:
+     * distinct schedule ids from the user's layer-user rows (optionally within
+     * `projectIds`), plus — when includeCoveringShifts — the schedules of every
+     * user the caller substitutes for through an override overlapping the
+     * window. Optionally narrowed to one schedule. Root reads: the caller has
+     * already decided the user may see these.
+     *
+     * One user, 2-3 queries. Anything that needs this for a GROUP of users
+     * (the reminder sweep and its change pass walk every reminded user of a
+     * project on every tick) must call getCandidateScheduleIdsForUsers, which
+     * answers the whole group in the same 2-3 queries.
+     */
+    static async getCandidateScheduleIdsForUser(data) {
+        const byUser = await OnCallShiftMaterializer.getCandidateScheduleIdsForUsers({
+            userIds: [data.userId],
+            projectIds: data.projectIds,
+            scheduleId: data.scheduleId,
+            windowStart: data.windowStart,
+            windowEnd: data.windowEnd,
+            includeCoveringShifts: data.includeCoveringShifts,
+        });
+        return byUser.get(data.userId.toString()) || [];
+    }
+    /**
+     * The batched form of getCandidateScheduleIdsForUser: the candidate
+     * schedules of MANY users in the same two or three queries it takes for
+     * one, keyed by user id (every requested user gets an entry, empty when
+     * they are on nothing). Semantics per user are identical — own layer-user
+     * rows, plus the schedules of the people that user substitutes for through
+     * an override overlapping the window, narrowed to `scheduleId` when given.
+     *
+     * The covering overrides are matched back to the SUBSTITUTE that each one
+     * routes to, so one user's coverage never leaks into another's list.
+     */
+    static async getCandidateScheduleIdsForUsers(data) {
+        var _a, _b, _c, _d, _e, _f;
+        const userIds = OnCallShiftMaterializer.dedupeIds(data.userIds);
+        const candidatesByUser = new Map();
+        for (const userId of userIds) {
+            candidatesByUser.set(userId.toString(), []);
+        }
+        if (userIds.length === 0) {
+            return candidatesByUser;
+        }
+        const projectFilter = data.projectIds && data.projectIds.length > 0
+            ? OnCallShiftMaterializer.dedupeIds(data.projectIds)
+            : undefined;
+        const ownRows = await OnCallDutyPolicyScheduleLayerUserService.findBy({
+            query: projectFilter
+                ? {
+                    userId: QueryHelper.any(userIds),
+                    projectId: QueryHelper.any(projectFilter),
+                }
+                : {
+                    userId: QueryHelper.any(userIds),
+                },
+            select: {
+                onCallDutyPolicyScheduleId: true,
+                projectId: true,
+                userId: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const row of ownRows) {
+            const userKey = ((_a = row.userId) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+            const candidates = candidatesByUser.get(userKey);
+            if (!candidates || !row.onCallDutyPolicyScheduleId) {
+                continue;
+            }
+            candidates.push(row.onCallDutyPolicyScheduleId);
+        }
+        if (data.includeCoveringShifts) {
+            const coveringOverrides = await OnCallDutyPolicyUserOverrideService.findBy({
+                query: projectFilter
+                    ? {
+                        routeAlertsToUserId: QueryHelper.any(userIds),
+                        projectId: QueryHelper.any(projectFilter),
+                        startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
+                        endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+                    }
+                    : {
+                        routeAlertsToUserId: QueryHelper.any(userIds),
+                        startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
+                        endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+                    },
+                select: {
+                    projectId: true,
+                    overrideUserId: true,
+                    routeAlertsToUserId: true,
+                    startsAt: true,
+                    endsAt: true,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            // substitute -> the (project, overridden user) pairs THEY cover.
+            const pairsByUser = new Map();
+            const overriddenUserIds = [];
+            const overrideProjectIds = [];
+            for (const override of coveringOverrides) {
+                const overriddenUserId = override.overrideUserId;
+                const projectId = override.projectId;
+                const substituteKey = ((_b = override.routeAlertsToUserId) === null || _b === void 0 ? void 0 : _b.toString()) || "";
+                if (!overriddenUserId ||
+                    !projectId ||
+                    !candidatesByUser.has(substituteKey)) {
+                    continue;
+                }
+                if (override.startsAt &&
+                    override.endsAt &&
+                    (OneUptimeDate.isAfter(override.startsAt, data.windowEnd) ||
+                        OneUptimeDate.isBefore(override.endsAt, data.windowStart))) {
+                    continue;
+                }
+                let pairs = pairsByUser.get(substituteKey);
+                if (!pairs) {
+                    pairs = new Set();
+                    pairsByUser.set(substituteKey, pairs);
+                }
+                pairs.add(`${projectId.toString()}:${overriddenUserId.toString()}`);
+                overriddenUserIds.push(overriddenUserId);
+                overrideProjectIds.push(projectId);
+            }
+            if (pairsByUser.size > 0) {
+                const coveredRows = await OnCallDutyPolicyScheduleLayerUserService.findBy({
+                    query: {
+                        userId: QueryHelper.any(OnCallShiftMaterializer.dedupeIds(overriddenUserIds)),
+                        projectId: QueryHelper.any(OnCallShiftMaterializer.dedupeIds(overrideProjectIds)),
+                    },
+                    select: {
+                        onCallDutyPolicyScheduleId: true,
+                        projectId: true,
+                        userId: true,
+                    },
+                    limit: LIMIT_PER_PROJECT,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                for (const row of coveredRows) {
+                    const key = `${((_c = row.projectId) === null || _c === void 0 ? void 0 : _c.toString()) || ""}:${((_d = row.userId) === null || _d === void 0 ? void 0 : _d.toString()) || ""}`;
+                    if (!row.onCallDutyPolicyScheduleId) {
+                        continue;
+                    }
+                    for (const [substituteKey, pairs] of pairsByUser) {
+                        if (pairs.has(key)) {
+                            (_e = candidatesByUser
+                                .get(substituteKey)) === null || _e === void 0 ? void 0 : _e.push(row.onCallDutyPolicyScheduleId);
+                        }
+                    }
+                }
+            }
+        }
+        const wanted = (_f = data.scheduleId) === null || _f === void 0 ? void 0 : _f.toString();
+        for (const [userKey, candidates] of candidatesByUser) {
+            let deduped = OnCallShiftMaterializer.dedupeIds(candidates);
+            if (wanted) {
+                deduped = deduped.filter((id) => {
+                    return id.toString() === wanted;
+                });
+            }
+            candidatesByUser.set(userKey, deduped);
+        }
+        return candidatesByUser;
+    }
+    // -- Pure materialization ---------------------------------------------
+    /**
+     * Materialize ONE resolved schedule: base shifts plus policy-variant
+     * shifts. Pure — every lookup has already happened.
+     */
+    static materializeResolved(resolved, options) {
+        const baseShifts = OnCallShiftMaterializer.toShifts(resolved.segments);
+        const shifts = baseShifts.map((shift) => {
+            return OnCallShiftMaterializer.toMaterializedShift({
+                shift,
+                resolved,
+                options,
+                policyVariant: null,
+            });
+        });
+        for (const variant of resolved.policyVariants) {
+            const variantShifts = OnCallShiftMaterializer.toShifts(variant.segments);
+            const differing = OnCallShiftMaterializer.diffPolicyVariant(baseShifts, variantShifts);
+            for (const entry of differing) {
+                shifts.push(OnCallShiftMaterializer.toMaterializedShift({
+                    shift: entry.shift,
+                    resolved,
+                    options,
+                    policyVariant: {
+                        policyId: variant.policyId,
+                        policyName: variant.policyName,
+                        globalUserId: entry.globalUserId,
+                    },
+                }));
+            }
+        }
+        return MaterializedShiftUtil.sortByStart(shifts);
+    }
+    /*
+     * Group + seam-normalise raw segments into shifts. Exposed so tests and
+     * the coverage-gap logic can reproduce exactly what the feed sees.
+     */
+    static toShifts(segments) {
+        const grouped = ScheduleShiftUtil.groupEventsIntoShifts(segments, {
+            mergeAcrossGaps: false,
+            groupKey: ScheduleShiftUtil.groupKeyByUserOverrideAndLayer,
+        });
+        /*
+         * Seam normalisation widens a shift by the engine's one-second seams;
+         * with mergeAcrossGaps = false every shift is one contiguous block, so
+         * its honest active time is exactly its span. Recompute rather than
+         * carry the pre-normalisation sum, which would read 28799 for an 8-hour
+         * block.
+         */
+        return ShiftSeamUtil.normalizeSeams(grouped)
+            .filter((shift) => {
+            return shift.end.getTime() > shift.start.getTime();
+        })
+            .map((shift) => {
+            return Object.assign(Object.assign({}, shift), { coverageSeconds: Math.round((shift.end.getTime() - shift.start.getTime()) / 1000) });
+        });
+    }
+    /*
+     * The variant shifts during which a DIFFERENT person is paged than in the
+     * base resolution. A variant shift whose whole span is covered by base
+     * shifts of the same user is identical for the subscriber and dropped; one
+     * that overlaps a base shift of another user (or no base shift at all) is
+     * kept, together with who the base resolution pages at its start.
+     */
+    static diffPolicyVariant(baseShifts, variantShifts) {
+        var _a;
+        const result = [];
+        for (const variant of variantShifts) {
+            const overlapping = baseShifts.filter((base) => {
+                return (base.start.getTime() < variant.end.getTime() &&
+                    base.end.getTime() > variant.start.getTime());
+            });
+            const differingBase = overlapping.find((base) => {
+                return base.userId !== variant.userId;
+            });
+            if (overlapping.length > 0 && !differingBase) {
+                continue; // same person throughout: nothing policy-specific here.
+            }
+            const globalUserId = (differingBase === null || differingBase === void 0 ? void 0 : differingBase.userId) ||
+                ((_a = variant.override) === null || _a === void 0 ? void 0 : _a.originalUserId) ||
+                variant.userId;
+            result.push({ shift: variant, globalUserId });
+        }
+        return result;
+    }
+    /** Keep only the shifts where `userId` is the person on call. */
+    static filterShiftsForUser(shifts, userId) {
+        const wanted = userId.toString();
+        return shifts.filter((shift) => {
+            return shift.userId === wanted;
+        });
+    }
+    /*
+     * sha256 over every field that changes what a subscriber sees for this
+     * shift, excluding the identity (shiftKey), the version and the
+     * modification stamp, so two renders of an unchanged shift hash the same
+     * and any content change — the person, the end, the layer, the policies,
+     * the override provenance — changes the hash.
+     */
+    static computeContentHash(shift) {
+        var _a, _b, _c, _d, _e;
+        const payload = {
+            scheduleId: shift.scheduleId,
+            scheduleName: shift.scheduleName,
+            scheduleTimezone: (_a = shift.scheduleTimezone) !== null && _a !== void 0 ? _a : null,
+            projectName: (_b = shift.projectName) !== null && _b !== void 0 ? _b : null,
+            userId: shift.userId,
+            userName: shift.userName,
+            start: shift.start.toISOString(),
+            end: shift.end.toISOString(),
+            coverageSeconds: shift.coverageSeconds,
+            layerId: (_c = shift.layerId) !== null && _c !== void 0 ? _c : null,
+            layerName: (_d = shift.layerName) !== null && _d !== void 0 ? _d : null,
+            override: shift.override
+                ? {
+                    originalUserId: shift.override.originalUserId,
+                    originalUserName: shift.override.originalUserName,
+                    overrideStartsAt: shift.override.overrideStartsAt.toISOString(),
+                    overrideEndsAt: shift.override.overrideEndsAt.toISOString(),
+                    onCallDutyPolicyId: (_e = shift.override.onCallDutyPolicyId) !== null && _e !== void 0 ? _e : null,
+                }
+                : null,
+            policyVariantOf: shift.policyVariantOf
+                ? {
+                    policyId: shift.policyVariantOf.policyId,
+                    policyName: shift.policyVariantOf.policyName,
+                    globalUserId: shift.policyVariantOf.globalUserId,
+                }
+                : null,
+            policies: shift.policies.map((policy) => {
+                return {
+                    policyId: policy.policyId,
+                    policyName: policy.policyName,
+                    ruleId: policy.ruleId,
+                    ruleName: policy.ruleName,
+                    ruleOrder: policy.ruleOrder,
+                };
+            }),
+        };
+        return crypto
+            .createHash("sha256")
+            .update(JSON.stringify(payload), "utf8")
+            .digest("hex");
+    }
+    // -- Internals ---------------------------------------------------------
+    static toMaterializedShift(data) {
+        var _a, _b;
+        const { shift, resolved, options } = data;
+        const base = {
+            projectId: resolved.schedule.projectId,
+            scheduleId: resolved.schedule.id,
+            scheduleName: resolved.schedule.name,
+            userId: shift.userId,
+            userName: OnCallShiftMaterializer.displayName(options.users, shift.userId),
+            start: shift.start,
+            end: shift.end,
+            coverageSeconds: shift.coverageSeconds,
+            policies: resolved.attachedPolicies.map((policy) => {
+                return Object.assign({}, policy);
+            }),
+            isPast: shift.start.getTime() < options.now.getTime(),
+        };
+        if (options.projectName !== undefined) {
+            base.projectName = options.projectName;
+        }
+        if (resolved.schedule.timezone !== undefined) {
+            base.scheduleTimezone = resolved.schedule.timezone;
+        }
+        if (shift.layerId !== undefined) {
+            base.layerId = shift.layerId;
+        }
+        if (shift.layerName !== undefined) {
+            base.layerName = shift.layerName;
+        }
+        if (shift.override) {
+            const override = {
+                originalUserId: shift.override.originalUserId,
+                originalUserName: OnCallShiftMaterializer.displayName(options.users, shift.override.originalUserId),
+                overrideStartsAt: new Date(shift.override.overrideStartsAt.getTime()),
+                overrideEndsAt: new Date(shift.override.overrideEndsAt.getTime()),
+            };
+            const policyId = OnCallShiftMaterializer.findOverridePolicyId(resolved.overrides, {
+                originalUserId: shift.override.originalUserId,
+                substituteUserId: shift.userId,
+                startsAt: shift.override.overrideStartsAt,
+                endsAt: shift.override.overrideEndsAt,
+                preferredPolicyId: (_a = data.policyVariant) === null || _a === void 0 ? void 0 : _a.policyId,
+            });
+            if (policyId) {
+                override.onCallDutyPolicyId = policyId;
+            }
+            base.override = override;
+        }
+        if (data.policyVariant) {
+            base.policyVariantOf = {
+                policyId: data.policyVariant.policyId,
+                policyName: data.policyVariant.policyName,
+                globalUserId: data.policyVariant.globalUserId,
+            };
+        }
+        return Object.assign(Object.assign({}, base), { shiftKey: MaterializedShiftUtil.buildShiftKey({
+                scheduleId: resolved.schedule.id,
+                start: shift.start,
+                policyId: (_b = data.policyVariant) === null || _b === void 0 ? void 0 : _b.policyId,
+            }), contentHash: OnCallShiftMaterializer.computeContentHash(base), lastModifiedAt: resolved.lastModifiedAt, shiftConfigVersion: resolved.schedule.shiftConfigVersion });
+    }
+    /*
+     * Map a segment's override meta back to the override record that produced
+     * it, to learn its policy scope. Prefers a record scoped to
+     * `preferredPolicyId` (the variant being materialized); falls back to any
+     * record with the same users and window.
+     */
+    static findOverridePolicyId(overrides, data) {
+        const matches = overrides.filter((record) => {
+            return (record.overrideUserId === data.originalUserId &&
+                record.routeAlertsToUserId === data.substituteUserId &&
+                record.startsAt.getTime() === data.startsAt.getTime() &&
+                record.endsAt.getTime() === data.endsAt.getTime());
+        });
+        if (matches.length === 0) {
+            return null;
+        }
+        if (data.preferredPolicyId) {
+            const preferred = matches.find((record) => {
+                return record.onCallDutyPolicyId === data.preferredPolicyId;
+            });
+            if (preferred) {
+                return preferred.onCallDutyPolicyId || null;
+            }
+        }
+        // A global match wins over a scoped one for the base resolution.
+        const global = matches.find((record) => {
+            return !record.onCallDutyPolicyId;
+        });
+        if (global) {
+            return null;
+        }
+        return matches[0].onCallDutyPolicyId || null;
+    }
+    static displayName(users, userId) {
+        var _a;
+        return (((_a = users.get(userId)) === null || _a === void 0 ? void 0 : _a.userName) || OnCallCalendarFeedUtil.FALLBACK_USER_NAME);
+    }
+    static collectUserIds(resolved) {
+        const ids = new Set();
+        for (const item of resolved) {
+            for (const segment of item.segments) {
+                if (segment.title) {
+                    ids.add(segment.title);
+                }
+            }
+            for (const variant of item.policyVariants) {
+                for (const segment of variant.segments) {
+                    if (segment.title) {
+                        ids.add(segment.title);
+                    }
+                }
+            }
+            for (const override of item.overrides) {
+                if (override.overrideUserId) {
+                    ids.add(override.overrideUserId);
+                }
+                if (override.routeAlertsToUserId) {
+                    ids.add(override.routeAlertsToUserId);
+                }
+            }
+            for (const userId of item.scheduleUserIds) {
+                ids.add(userId);
+            }
+        }
+        return Array.from(ids);
+    }
+    /*
+     * One root user lookup for names and timezones. Name falls back to email;
+     * the feed mapper masks emails where they must not appear (shared feeds).
+     */
+    static async loadUsers(userIds) {
+        var _a, _b, _c, _d;
+        const users = new Map();
+        if (userIds.length === 0) {
+            return users;
+        }
+        const rows = await UserService.findBy({
+            query: {
+                _id: QueryHelper.any(userIds),
+            },
+            select: {
+                _id: true,
+                name: true,
+                email: true,
+                timezone: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const row of rows) {
+            const userId = (_a = row.id) === null || _a === void 0 ? void 0 : _a.toString();
+            if (!userId) {
+                continue;
+            }
+            const name = ((_b = row.name) === null || _b === void 0 ? void 0 : _b.toString().trim()) || "";
+            const email = ((_c = row.email) === null || _c === void 0 ? void 0 : _c.toString().trim()) || "";
+            const timezone = ((_d = row.timezone) === null || _d === void 0 ? void 0 : _d.toString()) || "";
+            const info = {
+                userId,
+                userName: name || email || OnCallCalendarFeedUtil.FALLBACK_USER_NAME,
+            };
+            if (email) {
+                info.email = email;
+            }
+            if (timezone) {
+                info.timezone = timezone;
+            }
+            users.set(userId, info);
+        }
+        return users;
+    }
+    static async loadProjectNames(projectIds) {
+        var _a;
+        const names = new Map();
+        const distinct = Array.from(new Set(projectIds.filter((id) => {
+            return Boolean(id);
+        })));
+        if (distinct.length === 0) {
+            return names;
+        }
+        const projects = await ProjectService.findBy({
+            query: {
+                _id: QueryHelper.any(distinct),
+            },
+            select: {
+                _id: true,
+                name: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const project of projects) {
+            const id = (_a = project.id) === null || _a === void 0 ? void 0 : _a.toString();
+            if (id && project.name) {
+                names.set(id, project.name);
+            }
+        }
+        return names;
+    }
+    static validateWindow(windowStart, windowEnd) {
+        if (!(windowStart instanceof Date) ||
+            !(windowEnd instanceof Date) ||
+            Number.isNaN(windowStart.getTime()) ||
+            Number.isNaN(windowEnd.getTime())) {
+            throw new BadDataException("windowStart and windowEnd must be dates");
+        }
+        if (windowStart.getTime() >= windowEnd.getTime()) {
+            throw new BadDataException("windowStart must be before windowEnd");
+        }
+    }
+    static emptyResult(now) {
+        return {
+            shifts: [],
+            truncated: false,
+            schedules: [],
+            users: [],
+            generatedAt: now,
+        };
+    }
+    static dedupeIds(ids) {
+        const seen = new Set();
+        const result = [];
+        for (const id of ids) {
+            if (!id) {
+                continue;
+            }
+            const key = id.toString();
+            if (!key || seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            result.push(id);
+        }
+        return result;
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OnCallShiftMaterializer, "materializeForSchedule", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OnCallShiftMaterializer, "materializeForSchedules", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OnCallShiftMaterializer, "materializeForUser", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OnCallShiftMaterializer, "materializeForProject", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OnCallShiftMaterializer, "getCandidateScheduleIdsForUser", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OnCallShiftMaterializer, "getCandidateScheduleIdsForUsers", null);
+//# sourceMappingURL=OnCallShiftMaterializer.js.map