@oneuptime/common 14.0.6 → 14.0.8

package/Server/Services/StatusPageService.ts

@@ -63,7 +63,8 @@ import MonitorGroupResource from "../../Models/DatabaseModels/MonitorGroupResour
 import MonitorGroupService from "./MonitorGroupService";
 import QueryHelper from "../Types/Database/QueryHelper";
 import OneUptimeDate from "../../Types/Date";
-import IncidentService from "./IncidentService";
+import IncidentStatusPageScope from "../Utils/StatusPage/IncidentStatusPageScope";
+import Select from "../Types/Database/Select";
 import MonitorStatusTimeline from "../../Models/DatabaseModels/MonitorStatusTimeline";
 import MonitorStatusTimelineService, {
   MergedDowntimeTotals,
@@ -122,6 +123,17 @@ export const STATUS_PAGE_SSO_REQUIREMENT_COLUMNS: ReadonlyArray<string> = [
   "requireSsoForLogin",
 ];
 
+/*
+ * What a report's incident counts read of the status page: which project's
+ * incidents to count, and whether the page only shows incidents limited to
+ * it (IncidentStatusPageScope decides from that which incidents count).
+ */
+export const INCIDENT_COUNT_STATUS_PAGE_SELECT: Select<StatusPage> = {
+  _id: true,
+  projectId: true,
+  onlyShowScopedIncidents: true,
+};
+
 export class Service extends DatabaseService<StatusPage> {
   /*
    * Caches the resolved status page URL per statusPageId. `getStatusPageURL`
@@ -1393,7 +1405,7 @@ export class Service extends DatabaseService<StatusPage> {
         const unsubscribeUrl: string =
           StatusPageSubscriberService.getUnsubscribeLink(
             URL.fromString(statusPageURL),
-            subscriber.id!,
+            subscriber,
           ).toString();
 
         if (subscriber.subscriberEmail) {
@@ -1432,6 +1444,8 @@ export class Service extends DatabaseService<StatusPage> {
       },
       select: {
         downtimeMonitorStatuses: true,
+        // What the incident counts below are scoped by.
+        ...INCIDENT_COUNT_STATUS_PAGE_SELECT,
       },
     });
 
@@ -1499,7 +1513,7 @@ export class Service extends DatabaseService<StatusPage> {
     }
 
     const incidentCount: number = await this.getIncidentCountOnStatusPage({
-      statusPageId: data.statusPageId,
+      statusPage: statusPage,
       startDate: startDate,
       endDate: endDate,
     });
@@ -1661,6 +1675,7 @@ export class Service extends DatabaseService<StatusPage> {
         reportItem: {
           resourceName: resource.displayName || "",
           totalIncidentCount: await this.getIncidentCountByMonitorIds({
+            statusPage: statusPage,
             monitorIds: monitorIdsForThisResource,
             startDate: startDate,
             endDate: endDate,
@@ -1710,6 +1725,7 @@ export class Service extends DatabaseService<StatusPage> {
 
     const groupMetricsByGroupId: Dictionary<StatusPageReportGroupMetrics> =
       await this.getReportGroupMetrics({
+        statusPage: statusPage,
         statusPageGroups: statusPageGroups,
         entries: entries,
         monitorIdsByResourceIndex: monitorIdsByResourceIndex,
@@ -1817,6 +1833,11 @@ export class Service extends DatabaseService<StatusPage> {
    */
   @CaptureSpan()
   public async getReportGroupMetrics(data: {
+    /*
+     * The status page the report is for, which the incident counts are
+     * scoped by: loaded with INCIDENT_COUNT_STATUS_PAGE_SELECT.
+     */
+    statusPage: StatusPage;
     statusPageGroups: Array<StatusPageGroup>;
     entries: Array<StatusPageReportResourceEntry>;
     monitorIdsByResourceIndex: Array<Array<ObjectID>>;
@@ -1913,6 +1934,7 @@ export class Service extends DatabaseService<StatusPage> {
         totalIncidentCount =
           monitorIds.length > 0
             ? await this.getIncidentCountByMonitorIds({
+                statusPage: data.statusPage,
                 monitorIds: monitorIds,
                 startDate: data.reportWindow.startDate,
                 endDate: data.reportWindow.endDate,
@@ -1963,13 +1985,41 @@ export class Service extends DatabaseService<StatusPage> {
     });
   }
 
+  /*
+   * How many incidents the status page shows on these monitors, created in
+   * the window: the report's count for a resource, a group or the page.
+   *
+   * It counts what the page shows, through IncidentStatusPageScope - an
+   * incident limited to other status pages is not counted, nor is an
+   * unlimited one on a page that only shows incidents limited to it - and
+   * only the project's incidents visible on status pages. (Before the scope,
+   * this counted every incident on the monitors, hidden ones and all.)
+   *
+   * The status page must be loaded with INCIDENT_COUNT_STATUS_PAGE_SELECT. It
+   * is passed in rather than read here because a report counts once for each
+   * resource and group.
+   */
   @CaptureSpan()
   public async getIncidentCountByMonitorIds(data: {
+    statusPage: StatusPage;
     monitorIds: Array<ObjectID>;
     startDate: Date;
     endDate: Date;
   }): Promise<number> {
-    const incidentCount: PositiveNumber = await IncidentService.countBy({
+    // No monitor, so no incident on one to count.
+    if (data.monitorIds.length === 0) {
+      return 0;
+    }
+
+    if (!data.statusPage.projectId) {
+      throw new BadDataException(
+        "Cannot count the incidents on a status page without its project.",
+      );
+    }
+
+    return await IncidentStatusPageScope.countIncidentsForStatusPage({
+      statusPage: data.statusPage,
+      projectId: data.statusPage.projectId,
       query: {
         monitors: data.monitorIds as any,
         createdAt: QueryHelper.inBetween(data.startDate, data.endDate),
@@ -1978,24 +2028,31 @@ export class Service extends DatabaseService<StatusPage> {
         isRoot: true,
       },
     });
-
-    return incidentCount.toNumber();
   }
 
+  // How many incidents the status page shows, over all of its monitors.
   @CaptureSpan()
   public async getIncidentCountOnStatusPage(data: {
-    statusPageId: ObjectID;
+    // Loaded with INCIDENT_COUNT_STATUS_PAGE_SELECT.
+    statusPage: StatusPage;
     startDate: Date;
     endDate: Date;
   }): Promise<number> {
+    if (!data.statusPage.id) {
+      throw new BadDataException(
+        "Cannot count the incidents on a status page without its id.",
+      );
+    }
+
     const monitorsOnStatusPage: {
       monitorsOnStatusPage: Array<ObjectID>;
       monitorsInGroup: Dictionary<Array<ObjectID>>;
     } = await this.getMonitorIdsOnStatusPage({
-      statusPageId: data.statusPageId,
+      statusPageId: data.statusPage.id,
     });
 
     return this.getIncidentCountByMonitorIds({
+      statusPage: data.statusPage,
       monitorIds: monitorsOnStatusPage.monitorsOnStatusPage,
       startDate: data.startDate,
       endDate: data.endDate,

package/Server/Services/StatusPageSubscriberNotificationTemplateService.ts

@@ -2,21 +2,256 @@ import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
 import StatusPageSubscriberNotificationTemplateStatusPage from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplateStatusPage";
 import ObjectID from "../../Types/ObjectID";
+import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import Query from "../Types/Database/Query";
+import QueryHelper from "../Types/Database/QueryHelper";
+import UpdateBy from "../Types/Database/UpdateBy";
+import SubscriberTemplateIncidentRecordAccess from "../Utils/StatusPage/SubscriberTemplateIncidentRecordAccess";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
 import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
 import StatusPageSubscriberNotificationTemplateStatusPageService from "./StatusPageSubscriberNotificationTemplateStatusPageService";
 import SubscriberNotificationTemplateVariables, {
   SubscriberNotificationTemplateVariable,
 } from "../../Types/StatusPage/SubscriberNotificationTemplateVariables";
+import SubscriberNotificationTemplateCompiler, {
+  SubscriberNotificationEmailBodyTemplateVariables,
+  SubscriberNotificationTextTemplateVariables,
+} from "../../Types/StatusPage/SubscriberNotificationTemplateCompiler";
+
+export type {
+  SubscriberNotificationEmailBodyTemplateVariables,
+  SubscriberNotificationTextTemplateVariables,
+};
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  /*
+   * A template's body and subject may place values from the team's incident
+   * records - {{incidentLabels}} and {{customFields.<key>}} - only when
+   * whoever writes them may read those records: the status page roles that
+   * may write templates may not (SubscriberTemplateIncidentRecordAccess).
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    SubscriberTemplateIncidentRecordAccess.assertCanPlace({
+      placeholders:
+        SubscriberNotificationTemplateVariables.getIncidentRecordPlaceholders([
+          createBy.data.templateBody,
+          createBy.data.emailSubject,
+        ]),
+      props: createBy.props,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * On an update, only what the write adds is checked: a placeholder the
+   * template already holds was allowed when it was written, so someone
+   * without incident access can still fix a typo, rename the template or
+   * move a placeholder from the subject to the body - but not add one.
+   *
+   * Pointing a template somewhere else counts as placing everything it
+   * holds: changing its channel or event type makes an admin's template
+   * send its incident records to wherever the new channel goes, and a
+   * status page role can add a Slack, Teams or webhook subscriber of its
+   * own. (Linking it to another status page is checked by
+   * StatusPageSubscriberNotificationTemplateStatusPageService.)
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    SubscriberTemplateIncidentRecordAccess.assertCanPlace({
+      placeholders: await this.getIncidentRecordPlaceholdersToCheck(updateBy),
+      props: updateBy.props,
+    });
+
+    return { updateBy, carryForward: null };
+  }
+
+  /*
+   * The incident record placeholders this update must be allowed to place,
+   * across every template it would change: those it writes into a body or
+   * subject that the template did not hold before, and, when it changes
+   * where the template is sent (its channel or event type), every one the
+   * template will hold once written. The templates are read as root and
+   * limited to the caller's project, like other update hooks: the update's
+   * own permission check has not run yet, and only narrows the rows further.
+   */
+  private async getIncidentRecordPlaceholdersToCheck(
+    updateBy: UpdateBy<Model>,
+  ): Promise<Array<string>> {
+    if (updateBy.props.isRoot || updateBy.props.isMasterAdmin) {
+      return [];
+    }
+
+    const data: {
+      templateBody?: unknown;
+      emailSubject?: unknown;
+      eventType?: unknown;
+      notificationMethod?: unknown;
+    } = updateBy.data as unknown as {
+      templateBody?: unknown;
+      emailSubject?: unknown;
+      eventType?: unknown;
+      notificationMethod?: unknown;
+    };
+    const writesBody: boolean = data.templateBody !== undefined;
+    const writesSubject: boolean = data.emailSubject !== undefined;
+    const writesTarget: boolean =
+      data.eventType !== undefined || data.notificationMethod !== undefined;
+
+    if (!writesBody && !writesSubject && !writesTarget) {
+      return [];
+    }
+
+    // Anything but text places nothing: the column check refuses it anyway.
+    const writtenBody: string | null =
+      writesBody && typeof data.templateBody === "string"
+        ? data.templateBody
+        : null;
+    const writtenSubject: string | null =
+      writesSubject && typeof data.emailSubject === "string"
+        ? data.emailSubject
+        : null;
+
+    const written: Array<string> =
+      SubscriberNotificationTemplateVariables.getIncidentRecordPlaceholders([
+        writtenBody,
+        writtenSubject,
+      ]);
+
+    if (written.length === 0 && !writesTarget) {
+      return [];
+    }
+
+    const query: Query<Model> = updateBy.props.tenantId
+      ? { ...updateBy.query, projectId: updateBy.props.tenantId }
+      : updateBy.query;
+
+    const templates: Array<Model> = await this.findBy({
+      query: query,
+      select: {
+        templateBody: true,
+        emailSubject: true,
+        eventType: true,
+        notificationMethod: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const added: Set<string> = new Set<string>();
+
+    for (const template of templates) {
+      const held: Array<string> =
+        SubscriberNotificationTemplateVariables.getIncidentRecordPlaceholders([
+          template.templateBody,
+          template.emailSubject,
+        ]);
+
+      /*
+       * Only a real change: the edit form sends the channel and event type
+       * back as they were, and a typo fix must still go through.
+       */
+      const changesTarget: boolean =
+        writesTarget &&
+        ((data.eventType !== undefined &&
+          data.eventType !== template.eventType) ||
+          (data.notificationMethod !== undefined &&
+            data.notificationMethod !== template.notificationMethod));
+
+      if (changesTarget) {
+        // Everything the template will hold goes to the new target.
+        for (const name of SubscriberNotificationTemplateVariables.getIncidentRecordPlaceholders(
+          [
+            writesBody ? writtenBody : template.templateBody,
+            writesSubject ? writtenSubject : template.emailSubject,
+          ],
+        )) {
+          added.add(name);
+        }
+
+        continue;
+      }
+
+      for (const name of written) {
+        if (!held.includes(name)) {
+          added.add(name);
+        }
+      }
+    }
+
+    return Array.from(added).sort();
+  }
+
+  /*
+   * The incident record placeholders the given templates hold, in the
+   * caller's project: what linking them to a status page places there
+   * (StatusPageSubscriberNotificationTemplateStatusPageService). Read as
+   * root, like the update hook above.
+   */
+  public async getIncidentRecordPlaceholdersHeld(data: {
+    templateIds: Array<ObjectID>;
+    projectId?: ObjectID | undefined;
+  }): Promise<Array<string>> {
+    if (data.templateIds.length === 0) {
+      return [];
+    }
+
+    const templates: Array<Model> = await this.findBy({
+      query: {
+        _id: QueryHelper.any(data.templateIds),
+        ...(data.projectId ? { projectId: data.projectId } : {}),
+      },
+      select: {
+        templateBody: true,
+        emailSubject: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const held: Set<string> = new Set<string>();
+
+    for (const template of templates) {
+      for (const name of SubscriberNotificationTemplateVariables.getIncidentRecordPlaceholders(
+        [template.templateBody, template.emailSubject],
+      )) {
+        held.add(name);
+      }
+    }
+
+    return Array.from(held).sort();
+  }
+
   /**
    * Get template for a specific status page, event type, and notification method.
    * Returns null if no custom template is found (caller should use default template).
+   *
+   * Workers call this as root, so nothing but the query below keeps one
+   * project's page from reading another project's templates. The template
+   * query is therefore narrowed to the ids this page links to AND to the
+   * page's own project. It used to ask for every template of this event type
+   * and channel across all projects, 100 at a time, and look for the linked
+   * id in memory: once more than 100 such templates existed on a shared
+   * server, the linked one could fall outside those 100 and the page's
+   * subscribers silently got the default template instead of the branded one.
    */
   public async getTemplateForStatusPage(data: {
     statusPageId: ObjectID;
@@ -25,7 +260,11 @@ export class Service extends DatabaseService<Model> {
   }): Promise<Model | null> {
     const { statusPageId, eventType, notificationMethod } = data;
 
-    // First find the template link for this status page
+    /*
+     * First find the template links for this status page. There is one per
+     * linked template, so a page has only a handful, but nothing enforces a
+     * cap - so read them all rather than risk the same truncation as above.
+     */
     const templateLinks: Array<StatusPageSubscriberNotificationTemplateStatusPage> =
       await StatusPageSubscriberNotificationTemplateStatusPageService.findBy({
         query: {
@@ -33,9 +272,13 @@ export class Service extends DatabaseService<Model> {
         },
         select: {
           statusPageSubscriberNotificationTemplateId: true,
+          projectId: true,
+          statusPage: {
+            projectId: true,
+          },
         },
         skip: 0,
-        limit: 100,
+        limit: LIMIT_PER_PROJECT,
         props: {
           isRoot: true,
         },
@@ -45,27 +288,52 @@ export class Service extends DatabaseService<Model> {
       return null;
     }
 
-    // Get the template IDs
+    const statusPageProjectId: ObjectID | undefined =
+      templateLinks.find(
+        (link: StatusPageSubscriberNotificationTemplateStatusPage) => {
+          return Boolean(link.statusPage?.projectId);
+        },
+      )?.statusPage?.projectId || undefined;
+
+    if (!statusPageProjectId) {
+      return null;
+    }
+
+    /*
+     * Only links the page's own project made count: a link row stamped with
+     * another project cannot pull that project's template onto this page.
+     */
     const templateIds: Array<ObjectID> = templateLinks
+      .filter((link: StatusPageSubscriberNotificationTemplateStatusPage) => {
+        return link.projectId?.toString() === statusPageProjectId.toString();
+      })
       .map((link: StatusPageSubscriberNotificationTemplateStatusPage) => {
         return link.statusPageSubscriberNotificationTemplateId;
       })
       .filter((id: ObjectID | undefined): id is ObjectID => {
-        return id !== undefined;
+        return id !== undefined && id !== null;
       });
 
     if (templateIds.length === 0) {
       return null;
     }
 
-    // Find the specific template matching the event type and notification method
+    /*
+     * Find the linked template for this event type and notification method.
+     * Several linked templates can match (nothing stops a page linking two
+     * for the same event and channel); the default sort returns the newest
+     * first, which is the one this method has always picked.
+     */
     const templates: Array<Model> = await this.findBy({
       query: {
+        _id: QueryHelper.any(templateIds),
+        projectId: statusPageProjectId,
         eventType: eventType,
         notificationMethod: notificationMethod,
       },
       select: {
         _id: true,
+        projectId: true,
         templateName: true,
         templateBody: true,
         emailSubject: true,
@@ -73,24 +341,13 @@ export class Service extends DatabaseService<Model> {
         notificationMethod: true,
       },
       skip: 0,
-      limit: 100,
+      limit: 1,
       props: {
         isRoot: true,
       },
     });
 
-    // Find a template that matches one of the linked template IDs
-    for (const template of templates) {
-      if (
-        templateIds.some((id: ObjectID) => {
-          return id.toString() === template._id?.toString();
-        })
-      ) {
-        return template;
-      }
-    }
-
-    return null;
+    return templates[0] || null;
   }
 
   /**
@@ -108,31 +365,36 @@ export class Service extends DatabaseService<Model> {
   }
 
   /**
-   * Compile a template with the given variables.
-   * Replaces {{variableName}} with the actual values.
+   * Compile a template for a channel that does not render HTML - an email
+   * subject, SMS, Slack or Microsoft Teams - replacing {{variableName}} with
+   * each value exactly as written.
    *
-   * 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.
+   * Never use it for the body of an email template, which is HTML: use
+   * compileEmailBodyTemplate. See SubscriberNotificationTemplateCompiler.
    */
   public static compileTemplate(
     template: string,
-    variables: Record<string, string>,
+    variables: SubscriberNotificationTextTemplateVariables,
   ): string {
-    return template.replace(
-      /{{\s*([\w.]+)\s*}}/g,
-      (placeholder: string, name: string): string => {
-        if (!Object.prototype.hasOwnProperty.call(variables, name)) {
-          return placeholder;
-        }
+    return SubscriberNotificationTemplateCompiler.compileTemplate(
+      template,
+      variables,
+    );
+  }
 
-        return variables[name] || "";
-      },
+  /**
+   * Compile the body of an EMAIL template, which is sent as HTML. Plain
+   * values are HTML-escaped; only a SafeHtml value (rendered Markdown, the
+   * date helper's HTML, the escaped resource list) is inserted as it is. See
+   * SubscriberNotificationTemplateCompiler.
+   */
+  public static compileEmailBodyTemplate(
+    template: string,
+    variables: SubscriberNotificationEmailBodyTemplateVariables,
+  ): string {
+    return SubscriberNotificationTemplateCompiler.compileEmailBodyTemplate(
+      template,
+      variables,
     );
   }
 }