@oneuptime/common 13.0.4 → 13.0.6

package/Server/Services/StatusPageOwnerRuleEngineService.ts

@@ -2,15 +2,47 @@ import Label from "../../Models/DatabaseModels/Label";
 import StatusPage from "../../Models/DatabaseModels/StatusPage";
 import StatusPageOwnerRule from "../../Models/DatabaseModels/StatusPageOwnerRule";
 import StatusPageOwnerRuleService from "./StatusPageOwnerRuleService";
+import StatusPageOwnerTeamService from "./StatusPageOwnerTeamService";
+import StatusPageOwnerUserService from "./StatusPageOwnerUserService";
 import StatusPageService from "./StatusPageService";
 import ObjectID from "../../Types/ObjectID";
+import Select from "../Types/Database/Select";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import OwnerRuleAssignment, {
+  OwnersToAssign,
+} from "../Utils/Rules/OwnerRuleAssignment";
+import {
+  ApplyRulesToExistingResourceData,
+  RuleApplicationResult,
+  RuleApplicationResultUtil,
+  RuleRunEngine,
+} from "../Utils/Rules/RuleRun/RuleApplication";
+
+class StatusPageOwnerRuleEngineServiceClass
+  implements RuleRunEngine<StatusPage, StatusPageOwnerRule>
+{
+  public readonly ruleSelect: Select<StatusPageOwnerRule> = {
+    _id: true,
+    name: true,
+    criteria: true,
+    notifyOwners: true,
+    statusPageLabels: { _id: true },
+    statusPageNamePattern: true,
+    statusPageDescriptionPattern: true,
+    ownerUsers: { _id: true },
+    ownerTeams: { _id: true },
+  };
+
+  // Evaluation re-reads the status page, so a run only has to name it.
+  public readonly resourceSelectForRuleRun: Select<StatusPage> = {
+    _id: true,
+    projectId: true,
+  };
 
-class StatusPageOwnerRuleEngineServiceClass {
   /**
    * Evaluates StatusPageOwnerRule rows for the given status page and adds
    * matched owner users / teams via StatusPageService.addOwners. Rules with
@@ -31,17 +63,7 @@ class StatusPageOwnerRuleEngineServiceClass {
             isEnabled: true,
           },
           props: { isRoot: true },
-          select: {
-            _id: true,
-            name: true,
-            criteria: true,
-            notifyOwners: true,
-            statusPageLabels: { _id: true },
-            statusPageNamePattern: true,
-            statusPageDescriptionPattern: true,
-            ownerUsers: { _id: true },
-            ownerTeams: { _id: true },
-          },
+          select: this.ruleSelect,
           limit: MAX_RULES_EVALUATED_PER_PROJECT,
           skip: 0,
         });
@@ -56,107 +78,196 @@ class StatusPageOwnerRuleEngineServiceClass {
         return;
       }
 
-      const usersByNotify: Map<boolean, Set<string>> = new Map([
-        [true, new Set()],
-        [false, new Set()],
-      ]);
-      const teamsByNotify: Map<boolean, Set<string>> = new Map([
-        [true, new Set()],
-        [false, new Set()],
-      ]);
-
-      const matchedRules: Array<StatusPageOwnerRule> = [];
-      const allUserIds: Set<string> = new Set();
-      const allTeamIds: Set<string> = new Set();
-
-      const statusPageWithDetails: StatusPage | null =
-        await StatusPageService.findOneById({
-          id: statusPage.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+      await this.applyRules({
+        statusPage: statusPage,
+        rules: rules,
+        allowOwnerNotification: true,
+      });
+    } catch (error) {
+      logger.error(`Error applying status page owner rules: ${error}`, {
+        projectId: statusPage.projectId?.toString(),
+        statusPageId: statusPage.id?.toString(),
+      } as LogAttributes);
+    }
+  }
 
-      if (!statusPageWithDetails) {
-        return;
-      }
+  /*
+   * "Run now": the same evaluation, for a status page that already exists and
+   * only the rules being run.
+   */
+  @CaptureSpan()
+  public async applyRulesToExistingResource(
+    data: ApplyRulesToExistingResourceData<StatusPage, StatusPageOwnerRule>,
+  ): Promise<RuleApplicationResult> {
+    try {
+      return await this.applyRules({
+        statusPage: data.resource,
+        rules: data.rules,
+        allowOwnerNotification: data.allowOwnerNotification,
+      });
+    } catch (error) {
+      logger.error(`Error running status page owner rules: ${error}`, {
+        projectId: data.resource.projectId?.toString(),
+        statusPageId: data.resource.id?.toString(),
+      } as LogAttributes);
 
-      for (const rule of rules) {
-        const matches: boolean = this.doesStatusPageMatchRule(
-          statusPageWithDetails,
-          rule,
-        );
-        if (!matches) {
-          continue;
-        }
-        let ruleAddedAny: boolean = false;
-        const notify: boolean = rule.notifyOwners !== false;
-        for (const user of rule.ownerUsers || []) {
-          if (user.id) {
-            usersByNotify.get(notify)!.add(user.id.toString());
-            allUserIds.add(user.id.toString());
-            ruleAddedAny = true;
-          }
-        }
-        for (const team of rule.ownerTeams || []) {
-          if (team.id) {
-            teamsByNotify.get(notify)!.add(team.id.toString());
-            allTeamIds.add(team.id.toString());
-            ruleAddedAny = true;
-          }
+      return RuleApplicationResultUtil.failed();
+    }
+  }
+
+  private async applyRules(data: {
+    statusPage: StatusPage;
+    rules: Array<StatusPageOwnerRule>;
+    allowOwnerNotification: boolean;
+  }): Promise<RuleApplicationResult> {
+    const { statusPage, rules } = data;
+
+    if (!statusPage.id || !statusPage.projectId || rules.length === 0) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    const usersByNotify: Map<boolean, Set<string>> = new Map([
+      [true, new Set()],
+      [false, new Set()],
+    ]);
+    const teamsByNotify: Map<boolean, Set<string>> = new Map([
+      [true, new Set()],
+      [false, new Set()],
+    ]);
+
+    const matchedRules: Array<StatusPageOwnerRule> = [];
+    const allUserIds: Set<string> = new Set();
+    const allTeamIds: Set<string> = new Set();
+
+    const statusPageWithDetails: StatusPage | null =
+      await StatusPageService.findOneById({
+        id: statusPage.id,
+        select: {
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+        props: { isRoot: true },
+      });
+
+    if (!statusPageWithDetails) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    let anyRuleMatched: boolean = false;
+
+    for (const rule of rules) {
+      const matches: boolean = this.doesStatusPageMatchRule(
+        statusPageWithDetails,
+        rule,
+      );
+      if (!matches) {
+        continue;
+      }
+      anyRuleMatched = true;
+      let ruleAddedAny: boolean = false;
+      const notify: boolean =
+        rule.notifyOwners !== false && data.allowOwnerNotification;
+      for (const user of rule.ownerUsers || []) {
+        if (user.id) {
+          usersByNotify.get(notify)!.add(user.id.toString());
+          allUserIds.add(user.id.toString());
+          ruleAddedAny = true;
         }
-        if (ruleAddedAny) {
-          matchedRules.push(rule);
+      }
+      for (const team of rule.ownerTeams || []) {
+        if (team.id) {
+          teamsByNotify.get(notify)!.add(team.id.toString());
+          allTeamIds.add(team.id.toString());
+          ruleAddedAny = true;
         }
       }
-
-      if (matchedRules.length === 0) {
-        return;
+      if (ruleAddedAny) {
+        matchedRules.push(rule);
       }
+    }
 
-      if (allUserIds.size === 0 && allTeamIds.size === 0) {
-        return;
-      }
+    if (!anyRuleMatched) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-      for (const notify of [true, false]) {
-        const userIds: Array<ObjectID> = Array.from(
-          usersByNotify.get(notify)!,
-        ).map((id: string) => {
-          return new ObjectID(id);
-        });
-        const teamIds: Array<ObjectID> = Array.from(
-          teamsByNotify.get(notify)!,
-        ).map((id: string) => {
-          return new ObjectID(id);
-        });
+    if (
+      matchedRules.length === 0 ||
+      (allUserIds.size === 0 && allTeamIds.size === 0)
+    ) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
 
-        if (userIds.length === 0 && teamIds.length === 0) {
-          continue;
-        }
+    // Owners already on the status page are skipped rather than duplicated.
+    const notYetAssigned: OwnersToAssign =
+      await OwnerRuleAssignment.getOwnersNotYetAssigned({
+        ownerUserService: StatusPageOwnerUserService,
+        ownerTeamService: StatusPageOwnerTeamService,
+        resourceIdColumn: "statusPageId",
+        resourceId: statusPage.id,
+        userIds: Array.from(allUserIds),
+        teamIds: Array.from(allTeamIds),
+      });
+
+    const userIdsToAdd: Set<string> = new Set(
+      notYetAssigned.userIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+    const teamIdsToAdd: Set<string> = new Set(
+      notYetAssigned.teamIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+
+    let ownersAdded: number = 0;
 
-        await StatusPageService.addOwners(
-          statusPage.projectId,
-          statusPage.id,
-          userIds,
-          teamIds,
-          notify,
-          { isRoot: true },
-        );
+    /*
+     * The notifying set goes first, so an owner two matching rules disagree
+     * about is added once, and notified.
+     */
+    for (const notify of [true, false]) {
+      const userIds: Array<string> = Array.from(
+        usersByNotify.get(notify)!,
+      ).filter((id: string) => {
+        return userIdsToAdd.delete(id);
+      });
+      const teamIds: Array<string> = Array.from(
+        teamsByNotify.get(notify)!,
+      ).filter((id: string) => {
+        return teamIdsToAdd.delete(id);
+      });
+
+      if (userIds.length === 0 && teamIds.length === 0) {
+        continue;
       }
 
-      logger.debug(
-        `StatusPageOwnerRuleEngine added owners to status page ${statusPage.id}`,
-        { projectId: statusPage.projectId.toString() } as LogAttributes,
+      await StatusPageService.addOwners(
+        statusPage.projectId,
+        statusPage.id,
+        userIds.map((id: string) => {
+          return new ObjectID(id);
+        }),
+        teamIds.map((id: string) => {
+          return new ObjectID(id);
+        }),
+        notify,
+        { isRoot: true },
       );
-    } catch (error) {
-      logger.error(`Error applying status page owner rules: ${error}`, {
-        projectId: statusPage.projectId?.toString(),
-        statusPageId: statusPage.id?.toString(),
-      } as LogAttributes);
+
+      ownersAdded += userIds.length + teamIds.length;
     }
+
+    if (ownersAdded === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
+
+    logger.debug(
+      `StatusPageOwnerRuleEngine added owners to status page ${statusPage.id}`,
+      { projectId: statusPage.projectId.toString() } as LogAttributes,
+    );
+
+    return RuleApplicationResultUtil.updated(ownersAdded);
   }
 
   private doesStatusPageMatchRule(

package/Server/Services/StatusPageSubscriberNotificationTemplateService.ts

@@ -5,7 +5,9 @@ import ObjectID from "../../Types/ObjectID";
 import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
 import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
 import StatusPageSubscriberNotificationTemplateStatusPageService from "./StatusPageSubscriberNotificationTemplateStatusPageService";
-import BadDataException from "../../Types/Exception/BadDataException";
+import SubscriberNotificationTemplateVariables, {
+  SubscriberNotificationTemplateVariable,
+} from "../../Types/StatusPage/SubscriberNotificationTemplateVariables";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -94,250 +96,44 @@ export class Service extends DatabaseService<Model> {
   /**
    * Get available variables for a specific event type.
    * These variables can be used in templates with {{variableName}} syntax.
+   * The list lives in SubscriberNotificationTemplateVariables, which has no
+   * database dependencies, so workers' tests and the dashboard can read it.
    */
   public static getAvailableVariablesForEventType(
     eventType: StatusPageSubscriberNotificationEventType,
-  ): Array<{ name: string; description: string }> {
-    const commonVariables: Array<{ name: string; description: string }> = [
-      { name: "statusPageName", description: "Name of the status page" },
-      { name: "statusPageUrl", description: "URL of the status page" },
-      {
-        name: "unsubscribeUrl",
-        description: "URL to unsubscribe from notifications",
-      },
-      { name: "resourcesAffected", description: "List of affected resources" },
-    ];
-
-    switch (eventType) {
-      case StatusPageSubscriberNotificationEventType.SubscriberIncidentCreated:
-        return [
-          ...commonVariables,
-          { name: "incidentTitle", description: "Title of the incident" },
-          {
-            name: "incidentDescription",
-            description: "Description of the incident",
-          },
-          { name: "incidentSeverity", description: "Severity of the incident" },
-          { name: "detailsUrl", description: "URL to view incident details" },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberIncidentStateChanged:
-        return [
-          ...commonVariables,
-          { name: "incidentTitle", description: "Title of the incident" },
-          {
-            name: "incidentDescription",
-            description: "Description of the incident",
-          },
-          { name: "incidentSeverity", description: "Severity of the incident" },
-          {
-            name: "incidentState",
-            description: "Current state of the incident",
-          },
-          { name: "detailsUrl", description: "URL to view incident details" },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberIncidentNoteCreated:
-        return [
-          ...commonVariables,
-          { name: "incidentTitle", description: "Title of the incident" },
-          { name: "incidentSeverity", description: "Severity of the incident" },
-          {
-            name: "incidentState",
-            description: "Current state of the incident",
-          },
-          { name: "postedAt", description: "When the note was posted" },
-          { name: "note", description: "Content of the note" },
-          { name: "detailsUrl", description: "URL to view incident details" },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberIncidentPostmortemPublished:
-        return [
-          ...commonVariables,
-          { name: "incidentTitle", description: "Title of the incident" },
-          { name: "incidentSeverity", description: "Severity of the incident" },
-          {
-            name: "postmortemNote",
-            description: "Content of the postmortem note",
-          },
-          { name: "detailsUrl", description: "URL to view incident details" },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberAnnouncementCreated:
-        return [
-          ...commonVariables,
-          {
-            name: "announcementTitle",
-            description: "Title of the announcement",
-          },
-          {
-            name: "announcementDescription",
-            description: "Description of the announcement",
-          },
-          {
-            name: "detailsUrl",
-            description: "URL to view announcement details",
-          },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceCreated:
-        return [
-          ...commonVariables,
-          {
-            name: "scheduledMaintenanceTitle",
-            description: "Title of the scheduled maintenance",
-          },
-          {
-            name: "scheduledMaintenanceDescription",
-            description: "Description of the scheduled maintenance",
-          },
-          {
-            name: "scheduledStartTime",
-            description: "When the maintenance is scheduled to start",
-          },
-          {
-            name: "scheduledEndTime",
-            description: "When the maintenance is scheduled to end",
-          },
-          {
-            name: "detailsUrl",
-            description: "URL to view scheduled maintenance details",
-          },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceStateChanged:
-        return [
-          ...commonVariables,
-          {
-            name: "scheduledMaintenanceTitle",
-            description: "Title of the scheduled maintenance",
-          },
-          {
-            name: "scheduledMaintenanceDescription",
-            description: "Description of the scheduled maintenance",
-          },
-          {
-            name: "scheduledMaintenanceState",
-            description: "Current state of the scheduled maintenance",
-          },
-          {
-            name: "detailsUrl",
-            description: "URL to view scheduled maintenance details",
-          },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceNoteCreated:
-        return [
-          ...commonVariables,
-          {
-            name: "scheduledMaintenanceTitle",
-            description: "Title of the scheduled maintenance",
-          },
-          {
-            name: "scheduledMaintenanceState",
-            description: "Current state of the scheduled maintenance",
-          },
-          { name: "postedAt", description: "When the note was posted" },
-          { name: "note", description: "Content of the note" },
-          {
-            name: "detailsUrl",
-            description: "URL to view scheduled maintenance details",
-          },
-        ];
-
-      case StatusPageSubscriberNotificationEventType.SubscriberReport:
-        /*
-         * The report template is rendered through the full Handlebars engine
-         * with the structured `report` object, so the per-resource fields are
-         * accessed inside {{#each report.resources}} rather than as flat
-         * scalars. The entries below document the top-level paths.
-         */
-        return [
-          ...commonVariables,
-          {
-            name: "report.reportDates",
-            description: "The reporting period as a range",
-          },
-          {
-            name: "report.reportPeriodName",
-            description:
-              'How a sentence refers to the period - "the last 30 days", "July 2026"',
-          },
-          {
-            name: "report.reportStartDate",
-            description: "First day of the reporting period",
-          },
-          {
-            name: "report.reportEndDate",
-            description: "Last day of the reporting period",
-          },
-          {
-            name: "report.reportTimezone",
-            description: "The timezone the reporting period was resolved in",
-          },
-          {
-            name: "report.averageUptimePercent",
-            description: "Average uptime across all resources",
-          },
-          {
-            name: "report.totalDowntimeInHoursAndMinutes",
-            description: "Total downtime in the period",
-          },
-          {
-            name: "report.totalIncidents",
-            description: "Total number of incidents in the period",
-          },
-          {
-            name: "report.totalResources",
-            description: "Number of resources on the status page",
-          },
-          {
-            name: "report.resources",
-            description:
-              "Array of per-resource rows (resourceName, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount, groupName, groupPath) to loop over with {{#each}}",
-          },
-          {
-            name: "report.hasGroups",
-            description:
-              "true when the status page organises its resources into groups",
-          },
-          {
-            name: "report.rows",
-            description:
-              "The status page's group hierarchy flattened into render order (isGroup, name, depth, indentInPixels, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount, totalResources) to loop over with {{#each}}",
-          },
-          {
-            name: "report.groups",
-            description:
-              "The group hierarchy as a nested tree (groupName, groupPath, depth, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount, totalResources, resources, subGroups)",
-          },
-          {
-            name: "report.ungroupedResources",
-            description: "Per-resource rows for resources that are in no group",
-          },
-        ];
-
-      default:
-        throw new BadDataException(`Unknown event type: ${eventType}`);
-    }
+  ): Array<SubscriberNotificationTemplateVariable> {
+    return SubscriberNotificationTemplateVariables.getAvailableVariablesForEventType(
+      eventType,
+    );
   }
 
   /**
    * Compile a template with the given variables.
    * Replaces {{variableName}} with the actual values.
+   *
+   * One pass over the template, with a replacer function:
+   * - A replacement string would give "$&", "$$", "$`" and "$'" special
+   *   meaning, so a note mentioning "$$5" or a resource named "Store $&" was
+   *   rewritten on its way to subscribers.
+   * - Replacing one variable at a time also expanded placeholders that
+   *   appeared inside an earlier value, so a note containing
+   *   "{{unsubscribeUrl}}" came out as a link.
+   * A placeholder with no variable is left as written.
    */
   public static compileTemplate(
     template: string,
     variables: Record<string, string>,
   ): string {
-    let compiledTemplate: string = template;
-
-    for (const [key, value] of Object.entries(variables)) {
-      const regex: RegExp = new RegExp(`{{\\s*${key}\\s*}}`, "g");
-      compiledTemplate = compiledTemplate.replace(regex, value || "");
-    }
-
-    return compiledTemplate;
+    return template.replace(
+      /{{\s*([\w.]+)\s*}}/g,
+      (placeholder: string, name: string): string => {
+        if (!Object.prototype.hasOwnProperty.call(variables, name)) {
+          return placeholder;
+        }
+
+        return variables[name] || "";
+      },
+    );
   }
 }
 

package/Server/Services/StatusPageSubscriberService.ts

@@ -1400,6 +1400,12 @@ Stay informed about service availability! 🚀`;
         showAnnouncementsOnStatusPage: true,
         showIncidentsOnStatusPage: true,
         showScheduledMaintenanceEventsOnStatusPage: true,
+        /*
+         * The episode workers skip every page where this is off, and a column
+         * that is not selected reads as undefined - so leaving it out stopped
+         * every episode notification from being sent.
+         */
+        showEpisodesOnStatusPage: true,
       },
     });