@oneuptime/common 11.3.26 → 11.3.28

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -10,6 +10,7 @@ import OnCallDutyPolicyEscalationRuleScheduleService from "./OnCallDutyPolicyEsc
 import OnCallDutyPolicyEscalationRuleTeamService from "./OnCallDutyPolicyEscalationRuleTeamService";
 import OnCallDutyPolicyEscalationRuleUserService from "./OnCallDutyPolicyEscalationRuleUserService";
 import OnCallDutyPolicyExecutionLogService from "./OnCallDutyPolicyExecutionLogService";
+import OnCallDutyPolicyExecutionLog from "../../Models/DatabaseModels/OnCallDutyPolicyExecutionLog";
 import OnCallDutyPolicyExecutionLogTimelineService from "./OnCallDutyPolicyExecutionLogTimelineService";
 import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 import TeamMemberService from "./TeamMemberService";
@@ -315,31 +316,66 @@ export class Service extends DatabaseService<Model> {
     );
 
     type StartUserNotificationRuleExecutionFunction = (
-      userId: ObjectID,
+      originalUserId: ObjectID,
+      alertSentToUserId: ObjectID,
       teamId: ObjectID | null,
       scheduleId: ObjectID | null,
     ) => Promise<void>;
 
-    const startUserNotificationRuleExecution: StartUserNotificationRuleExecutionFunction =
-      async (
-        userId: ObjectID,
-        teamId: ObjectID | null,
-        scheduleId: ObjectID | null,
-      ): Promise<void> => {
-        // This is where user is notified.
-
-        // get route alert to user id.
-        let routeAlertToUserId: ObjectID | null = null;
+    /*
+     * Resolve the FINAL alert recipient for a target, applying a user override
+     * (getRouteAlertToUserId) exactly ONCE per paging decision.
+     *
+     * Schedule targets are already override-resolved: getCurrentUserIdInSchedule
+     * applies overrides via UserOverrideUtil. Applying getRouteAlertToUserId to
+     * them again re-substituted an already-substituted user (transitive), so the
+     * schedule paging path could page a different person than the roster,
+     * dashboard, handoff notification, and a rule that lists the same user
+     * directly — all of which apply overrides only once (audit F5). So team and
+     * direct-user targets (the RAW roster user) get the single override hop here;
+     * schedule targets do not.
+     */
+    const resolveAlertRecipientUserId: (
+      userId: ObjectID,
+      isFromSchedule: boolean,
+    ) => Promise<ObjectID> = async (
+      userId: ObjectID,
+      isFromSchedule: boolean,
+    ): Promise<ObjectID> => {
+      if (isFromSchedule) {
+        return userId;
+      }
 
-        if (options.onCallPolicyId) {
-          routeAlertToUserId = await this.getRouteAlertToUserId({
+      if (options.onCallPolicyId) {
+        const routeAlertToUserId: ObjectID | null =
+          await this.getRouteAlertToUserId({
             userId,
             onCallDutyPolicyId: options.onCallPolicyId,
             projectId: options.projectId,
           });
+
+        if (routeAlertToUserId) {
+          return routeAlertToUserId;
         }
+      }
+
+      return userId;
+    };
+
+    const startUserNotificationRuleExecution: StartUserNotificationRuleExecutionFunction =
+      async (
+        originalUserId: ObjectID,
+        alertSentToUserId: ObjectID,
+        teamId: ObjectID | null,
+        scheduleId: ObjectID | null,
+      ): Promise<void> => {
+        /*
+         * This is where user is notified. alertSentToUserId is already resolved
+         * (override applied at most once by resolveAlertRecipientUserId).
+         */
 
-        const alertSentToUserId: ObjectID = routeAlertToUserId || userId;
+        const wasOverridden: boolean =
+          alertSentToUserId.toString() !== originalUserId.toString();
 
         logger.debug(
           `Starting notification rule execution for userId: ${alertSentToUserId.toString()}`,
@@ -354,8 +390,8 @@ export class Service extends DatabaseService<Model> {
         log.status = OnCallDutyExecutionLogTimelineStatus.Executing;
         log.alertSentToUserId = alertSentToUserId;
 
-        if (routeAlertToUserId) {
-          log.overridedByUserId = userId;
+        if (wasOverridden) {
+          log.overridedByUserId = originalUserId;
         }
 
         if (teamId) {
@@ -390,12 +426,36 @@ export class Service extends DatabaseService<Model> {
             onCallDutyPolicyExecutionLogTimelineId: log.id!,
             projectId: options.projectId,
             onCallScheduleId: scheduleId || undefined,
-            overridedByUserId: routeAlertToUserId ? userId : undefined,
+            overridedByUserId: wasOverridden ? originalUserId : undefined,
           },
         );
       };
 
+    /*
+     * Dedup on the RESOLVED recipient (post-override), not the pre-route id.
+     * Keying on the pre-route id let two different targets that both reroute to
+     * the same backup each fire a full notification chain for the same person in
+     * one rule (audit F6).
+     */
     const uniqueUserIds: Array<ObjectID> = [];
+    const alreadyNotified: (recipientId: ObjectID) => boolean = (
+      recipientId: ObjectID,
+    ): boolean => {
+      return Boolean(
+        uniqueUserIds.find((userId: ObjectID) => {
+          return recipientId.toString() === userId.toString();
+        }),
+      );
+    };
+
+    /*
+     * M-5: tracks whether any schedule target for this rule momentarily had no
+     * on-call user (a restriction gap / future start / empty layer). If a rule
+     * reaches NO ONE solely because of such a gap, we re-sample the same rule on
+     * the next cron ticks (bounded) instead of permanently skipping it, so a
+     * user coming on-call moments later still gets paged.
+     */
+    let hadScheduleGap: boolean = false;
 
     for (const teamInRule of teamsInRule) {
       const usersInTeam: Array<User> = await TeamMemberService.getUsersInTeam(
@@ -403,14 +463,16 @@ export class Service extends DatabaseService<Model> {
       );
 
       for (const user of usersInTeam) {
-        if (
-          !uniqueUserIds.find((userId: ObjectID) => {
-            return user.id?.toString() === userId.toString();
-          })
-        ) {
-          uniqueUserIds.push(user.id!);
+        const recipientUserId: ObjectID = await resolveAlertRecipientUserId(
+          user.id!,
+          false,
+        );
+
+        if (!alreadyNotified(recipientUserId)) {
+          uniqueUserIds.push(recipientUserId);
           await startUserNotificationRuleExecution(
             user.id!,
+            recipientUserId,
             teamInRule.teamId!,
             null,
           );
@@ -419,7 +481,7 @@ export class Service extends DatabaseService<Model> {
           log.statusMessage =
             "Skipped because notification sent to this user already.";
           log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
-          log.alertSentToUserId = user.id!;
+          log.alertSentToUserId = recipientUserId;
           log.userBelongsToTeamId = teamInRule.teamId!;
 
           await OnCallDutyPolicyExecutionLogTimelineService.create({
@@ -433,19 +495,25 @@ export class Service extends DatabaseService<Model> {
     }
 
     for (const userRule of usersInRule) {
-      if (
-        !uniqueUserIds.find((userId: ObjectID) => {
-          return userRule.userId?.toString() === userId.toString();
-        })
-      ) {
-        uniqueUserIds.push(userRule.userId!);
-        await startUserNotificationRuleExecution(userRule.userId!, null, null);
+      const recipientUserId: ObjectID = await resolveAlertRecipientUserId(
+        userRule.userId!,
+        false,
+      );
+
+      if (!alreadyNotified(recipientUserId)) {
+        uniqueUserIds.push(recipientUserId);
+        await startUserNotificationRuleExecution(
+          userRule.userId!,
+          recipientUserId,
+          null,
+          null,
+        );
       } else {
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage =
           "Skipped because notification sent to this user already.";
         log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
-        log.alertSentToUserId = userRule.userId!;
+        log.alertSentToUserId = recipientUserId;
 
         await OnCallDutyPolicyExecutionLogTimelineService.create({
           data: log,
@@ -464,6 +532,8 @@ export class Service extends DatabaseService<Model> {
         );
 
       if (!userIdInSchedule) {
+        hadScheduleGap = true;
+
         const log: OnCallDutyPolicyExecutionLogTimeline = getNewLog();
         log.statusMessage =
           "Skipped because no active users are found in this schedule.";
@@ -480,14 +550,17 @@ export class Service extends DatabaseService<Model> {
         continue;
       }
 
-      if (
-        !uniqueUserIds.find((userId: ObjectID) => {
-          return userIdInSchedule?.toString() === userId.toString();
-        })
-      ) {
-        uniqueUserIds.push(userIdInSchedule);
+      // Schedule users are already override-resolved; no second override hop (F5).
+      const recipientUserId: ObjectID = await resolveAlertRecipientUserId(
+        userIdInSchedule,
+        true,
+      );
+
+      if (!alreadyNotified(recipientUserId)) {
+        uniqueUserIds.push(recipientUserId);
         await startUserNotificationRuleExecution(
           userIdInSchedule,
+          recipientUserId,
           null,
           scheduleRule.onCallDutyPolicyScheduleId!,
         );
@@ -496,7 +569,7 @@ export class Service extends DatabaseService<Model> {
         log.statusMessage =
           "Skipped because notification sent to this user already.";
         log.status = OnCallDutyExecutionLogTimelineStatus.Skipped;
-        log.alertSentToUserId = userIdInSchedule;
+        log.alertSentToUserId = recipientUserId;
         log.onCallDutyScheduleId = scheduleRule.onCallDutyPolicyScheduleId!;
 
         await OnCallDutyPolicyExecutionLogTimelineService.create({
@@ -521,6 +594,77 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    /*
+     * M-5: if this rule reached NO ONE and the only reason was a schedule gap
+     * (a schedule target with no on-call user right now), re-sample the SAME
+     * rule on the next cron ticks — bounded — instead of permanently skipping.
+     * ExecutePendingExecutions selects the rule with order =
+     * lastExecutedEscalationRuleOrder + 1, so rewinding the order by one makes
+     * it re-run this rule. No notifications were sent (uniqueUserIds is empty),
+     * so a re-sample cannot double-page anyone.
+     */
+    const maxScheduleGapRetries: number = 5;
+    const scheduleGapRetryIntervalMinutes: number = 1;
+    const reachedNoOne: boolean = uniqueUserIds.length === 0;
+
+    if (reachedNoOne && hadScheduleGap && rule.order) {
+      const executionLog: OnCallDutyPolicyExecutionLog | null =
+        await OnCallDutyPolicyExecutionLogService.findOneById({
+          id: options.onCallPolicyExecutionLogId,
+          select: {
+            scheduleGapRetryCount: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      const retryCount: number = executionLog?.scheduleGapRetryCount || 0;
+
+      if (retryCount < maxScheduleGapRetries) {
+        await OnCallDutyPolicyExecutionLogService.updateOneById({
+          id: options.onCallPolicyExecutionLogId,
+          data: {
+            lastExecutedEscalationRuleOrder: rule.order - 1,
+            executeNextEscalationRuleInMinutes: scheduleGapRetryIntervalMinutes,
+            scheduleGapRetryCount: retryCount + 1,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.debug(
+          `Rule ${ruleId.toString()} reached no one due to a schedule gap; re-sampling ${retryCount + 1}/${maxScheduleGapRetries}.`,
+          {
+            onCallDutyPolicyEscalationRuleId: ruleId.toString(),
+          } as LogAttributes,
+        );
+      } else {
+        // Retries exhausted — advance normally next tick and reset the counter.
+        await OnCallDutyPolicyExecutionLogService.updateOneById({
+          id: options.onCallPolicyExecutionLogId,
+          data: {
+            scheduleGapRetryCount: 0,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    } else {
+      // Reached someone (or no schedule gap): clear retry state for the next rule.
+      await OnCallDutyPolicyExecutionLogService.updateOneById({
+        id: options.onCallPolicyExecutionLogId,
+        data: {
+          scheduleGapRetryCount: 0,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     logger.debug(`Completed rule execution for ruleId: ${ruleId.toString()}`, {
       projectId: options.projectId.toString(),
       onCallDutyPolicyEscalationRuleId: ruleId.toString(),
@@ -912,8 +1056,8 @@ export class Service extends DatabaseService<Model> {
         // moving down.
 
         for (const resource of resources) {
-          if (resource.order! <= newOrder) {
-            // increment order.
+          if (resource.order! > currentOrder && resource.order! <= newOrder) {
+            // decrement order to fill the gap left by the moved rule.
             await this.updateOneBy({
               query: {
                 _id: resource._id!,

package/Server/Services/OnCallDutyPolicyEscalationRuleUserService.ts

@@ -261,22 +261,30 @@ export class Service extends DatabaseService<Model> {
               notifyUserId: userId || undefined,
             },
           });
-
-          // also remove on-call duty time log.
-          OnCallDutyPolicyTimeLogService.endTimeLogForUser({
-            projectId: projectId,
-            onCallDutyPolicyId: onCallDutyPolicyId,
-            onCallDutyPolicyEscalationRuleId:
-              item.onCallDutyPolicyEscalationRule!.id!,
-            userId: userId,
-            endsAt: OneUptimeDate.getCurrentDate(),
-          }).catch((error: Error) => {
-            logger.error(`Error ending time log for user ${userId}: ${error}`, {
-              projectId: projectId?.toString(),
-              userId: userId?.toString(),
-            } as LogAttributes);
-          });
         }
+
+        /*
+         * Close the removed user's open on-call time log. This MUST run
+         * independently of whether the user has a display name — invited users
+         * who have not finished signup commonly have a null/empty name, and the
+         * ADD path (onCreateSuccess) opens their time log regardless of name.
+         * Nesting this inside `if (user && user.name)` left those users' logs
+         * open forever, showing them as perpetually on-call in reporting
+         * (audit F19).
+         */
+        OnCallDutyPolicyTimeLogService.endTimeLogForUser({
+          projectId: projectId,
+          onCallDutyPolicyId: onCallDutyPolicyId,
+          onCallDutyPolicyEscalationRuleId:
+            item.onCallDutyPolicyEscalationRule!.id!,
+          userId: userId,
+          endsAt: OneUptimeDate.getCurrentDate(),
+        }).catch((error: Error) => {
+          logger.error(`Error ending time log for user ${userId}: ${error}`, {
+            projectId: projectId?.toString(),
+            userId: userId?.toString(),
+          } as LogAttributes);
+        });
       }
     }
 

package/Server/Services/OnCallDutyPolicyExecutionLogService.ts

@@ -26,6 +26,7 @@ import IncidentService from "./IncidentService";
 import AlertService from "./AlertService";
 import AlertEpisodeService from "./AlertEpisodeService";
 import IncidentEpisodeService from "./IncidentEpisodeService";
+import { IsNull, UpdateResult } from "typeorm";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -35,6 +36,44 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  /**
+   * Atomically claim the right to advance this execution to its next escalation
+   * rule on the current tick. Implemented as a single conditional
+   * `UPDATE ... WHERE lastEscalationRuleExecutedAt = <the value just read>`
+   * (via TypeORM's repository.update, which emits one atomic statement and
+   * returns the affected-row count), so that when two overlapping cron runs read
+   * the same lastEscalationRuleExecutedAt, exactly one wins — the loser sees
+   * `affected === 0` and bows out instead of double-paging responders (audit
+   * F13). `updateOneBy` could NOT provide this: it does a non-locking SELECT and
+   * then `save()` keyed only on `_id`, and returns the SELECT match count, so
+   * both overlapping runs would "win".
+   */
+  @CaptureSpan()
+  public async claimEscalationAdvance(data: {
+    executionLogId: ObjectID;
+    previousLastEscalationRuleExecutedAt: Date | null;
+    newLastEscalationRuleExecutedAt: Date;
+  }): Promise<boolean> {
+    const whereClause: Record<string, unknown> = {
+      _id: data.executionLogId.toString(),
+      status: OnCallDutyPolicyStatus.Executing,
+      lastEscalationRuleExecutedAt: data.previousLastEscalationRuleExecutedAt
+        ? data.previousLastEscalationRuleExecutedAt
+        : IsNull(),
+    };
+
+    const result: UpdateResult = await this.getRepository().update(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      whereClause as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      {
+        lastEscalationRuleExecutedAt: data.newLastEscalationRuleExecutedAt,
+      } as any,
+    );
+
+    return (result.affected || 0) > 0;
+  }
+
   @CaptureSpan()
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,

package/Server/Services/OnCallDutyPolicyScheduleLayerService.ts

@@ -8,6 +8,12 @@ import LIMIT_MAX from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
+import Recurring from "../../Types/Events/Recurring";
+import RestrictionTimes, {
+  RestrictionType,
+} from "../../Types/OnCallDutyPolicy/RestrictionTimes";
+import OneUptimeDate from "../../Types/Date";
+import UpdateBy from "../Types/Database/UpdateBy";
 import Model from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayer";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
@@ -17,6 +23,90 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  /*
+   * A rotation interval count of 0 / NaN / negative breaks the handoff math
+   * (division by zero, Invalid Date), so reject it at the persistence boundary.
+   * The client also guards this, and the engine defensively clamps, but a raw
+   * API write must not be able to store an invalid rotation.
+   */
+  private validateRotationInterval(rotation: unknown): void {
+    if (!rotation || typeof rotation === "function") {
+      return;
+    }
+
+    let count: number;
+    try {
+      const recurring: Recurring =
+        rotation instanceof Recurring
+          ? rotation
+          : Recurring.fromJSON(rotation as any);
+      count = recurring.intervalCount.toNumber();
+    } catch {
+      throw new BadDataException("Invalid rotation configuration.");
+    }
+
+    if (
+      !Number.isFinite(count) ||
+      isNaN(count) ||
+      !Number.isInteger(count) ||
+      count < 1
+    ) {
+      throw new BadDataException(
+        "Rotation interval must be a whole number greater than or equal to 1.",
+      );
+    }
+  }
+
+  /*
+   * Reject a zero-length Daily restriction window (From == To time-of-day) at the
+   * persistence boundary. Such a window is active 0 seconds/day, so the layer
+   * silently pages nobody for its coverage. The dashboard already blocks this
+   * (audit F22), but a raw API write bypasses the form — so guard server-side
+   * too. Compares UTC time-of-day, which is stable regardless of server zone.
+   */
+  private validateRestrictionTimes(restrictionTimes: unknown): void {
+    if (!restrictionTimes || typeof restrictionTimes === "function") {
+      return;
+    }
+
+    let parsed: RestrictionTimes;
+    try {
+      parsed =
+        restrictionTimes instanceof RestrictionTimes
+          ? restrictionTimes
+          : RestrictionTimes.fromJSON(restrictionTimes as any);
+    } catch {
+      // Malformed input is handled elsewhere; nothing to validate here.
+      return;
+    }
+
+    if (
+      parsed.restictionType === RestrictionType.Daily &&
+      parsed.dayRestrictionTimes &&
+      parsed.dayRestrictionTimes.startTime &&
+      parsed.dayRestrictionTimes.endTime
+    ) {
+      const start: Date = OneUptimeDate.fromString(
+        parsed.dayRestrictionTimes.startTime as any,
+      );
+      const end: Date = OneUptimeDate.fromString(
+        parsed.dayRestrictionTimes.endTime as any,
+      );
+
+      const timeOfDay: (d: Date) => number = (d: Date): number => {
+        return (
+          d.getUTCHours() * 3600 + d.getUTCMinutes() * 60 + d.getUTCSeconds()
+        );
+      };
+
+      if (timeOfDay(start) === timeOfDay(end)) {
+        throw new BadDataException(
+          "Daily restriction 'From' and 'To' times cannot be the same. Choose a window with a positive duration, or set restrictions to None for 24/7 coverage.",
+        );
+      }
+    }
+  }
+
   @CaptureSpan()
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
@@ -25,6 +115,9 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("onCallDutyPolicyScheduleId is required");
     }
 
+    this.validateRotationInterval(createBy.data.rotation);
+    this.validateRestrictionTimes(createBy.data.restrictionTimes);
+
     if (!createBy.data.order) {
       // count number of users in this layer.
 
@@ -77,6 +170,19 @@ export class Service extends DatabaseService<Model> {
     return createdItem;
   }
 
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    this.validateRotationInterval(updateBy.data.rotation);
+    this.validateRestrictionTimes(updateBy.data.restrictionTimes);
+
+    return {
+      updateBy,
+      carryForward: null,
+    };
+  }
+
   protected override async onUpdateSuccess(
     _onUpdate: OnUpdate<Model>,
     updatedItemIds: Array<ObjectID>,
@@ -107,6 +213,48 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    /*
+     * Capture the layer's order + schedule id as carryForward so onDeleteSuccess
+     * can re-sequence the remaining layers AND refresh the schedule roster after
+     * a layer is removed. Without this hook, onDeleteSuccess (which gates all of
+     * its work on onDelete.carryForward) was dead code: deleting a layer never
+     * re-sequenced order and never called
+     * refreshCurrentUserIdAndHandoffTimeInSchedule, so the schedule kept showing
+     * the removed layer's user as on-call and the genuinely-now-on-call user got
+     * no handoff notification for up to a full rotation period (audit F3).
+     * Mirrors OnCallDutyPolicyScheduleLayerUserService.onBeforeDelete.
+     */
+    if (!deleteBy.query._id && !deleteBy.props.isRoot) {
+      throw new BadDataException(
+        "_id should be present when deleting a schedule layer. Please try the delete with objectId",
+      );
+    }
+
+    let resource: Model | null = null;
+
+    if (!deleteBy.props.isRoot) {
+      resource = await this.findOneBy({
+        query: deleteBy.query,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          order: true,
+          onCallDutyPolicyScheduleId: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: resource,
+    };
+  }
+
   @CaptureSpan()
   protected override async onDeleteSuccess(
     onDelete: OnDelete<Model>,

package/Server/Services/OnCallDutyPolicyScheduleLayerUserService.ts

@@ -247,8 +247,17 @@ export class Service extends DatabaseService<Model> {
         // moving down.
 
         for (const resource of resources) {
-          if (resource.order! <= newOrder) {
-            // increment order.
+          /*
+           * Only shift rows strictly BETWEEN the old and new position. The lower
+           * bound (order > currentOrder) was missing, so every row above the
+           * moved user was also decremented — driving the top row's order to 0
+           * (and negative after repeated down-drags) and opening a gap at 1,
+           * breaking the 1-based contiguous invariant that create-default
+           * (count+1) and delete re-sequencing rely on (audit L3). Mirrors the
+           * double-bounded moving-up branch above.
+           */
+          if (resource.order! <= newOrder && resource.order! > currentOrder) {
+            // decrement order.
             await this.updateOneBy({
               query: {
                 _id: resource._id!,