@oneuptime/common 12.0.29 → 12.0.31

package/build/dist/Server/Services/OnCallDutyPolicyScheduleService.js

@@ -40,6 +40,8 @@ import OnCallDutyPolicyScheduleLabelRuleEngineService from "./OnCallDutyPolicySc
 import OnCallDutyPolicyScheduleOwnerRuleEngineService from "./OnCallDutyPolicyScheduleOwnerRuleEngineService";
 import PushNotificationUtil from "../Utils/PushNotificationUtil";
 import { createWhatsAppMessageFromTemplate } from "../Utils/WhatsAppTemplateUtil";
+import OnCallCalendarFeedCache from "../Infrastructure/OnCallCalendarFeedCache";
+import OnCallShiftChangeListeners, { OnCallShiftChangeReason, } from "../Utils/OnCall/OnCallShiftChangeListeners";
 export class Service extends DatabaseService {
     constructor() {
         super(OnCallDutyPolicySchedule);
@@ -89,11 +91,145 @@ export class Service extends DatabaseService {
                 });
             });
         }
+        /*
+         * Capture the members of each schedule being deleted. Their layer-user
+         * rows cascade away at the database level (no hooks run), so this is the
+         * last moment the ids are available; onDeleteSuccess uses them to purge
+         * those users' calendar-feed bodies and to tell the shift-change
+         * listeners whose shift lists just changed. Best-effort.
+         */
+        const deletedSchedules = [];
+        try {
+            const scheduleIds = callSchedules
+                .map((schedule) => {
+                return schedule.id;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            const layerUsers = scheduleIds.length > 0
+                ? await OnCallDutyPolicyScheduleLayerUserService.findBy({
+                    query: {
+                        onCallDutyPolicyScheduleId: QueryHelper.any(scheduleIds),
+                    },
+                    select: {
+                        userId: true,
+                        onCallDutyPolicyScheduleId: true,
+                    },
+                    limit: LIMIT_PER_PROJECT,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                })
+                : [];
+            for (const schedule of callSchedules) {
+                if (!schedule.id) {
+                    continue;
+                }
+                const scheduleIdString = schedule.id.toString();
+                deletedSchedules.push({
+                    scheduleId: schedule.id,
+                    projectId: schedule.projectId || null,
+                    userIds: OnCallShiftChangeListeners.dedupe(layerUsers
+                        .filter((layerUser) => {
+                        var _a;
+                        return (((_a = layerUser.onCallDutyPolicyScheduleId) === null || _a === void 0 ? void 0 : _a.toString()) ===
+                            scheduleIdString);
+                    })
+                        .map((layerUser) => {
+                        return layerUser.userId;
+                    })
+                        .filter((id) => {
+                        return Boolean(id);
+                    })),
+                });
+            }
+        }
+        catch (err) {
+            logger.error("Error capturing schedule members before delete (best-effort).");
+            logger.error(err);
+        }
         return {
             deleteBy: deleteBy,
-            carryForward: {},
+            carryForward: { deletedSchedules },
         };
     }
+    /*
+     * A deleted schedule takes its shared feed with it (FK cascade) and drops
+     * out of its members' personal feeds; purge what was rendered from it and
+     * let the shift-change listeners (reminders) re-plan for those users. No
+     * version bump — the row is gone.
+     */
+    async onDeleteSuccess(onDelete, _itemIdsBeforeDelete) {
+        var _a;
+        const deletedSchedules = ((_a = onDelete.carryForward) === null || _a === void 0 ? void 0 : _a.deletedSchedules) || [];
+        for (const deleted of deletedSchedules) {
+            await this.propagateShiftConfigChange({
+                scheduleIds: [deleted.scheduleId],
+                projectId: deleted.projectId,
+                userIds: deleted.userIds,
+                reason: OnCallShiftChangeReason.ScheduleDeleted,
+                skipVersionBump: true,
+            });
+        }
+        return onDelete;
+    }
+    /*
+     * A rename or a timezone change alters every calendar event of the
+     * schedule (its title, and for a timezone change the instants themselves),
+     * so it must bump the schedule's shiftConfigVersion like any other
+     * configuration edit. The roster refresh writes through updateOneById with
+     * ignoreHooks, and the version bump itself is a raw statement, so neither
+     * re-enters this hook.
+     */
+    async onUpdateSuccess(onUpdate, updatedItemIds) {
+        var _a, _b;
+        const data = (((_a = onUpdate.updateBy) === null || _a === void 0 ? void 0 : _a.data) ||
+            {});
+        const touchesShiftConfiguration = data["name"] !== undefined || data["timezone"] !== undefined;
+        if (!touchesShiftConfiguration || updatedItemIds.length === 0) {
+            return onUpdate;
+        }
+        try {
+            const schedules = await this.findBy({
+                query: {
+                    _id: QueryHelper.any(updatedItemIds),
+                },
+                select: {
+                    _id: true,
+                    projectId: true,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            });
+            const byProject = new Map();
+            for (const schedule of schedules) {
+                if (!schedule.id) {
+                    continue;
+                }
+                const projectKey = ((_b = schedule.projectId) === null || _b === void 0 ? void 0 : _b.toString()) || "";
+                const list = byProject.get(projectKey) || [];
+                list.push(schedule.id);
+                byProject.set(projectKey, list);
+            }
+            for (const [projectKey, scheduleIds] of byProject) {
+                await this.propagateShiftConfigChange({
+                    scheduleIds,
+                    projectId: projectKey ? new ObjectID(projectKey) : null,
+                    reason: OnCallShiftChangeReason.ScheduleChanged,
+                });
+            }
+        }
+        catch (err) {
+            logger.error("Error propagating a schedule rename / timezone change to the calendar feeds (best-effort).");
+            logger.error(err);
+        }
+        return onUpdate;
+    }
     async getOnCallSchedulesWhereUserIsOnCallDuty(data) {
         const schedules = await this.findBy({
             query: {
@@ -895,7 +1031,7 @@ export class Service extends DatabaseService {
     }
     async getScheduleLayerProps(data) {
         // get schedule layers.
-        var _a, _b, _c;
+        var _a, _b;
         const scheduleId = data.scheduleId;
         const layers = await OnCallDutyPolicyScheduleLayerService.findBy({
             query: {
@@ -954,11 +1090,31 @@ export class Service extends DatabaseService {
             },
         });
         const scheduleTimezone = ((_a = schedule === null || schedule === void 0 ? void 0 : schedule.timezone) === null || _a === void 0 ? void 0 : _a.toString()) || undefined;
+        const { layerProps, scheduleUserIds } = this.buildLayerPropsFromRows({
+            layers,
+            layerUsers,
+            scheduleTimezone,
+        });
+        const projectId = ((_b = layers[0]) === null || _b === void 0 ? void 0 : _b.projectId) || null;
+        return { layerProps, projectId, scheduleUserIds };
+    }
+    /*
+     * Compose LayerProps from persisted layer + layer-user rows. Shared by the
+     * single-schedule loader the paging/roster path uses and the batched loader
+     * the calendar feeds use, so both feed the engine byte-identical input.
+     * Layers must already be sorted by order; layer users by order.
+     *
+     * Each LayerProps is stamped with the layer's id and name (informational;
+     * the engine copies them onto its events) so consumers can tell which
+     * layer a merged segment came from.
+     */
+    buildLayerPropsFromRows(data) {
+        var _a, _b;
         const layerProps = [];
         const scheduleUserIds = [];
         const seenUserIds = new Set();
-        for (const layer of layers) {
-            const usersForLayer = layerUsers
+        for (const layer of data.layers) {
+            const usersForLayer = data.layerUsers
                 .filter((layerUser) => {
                 var _a, _b;
                 return (((_a = layerUser.onCallDutyPolicyScheduleLayerId) === null || _a === void 0 ? void 0 : _a.toString()) ===
@@ -971,23 +1127,750 @@ export class Service extends DatabaseService {
                 return Boolean(user);
             });
             for (const user of usersForLayer) {
-                const idStr = ((_b = user.id) === null || _b === void 0 ? void 0 : _b.toString()) || "";
+                const idStr = ((_a = user.id) === null || _a === void 0 ? void 0 : _a.toString()) || "";
                 if (idStr && !seenUserIds.has(idStr)) {
                     seenUserIds.add(idStr);
                     scheduleUserIds.push(user.id);
                 }
             }
-            layerProps.push({
+            const props = {
                 users: usersForLayer,
                 startDateTimeOfLayer: layer.startsAt,
                 restrictionTimes: layer.restrictionTimes,
                 rotation: layer.rotation,
                 handOffTime: layer.handOffTime,
-                timezone: scheduleTimezone,
+                timezone: data.scheduleTimezone,
+            };
+            const layerId = (_b = layer.id) === null || _b === void 0 ? void 0 : _b.toString();
+            if (layerId) {
+                props.layerId = layerId;
+            }
+            if (typeof layer.name === "string" && layer.name) {
+                props.layerName = layer.name;
+            }
+            layerProps.push(props);
+        }
+        return { layerProps, scheduleUserIds };
+    }
+    /*
+     * ---------------------------------------------------------------------------
+     * Shift resolver — the source of truth for the calendar feeds, /my-shifts
+     * and the shift reminders.
+     * ---------------------------------------------------------------------------
+     */
+    /**
+     * Resolve every on-call segment of ONE schedule that overlaps
+     * [windowStart, windowEnd), in the exact order the paging and roster paths
+     * use: layers -> engine -> overrides. Returns null when the schedule does
+     * not exist. See getResolvedShiftSegmentsForSchedules for the rules.
+     */
+    async getResolvedShiftSegments(options) {
+        const resolved = await this.getResolvedShiftSegmentsForSchedules({
+            scheduleIds: [options.scheduleId],
+            windowStart: options.windowStart,
+            windowEnd: options.windowEnd,
+            maxSimulationIterations: options.maxSimulationIterations,
+        });
+        return resolved[0] || null;
+    }
+    /**
+     * Batched resolver: loads the layers, layer users, policy attachments and
+     * overrides of every schedule with a handful of IN queries, then resolves
+     * each schedule in memory.
+     *
+     * Per schedule:
+     *   1. LayerProps exactly as the roster path builds them (plus layer ids).
+     *   2. Expansion window = 2 rotation periods before windowStart .. 2 after
+     *      windowEnd, so the segments overlapping the window carry their TRUE
+     *      start and end rather than the engine's clamp to the window edge.
+     *   3. ONE multi-layer engine expansion, bounded by maxSimulationIterations
+     *      (default: the engine's own caps); `truncated` reports a cap hit.
+     *   4. Overrides in the roster's policy context: the single attached
+     *      policy's scoped overrides plus globals when exactly one policy is
+     *      attached, globals only otherwise — the same rule as
+     *      refreshCurrentUserIdAndHandoffTimeInSchedule (getSingleAttachedPolicyId).
+     *   5. With two or more distinct attached policies AND a policy-scoped
+     *      override for a member overlapping the window, the same base events
+     *      are re-resolved once per such policy -> policyVariants. The
+     *      expensive expansion runs once; the override pass is cheap.
+     *   6. lastModifiedAt = max(updatedAt) over layers, layer users,
+     *      participating overrides and attachments — never the schedule row.
+     *
+     * Schedules that no longer exist are skipped; the result is in the order
+     * of the input ids.
+     */
+    async getResolvedShiftSegmentsForSchedules(options) {
+        var _a;
+        const scheduleIds = OnCallShiftChangeListeners.dedupe(options.scheduleIds);
+        if (scheduleIds.length === 0) {
+            return [];
+        }
+        if (!OneUptimeDate.isBefore(options.windowStart, options.windowEnd) &&
+            options.windowStart.getTime() !== options.windowEnd.getTime()) {
+            throw new BadDataException("windowStart must be before windowEnd");
+        }
+        const inputsById = await this.loadResolutionInputsForSchedules(scheduleIds);
+        const prepared = [];
+        const projectIds = new Set();
+        let earliestStart = null;
+        let latestEnd = null;
+        for (const scheduleId of scheduleIds) {
+            const inputs = inputsById.get(scheduleId.toString());
+            if (!inputs) {
+                continue;
+            }
+            const { layerProps, scheduleUserIds } = this.buildLayerPropsFromRows({
+                layers: inputs.layers,
+                layerUsers: inputs.layerUsers,
+                scheduleTimezone: ((_a = inputs.schedule.timezone) === null || _a === void 0 ? void 0 : _a.toString()) || undefined,
+            });
+            const expansionStart = layerProps.length > 0
+                ? this.computeResolutionWindowStart(layerProps, options.windowStart, 2)
+                : options.windowStart;
+            const expansionEnd = layerProps.length > 0
+                ? this.computeResolutionWindowEndByPeriods(layerProps, options.windowEnd, 2)
+                : options.windowEnd;
+            if (inputs.schedule.projectId) {
+                projectIds.add(inputs.schedule.projectId.toString());
+            }
+            if (!earliestStart ||
+                OneUptimeDate.isBefore(expansionStart, earliestStart)) {
+                earliestStart = expansionStart;
+            }
+            if (!latestEnd || OneUptimeDate.isAfter(expansionEnd, latestEnd)) {
+                latestEnd = expansionEnd;
+            }
+            prepared.push({
+                inputs,
+                layerProps,
+                scheduleUserIds,
+                expansionStart,
+                expansionEnd,
             });
         }
-        const projectId = ((_c = layers[0]) === null || _c === void 0 ? void 0 : _c.projectId) || null;
-        return { layerProps, projectId, scheduleUserIds };
+        if (prepared.length === 0) {
+            return [];
+        }
+        const allOverrides = projectIds.size > 0 && earliestStart && latestEnd
+            ? await this.loadOverridesForProjects({
+                projectIds: Array.from(projectIds).map((id) => {
+                    return new ObjectID(id);
+                }),
+                windowStart: earliestStart,
+                windowEnd: latestEnd,
+            })
+            : [];
+        const results = [];
+        for (const item of prepared) {
+            results.push(this.resolveScheduleInMemory({
+                schedule: item.inputs.schedule,
+                layers: item.inputs.layers,
+                layerUsers: item.inputs.layerUsers,
+                attachments: item.inputs.attachments,
+                layerProps: item.layerProps,
+                scheduleUserIds: item.scheduleUserIds,
+                overrides: allOverrides,
+                expansionStart: item.expansionStart,
+                expansionEnd: item.expansionEnd,
+                windowStart: options.windowStart,
+                windowEnd: options.windowEnd,
+                maxSimulationIterations: options.maxSimulationIterations,
+            }));
+        }
+        return results;
+    }
+    /*
+     * Everything the resolver needs for a batch of schedules, in four queries.
+     * Schedules that do not exist simply have no entry.
+     */
+    async loadResolutionInputsForSchedules(scheduleIds) {
+        var _a, _b, _c;
+        const schedules = await this.findBy({
+            query: {
+                _id: QueryHelper.any(scheduleIds),
+            },
+            select: {
+                _id: true,
+                name: true,
+                timezone: true,
+                projectId: true,
+                shiftConfigVersion: true,
+                createdAt: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const byId = new Map();
+        for (const schedule of schedules) {
+            if (!schedule.id) {
+                continue;
+            }
+            byId.set(schedule.id.toString(), {
+                schedule,
+                layers: [],
+                layerUsers: [],
+                attachments: [],
+            });
+        }
+        if (byId.size === 0) {
+            return byId;
+        }
+        const existingIds = Array.from(byId.keys()).map((id) => {
+            return new ObjectID(id);
+        });
+        const [layers, layerUsers, attachments] = await Promise.all([
+            OnCallDutyPolicyScheduleLayerService.findBy({
+                query: {
+                    onCallDutyPolicyScheduleId: QueryHelper.any(existingIds),
+                },
+                select: {
+                    _id: true,
+                    order: true,
+                    name: true,
+                    description: true,
+                    startsAt: true,
+                    restrictionTimes: true,
+                    rotation: true,
+                    onCallDutyPolicyScheduleId: true,
+                    projectId: true,
+                    handOffTime: true,
+                    updatedAt: true,
+                },
+                sort: {
+                    order: SortOrder.Ascending,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            }),
+            OnCallDutyPolicyScheduleLayerUserService.findBy({
+                query: {
+                    onCallDutyPolicyScheduleId: QueryHelper.any(existingIds),
+                },
+                select: {
+                    _id: true,
+                    user: {
+                        _id: true,
+                    },
+                    userId: true,
+                    order: true,
+                    onCallDutyPolicyScheduleLayerId: true,
+                    onCallDutyPolicyScheduleId: true,
+                    updatedAt: true,
+                },
+                sort: {
+                    order: SortOrder.Ascending,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            }),
+            OnCallDutyPolicyEscalationRuleScheduleService.findBy({
+                query: {
+                    onCallDutyPolicyScheduleId: QueryHelper.any(existingIds),
+                },
+                select: {
+                    _id: true,
+                    onCallDutyPolicyScheduleId: true,
+                    onCallDutyPolicyId: true,
+                    onCallDutyPolicyEscalationRuleId: true,
+                    updatedAt: true,
+                    onCallDutyPolicy: {
+                        name: true,
+                        _id: true,
+                    },
+                    onCallDutyPolicyEscalationRule: {
+                        name: true,
+                        _id: true,
+                        order: true,
+                    },
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                    isRoot: true,
+                },
+            }),
+        ]);
+        for (const layer of layers) {
+            const entry = byId.get(((_a = layer.onCallDutyPolicyScheduleId) === null || _a === void 0 ? void 0 : _a.toString()) || "");
+            if (entry) {
+                entry.layers.push(layer);
+            }
+        }
+        for (const layerUser of layerUsers) {
+            const entry = byId.get(((_b = layerUser.onCallDutyPolicyScheduleId) === null || _b === void 0 ? void 0 : _b.toString()) || "");
+            if (entry) {
+                entry.layerUsers.push(layerUser);
+            }
+        }
+        for (const attachment of attachments) {
+            const entry = byId.get(((_c = attachment.onCallDutyPolicyScheduleId) === null || _c === void 0 ? void 0 : _c.toString()) || "");
+            if (entry) {
+                entry.attachments.push(attachment);
+            }
+        }
+        return byId;
+    }
+    /*
+     * Every override (global AND policy-scoped) of the given projects that
+     * overlaps [windowStart, windowEnd]. The per-schedule policy scoping and
+     * member filtering happen in memory (see selectOverridesForSchedule), which
+     * mirrors fetchOverridesForSchedule's query exactly but for many schedules
+     * at once.
+     */
+    async loadOverridesForProjects(data) {
+        if (data.projectIds.length === 0) {
+            return [];
+        }
+        return await OnCallDutyPolicyUserOverrideService.findBy({
+            query: {
+                projectId: QueryHelper.any(data.projectIds),
+                startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
+                endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                startsAt: true,
+                endsAt: true,
+                overrideUserId: true,
+                routeAlertsToUserId: true,
+                onCallDutyPolicyId: true,
+                updatedAt: true,
+            },
+            sort: {
+                startsAt: SortOrder.Ascending,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+    /*
+     * The in-memory twin of fetchOverridesForSchedule: the overrides of this
+     * schedule's project that overlap the window, whose overridden user is a
+     * schedule member, scoped to `policyId` (that policy's plus globals) or to
+     * globals only when no policy context is given.
+     */
+    selectOverridesForSchedule(data) {
+        return data.overrides.filter((override) => {
+            var _a, _b, _c;
+            if (((_a = override.projectId) === null || _a === void 0 ? void 0 : _a.toString()) !== data.projectId) {
+                return false;
+            }
+            if (!override.startsAt || !override.endsAt) {
+                return false;
+            }
+            if (OneUptimeDate.isAfter(override.startsAt, data.windowEnd) ||
+                OneUptimeDate.isBefore(override.endsAt, data.windowStart)) {
+                return false;
+            }
+            if (!data.scheduleUserIds.has(((_b = override.overrideUserId) === null || _b === void 0 ? void 0 : _b.toString()) || "")) {
+                return false;
+            }
+            const overridePolicyId = ((_c = override.onCallDutyPolicyId) === null || _c === void 0 ? void 0 : _c.toString()) || undefined;
+            if (!overridePolicyId) {
+                return true; // global
+            }
+            return Boolean(data.policyId) && overridePolicyId === data.policyId;
+        });
+    }
+    toUserOverrideRecord(override) {
+        var _a, _b, _c;
+        return {
+            overrideUserId: ((_a = override.overrideUserId) === null || _a === void 0 ? void 0 : _a.toString()) || "",
+            routeAlertsToUserId: ((_b = override.routeAlertsToUserId) === null || _b === void 0 ? void 0 : _b.toString()) || "",
+            startsAt: override.startsAt,
+            endsAt: override.endsAt,
+            onCallDutyPolicyId: ((_c = override.onCallDutyPolicyId) === null || _c === void 0 ? void 0 : _c.toString()) || null,
+        };
+    }
+    /*
+     * The pure part of the resolver: given everything already loaded, expand
+     * once and resolve the base context plus any policy variants.
+     */
+    resolveScheduleInMemory(data) {
+        var _a, _b, _c;
+        const scheduleId = data.schedule.id.toString();
+        const projectId = ((_a = data.schedule.projectId) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+        // Distinct (policy, rule) attachments, stable order.
+        const attachedPolicies = this.toAttachedPolicies(data.attachments);
+        const distinctPolicyIds = [];
+        for (const policy of attachedPolicies) {
+            if (!distinctPolicyIds.includes(policy.policyId)) {
+                distinctPolicyIds.push(policy.policyId);
+            }
+        }
+        // The roster rule: exactly one attached policy => resolve in its context.
+        const baseContextPolicyId = distinctPolicyIds.length === 1 ? distinctPolicyIds[0] : undefined;
+        // 1 + 2 + 3: one engine expansion over the widened window.
+        let baseEvents = [];
+        let truncated = false;
+        if (data.layerProps.length > 0) {
+            const expansion = this.layerUtil.getMultiLayerEventsWithMeta({
+                layers: data.layerProps,
+                calendarStartDate: data.expansionStart,
+                calendarEndDate: data.expansionEnd,
+            }, data.maxSimulationIterations !== undefined
+                ? { maxSimulationIterations: data.maxSimulationIterations }
+                : undefined);
+            baseEvents = expansion.events;
+            truncated = expansion.truncated;
+        }
+        const scheduleUserIdSet = new Set(data.scheduleUserIds.map((id) => {
+            return id.toString();
+        }));
+        // 4: overrides in the base (roster) context.
+        const baseOverrideRows = this.selectOverridesForSchedule({
+            overrides: data.overrides,
+            projectId,
+            scheduleUserIds: scheduleUserIdSet,
+            windowStart: data.expansionStart,
+            windowEnd: data.expansionEnd,
+            policyId: baseContextPolicyId,
+        });
+        const baseOverrides = baseOverrideRows.map((override) => {
+            return this.toUserOverrideRecord(override);
+        });
+        const participatingOverrideRows = [
+            ...baseOverrideRows,
+        ];
+        const participatingOverrides = [
+            ...baseOverrides,
+        ];
+        let segments = baseEvents;
+        if (baseOverrides.length > 0 && baseEvents.length > 0) {
+            segments = UserOverrideUtil.applyOverridesToEvents({
+                events: baseEvents,
+                overrides: baseOverrides,
+                currentOnCallDutyPolicyId: baseContextPolicyId,
+            });
+        }
+        segments = this.filterEventsOverlappingWindow(segments, data.windowStart, data.windowEnd);
+        // 5: policy variants.
+        const policyVariants = [];
+        if (distinctPolicyIds.length >= 2 && baseEvents.length > 0) {
+            for (const policyId of distinctPolicyIds) {
+                const scopedRows = this.selectOverridesForSchedule({
+                    overrides: data.overrides,
+                    projectId,
+                    scheduleUserIds: scheduleUserIdSet,
+                    windowStart: data.expansionStart,
+                    windowEnd: data.expansionEnd,
+                    policyId,
+                }).filter((override) => {
+                    // Only the policy-scoped ones make this context differ.
+                    return Boolean(override.onCallDutyPolicyId);
+                });
+                if (scopedRows.length === 0) {
+                    continue;
+                }
+                const variantOverrideRows = [
+                    ...scopedRows,
+                    ...baseOverrideRows,
+                ];
+                const variantOverrides = variantOverrideRows.map((override) => {
+                    return this.toUserOverrideRecord(override);
+                });
+                for (const row of scopedRows) {
+                    participatingOverrideRows.push(row);
+                }
+                for (const record of variantOverrides.slice(0, scopedRows.length)) {
+                    participatingOverrides.push(record);
+                }
+                const variantSegments = this.filterEventsOverlappingWindow(UserOverrideUtil.applyOverridesToEvents({
+                    events: baseEvents,
+                    overrides: variantOverrides,
+                    currentOnCallDutyPolicyId: policyId,
+                }), data.windowStart, data.windowEnd);
+                const policyName = ((_b = attachedPolicies.find((policy) => {
+                    return policy.policyId === policyId;
+                })) === null || _b === void 0 ? void 0 : _b.policyName) || "";
+                policyVariants.push({
+                    policyId,
+                    policyName,
+                    segments: variantSegments,
+                });
+            }
+        }
+        // 6: lastModifiedAt — schedule row excluded.
+        const lastModifiedAt = this.computeLastModifiedAt({
+            schedule: data.schedule,
+            layers: data.layers,
+            layerUsers: data.layerUsers,
+            attachments: data.attachments,
+            overrides: participatingOverrideRows,
+        });
+        const scheduleInfo = {
+            id: scheduleId,
+            name: data.schedule.name || "",
+            projectId,
+            shiftConfigVersion: Service.toVersionNumber(data.schedule.shiftConfigVersion),
+        };
+        const timezone = ((_c = data.schedule.timezone) === null || _c === void 0 ? void 0 : _c.toString()) || undefined;
+        if (timezone) {
+            scheduleInfo.timezone = timezone;
+        }
+        return {
+            schedule: scheduleInfo,
+            segments,
+            policyVariants,
+            attachedPolicies,
+            layerProps: data.layerProps,
+            scheduleUserIds: Array.from(scheduleUserIdSet),
+            overrides: participatingOverrides,
+            lastModifiedAt,
+            truncated,
+        };
+    }
+    toAttachedPolicies(attachments) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const seen = new Set();
+        const policies = [];
+        for (const attachment of attachments) {
+            const policyId = ((_a = attachment.onCallDutyPolicyId) === null || _a === void 0 ? void 0 : _a.toString()) ||
+                ((_c = (_b = attachment.onCallDutyPolicy) === null || _b === void 0 ? void 0 : _b.id) === null || _c === void 0 ? void 0 : _c.toString()) ||
+                "";
+            const ruleId = ((_d = attachment.onCallDutyPolicyEscalationRuleId) === null || _d === void 0 ? void 0 : _d.toString()) ||
+                ((_f = (_e = attachment.onCallDutyPolicyEscalationRule) === null || _e === void 0 ? void 0 : _e.id) === null || _f === void 0 ? void 0 : _f.toString()) ||
+                "";
+            if (!policyId) {
+                continue;
+            }
+            const key = `${policyId}:${ruleId}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            policies.push({
+                policyId,
+                policyName: ((_g = attachment.onCallDutyPolicy) === null || _g === void 0 ? void 0 : _g.name) || "",
+                ruleId,
+                ruleName: ((_h = attachment.onCallDutyPolicyEscalationRule) === null || _h === void 0 ? void 0 : _h.name) || "",
+                ruleOrder: Service.toVersionNumber((_j = attachment.onCallDutyPolicyEscalationRule) === null || _j === void 0 ? void 0 : _j.order),
+            });
+        }
+        policies.sort((a, b) => {
+            if (a.policyName !== b.policyName) {
+                return a.policyName < b.policyName ? -1 : 1;
+            }
+            if (a.policyId !== b.policyId) {
+                return a.policyId < b.policyId ? -1 : 1;
+            }
+            if (a.ruleOrder !== b.ruleOrder) {
+                return a.ruleOrder - b.ruleOrder;
+            }
+            return a.ruleId < b.ruleId ? -1 : a.ruleId > b.ruleId ? 1 : 0;
+        });
+        return policies;
+    }
+    computeLastModifiedAt(data) {
+        let latest = null;
+        const consider = (value) => {
+            if (!value) {
+                return;
+            }
+            const asDate = value instanceof Date ? value : new Date(value);
+            if (Number.isNaN(asDate.getTime())) {
+                return;
+            }
+            if (!latest || asDate.getTime() > latest.getTime()) {
+                latest = asDate;
+            }
+        };
+        for (const rows of [
+            data.layers,
+            data.layerUsers,
+            data.attachments,
+            data.overrides,
+        ]) {
+            for (const row of rows) {
+                consider(row.updatedAt);
+            }
+        }
+        if (latest) {
+            return latest;
+        }
+        /*
+         * Nothing configured yet (no layers, no attachments): fall back to when
+         * the schedule was CREATED — stable, unlike its updatedAt — and finally
+         * to the epoch so the value is always a valid instant.
+         */
+        if (data.schedule.createdAt) {
+            const created = new Date(data.schedule.createdAt);
+            if (!Number.isNaN(created.getTime())) {
+                return created;
+            }
+        }
+        return new Date(0);
+    }
+    filterEventsOverlappingWindow(events, windowStart, windowEnd) {
+        return events.filter((event) => {
+            if (!event || !event.start || !event.end) {
+                return false;
+            }
+            return (event.start.getTime() < windowEnd.getTime() &&
+                event.end.getTime() > windowStart.getTime());
+        });
+    }
+    static toVersionNumber(value) {
+        const parsed = typeof value === "number" ? value : parseInt(String(value !== null && value !== void 0 ? value : ""), 10);
+        return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+    }
+    /*
+     * ---------------------------------------------------------------------------
+     * Change propagation — shiftConfigVersion, feed caches, listeners.
+     * ---------------------------------------------------------------------------
+     */
+    /**
+     * Atomically add one to shiftConfigVersion of each schedule, in a single
+     * UPDATE per schedule (`SET col = COALESCE(col, 0) + 1`, no hooks, no
+     * optimistic-lock bump — see atomicAddToColumnsByIdWithoutHooks). Best
+     * effort: a failure is logged and never thrown, because this runs inside
+     * the CRUD hooks of the user's edit and must not fail it.
+     *
+     * NEVER call this from refreshCurrentUserIdAndHandoffTimeInSchedule: the
+     * roster refresh runs every handoff and touches no configuration, and the
+     * version is what calendar clients see as SEQUENCE — bumping it there would
+     * make every feed look edited every rotation period.
+     */
+    async bumpShiftConfigVersion(scheduleIds) {
+        for (const scheduleId of OnCallShiftChangeListeners.dedupe(scheduleIds)) {
+            try {
+                await this.atomicAddToColumnsByIdWithoutHooks({
+                    id: scheduleId,
+                    add: { shiftConfigVersion: 1 },
+                });
+            }
+            catch (err) {
+                logger.error(`Error bumping shiftConfigVersion for schedule ${scheduleId.toString()} (best-effort).`);
+                logger.error(err);
+            }
+        }
+    }
+    /**
+     * The schedules in `projectId` whose layers include any of `userIds` —
+     * the query refreshRostersForUserInProject uses, batched. Root read.
+     */
+    async getScheduleIdsForUsersInProject(data) {
+        const userIds = OnCallShiftChangeListeners.dedupe(data.userIds);
+        if (userIds.length === 0) {
+            return [];
+        }
+        const layerUsers = await OnCallDutyPolicyScheduleLayerUserService.findBy({
+            query: {
+                projectId: data.projectId,
+                userId: QueryHelper.any(userIds),
+            },
+            select: {
+                onCallDutyPolicyScheduleId: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        return OnCallShiftChangeListeners.dedupe(layerUsers
+            .map((layerUser) => {
+            return layerUser.onCallDutyPolicyScheduleId;
+        })
+            .filter((id) => {
+            return Boolean(id);
+        }));
+    }
+    /**
+     * What every configuration hook calls after the roster refresh:
+     *   1. bump shiftConfigVersion of the affected schedules (SEQUENCE / cache key),
+     *   2. purge the calendar-feed caches of those schedules and of the users
+     *      the change names directly,
+     *   3. tell the shift-change listeners (the reminder change pass) which
+     *      schedules and users to look at again — delivered in the background,
+     *      never awaited, never allowed to fail the edit.
+     * Never throws.
+     */
+    async propagateShiftConfigChange(change) {
+        try {
+            const scheduleIds = OnCallShiftChangeListeners.dedupe(change.scheduleIds);
+            const explicitUserIds = OnCallShiftChangeListeners.dedupe(change.userIds || []);
+            if (scheduleIds.length > 0 && !change.skipVersionBump) {
+                await this.bumpShiftConfigVersion(scheduleIds);
+            }
+            for (const scheduleId of scheduleIds) {
+                try {
+                    await OnCallCalendarFeedCache.purgeForSchedule(scheduleId.toString());
+                }
+                catch (err) {
+                    logger.error(err);
+                }
+            }
+            if (change.projectId) {
+                for (const userId of explicitUserIds) {
+                    try {
+                        await OnCallCalendarFeedCache.purgeForUser(change.projectId.toString(), userId.toString());
+                    }
+                    catch (err) {
+                        logger.error(err);
+                    }
+                }
+            }
+            let userIds = explicitUserIds;
+            if (scheduleIds.length > 0) {
+                try {
+                    const members = await OnCallDutyPolicyScheduleLayerUserService.findBy({
+                        query: {
+                            onCallDutyPolicyScheduleId: QueryHelper.any(scheduleIds),
+                        },
+                        select: {
+                            userId: true,
+                        },
+                        limit: LIMIT_PER_PROJECT,
+                        skip: 0,
+                        props: {
+                            isRoot: true,
+                        },
+                    });
+                    userIds = OnCallShiftChangeListeners.dedupe([
+                        ...explicitUserIds,
+                        ...members
+                            .map((member) => {
+                            return member.userId;
+                        })
+                            .filter((id) => {
+                            return Boolean(id);
+                        }),
+                    ]);
+                }
+                catch (err) {
+                    logger.error("Error loading schedule members for the shift-change event (best-effort).");
+                    logger.error(err);
+                }
+            }
+            const event = OnCallShiftChangeListeners.buildEvent({
+                projectId: change.projectId,
+                scheduleIds,
+                userIds,
+                reason: change.reason,
+            });
+            // Background delivery; notify never rejects, the catch is belt-and-braces.
+            OnCallShiftChangeListeners.notify(event).catch((err) => {
+                logger.error(err);
+            });
+        }
+        catch (err) {
+            logger.error("Error propagating an on-call configuration change (best-effort).");
+            logger.error(err);
+        }
     }
     async fetchOverridesForSchedule(data) {
         if (data.scheduleUserIds.length === 0) {
@@ -1148,6 +2031,39 @@ export class Service extends DatabaseService {
         }
         return windowStart;
     }
+    /*
+     * Mirror of computeResolutionWindowStart, stepping FORWARDS: the latest of
+     * `from` plus `periodsForward` rotation periods across the layers (at least
+     * a day). The calendar-feed resolver widens its expansion this far past the
+     * requested window so the last overlapping segment carries its true end
+     * instead of the engine's clamp to the window edge.
+     */
+    computeResolutionWindowEndByPeriods(layerProps, from, periodsForward) {
+        let windowEnd = OneUptimeDate.addRemoveDays(from, 1);
+        for (const layer of layerProps) {
+            if (!layer.rotation) {
+                continue;
+            }
+            let recurring;
+            try {
+                recurring =
+                    layer.rotation instanceof Recurring
+                        ? layer.rotation
+                        : Recurring.fromJSON(layer.rotation);
+            }
+            catch (_a) {
+                continue;
+            }
+            let candidate = from;
+            for (let i = 0; i < periodsForward; i++) {
+                candidate = Recurring.getNextDateInterval(candidate, recurring);
+            }
+            if (OneUptimeDate.isAfter(candidate, windowEnd)) {
+                windowEnd = candidate;
+            }
+        }
+        return windowEnd;
+    }
     /*
      * Recover the TRUE start of the current on-call coverage window for
      * `currentUserId`. getEventByIndexInSchedule always expands from `now`, and
@@ -1314,6 +2230,36 @@ export class Service extends DatabaseService {
         return new ObjectID(userId);
     }
 }
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getResolvedShiftSegments", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getResolvedShiftSegmentsForSchedules", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "bumpShiftConfigVersion", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getScheduleIdsForUsersInProject", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "propagateShiftConfigChange", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),