@oneuptime/common 13.0.5 → 13.0.6

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -1,4 +1,5 @@
 import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
 import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
@@ -12,6 +13,7 @@ import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
 import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import SubscriberUpdateNotification from "../../Types/StatusPage/SubscriberUpdateNotification";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
@@ -50,6 +52,28 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /*
+   * An edit tells subscribers nothing unless the editor asked for it on this
+   * edit (see SubscriberUpdateNotification). When they did, queue the update
+   * notification; the ScheduledMaintenancePublicNote worker job sends it.
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    if (SubscriberUpdateNotification.isRequested(updateBy.miscDataProps)) {
+      updateBy.data.subscriberNotificationStatusOnNoteUpdated =
+        StatusPageSubscriberNotificationStatus.Pending;
+      updateBy.data.subscriberNotificationStatusMessageOnNoteUpdated =
+        SubscriberUpdateNotification.queuedMessage;
+    }
+
+    return {
+      updateBy: updateBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,

package/Server/Services/ScheduledMaintenanceService.ts

@@ -150,6 +150,19 @@ export class Service extends DatabaseService<Model> {
           }) || [],
         );
 
+      /*
+       * The description does not vary per status page or per subscriber, so
+       * it is converted once per event: HTML for email bodies, plain text for
+       * SMS and email subjects. Slack gets the Markdown as written.
+       */
+      const eventDescriptionHtml: string = await Markdown.convertToHTML(
+        event.description || "",
+        MarkdownContentType.Email,
+      );
+      const eventDescriptionPlainText: string = Markdown.convertToPlainText(
+        event.description || "",
+      );
+
       for (const statuspage of statusPages) {
         if (!statuspage.id) {
           continue;
@@ -249,7 +262,7 @@ export class Service extends DatabaseService<Model> {
               subscriber.id!,
             ).toString();
 
-          // Create template variables for custom templates
+          // Template variables for custom templates, as Markdown (Slack)
           const templateVariables: Record<string, string> = {
             statusPageName: statusPageName,
             statusPageUrl: statusPageURL,
@@ -267,12 +280,10 @@ export class Service extends DatabaseService<Model> {
             unsubscribeUrl: unsubscribeUrl,
           };
 
-          // SMS-specific template variables with plain text (no HTML/Markdown)
-          const smsTemplateVariables: Record<string, string> = {
+          // Template variables for SMS and email subjects, as plain text
+          const plainTextTemplateVariables: Record<string, string> = {
             ...templateVariables,
-            scheduledMaintenanceDescription: Markdown.convertToPlainText(
-              event.description || "",
-            ),
+            scheduledMaintenanceDescription: eventDescriptionPlainText,
           };
 
           if (subscriber.subscriberPhone) {
@@ -287,7 +298,7 @@ export class Service extends DatabaseService<Model> {
               smsMessage =
                 StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
                   smsTemplate.templateBody,
-                  smsTemplateVariables,
+                  plainTextTemplateVariables,
                 );
             } else {
               // Use default template
@@ -411,10 +422,7 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                   use12HourFormat: true,
                 }),
               eventTitle: event.title || "",
-              eventDescription: await Markdown.convertToHTML(
-                event.description || "",
-                MarkdownContentType.Email,
-              ),
+              eventDescription: eventDescriptionHtml,
               unsubscribeUrl: unsubscribeUrl,
             };
 
@@ -424,16 +432,37 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
               emailTemplate.templateBody &&
               statuspage.smtpConfig
             ) {
-              // Use custom template with BlankTemplate only when custom SMTP is configured
+              /*
+               * Use custom template with BlankTemplate only when custom SMTP
+               * is configured. The body is HTML, so the description is too.
+               * The subject is plain text, including the email-only
+               * variables that are HTML in the body.
+               */
               const customEmailBody: string =
                 StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
                   emailTemplate.templateBody,
-                  { ...templateVariables, ...emailVars },
+                  {
+                    ...templateVariables,
+                    ...emailVars,
+                    scheduledMaintenanceDescription: eventDescriptionHtml,
+                  },
                 );
               const customEmailSubject: string = emailTemplate.emailSubject
                 ? StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
                     emailTemplate.emailSubject,
-                    { ...templateVariables, ...emailVars },
+                    {
+                      ...emailVars,
+                      ...plainTextTemplateVariables,
+                      eventDescription: eventDescriptionPlainText,
+                      scheduledAt:
+                        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones(
+                          {
+                            date: event.startsAt!,
+                            timezones: statuspage.subscriberTimezones || [],
+                            use12HourFormat: true,
+                          },
+                        ).join(", "),
+                    },
                   )
                 : "[Scheduled Maintenance] " + (event.title || statusPageName);
 

package/Server/Services/SecurityEventConnectionService.ts

@@ -59,6 +59,13 @@ export class Service extends DatabaseService<Model> {
    * Keys are the catalog's; values are strings, numbers or booleans. Unknown
    * keys are rejected rather than stored, so a typo in a field key cannot
    * silently become "the setting was never provided".
+   *
+   * A "json" field (a Google Cloud service-account key) holds the JSON
+   * document as the text that was pasted. It must parse to an object, so a
+   * truncated paste is a form error rather than a poll that fails forever,
+   * but it is stored and handed to the connector as that string, never as
+   * a parsed object: the secrets blob only holds scalar values and the
+   * connector parses the document itself.
    */
   public static validateFields(data: {
     definition: SecurityEventConnectorDefinition;
@@ -67,14 +74,16 @@ export class Service extends DatabaseService<Model> {
     label: string;
     requireRequiredFields: boolean;
   }): void {
-    const knownKeys: Set<string> = new Set(
-      data.fields.map((field: ConnectorField): string => {
-        return field.key;
+    const fieldsByKey: Map<string, ConnectorField> = new Map(
+      data.fields.map((field: ConnectorField): [string, ConnectorField] => {
+        return [field.key, field];
       }),
     );
 
     for (const key of Object.keys(data.values)) {
-      if (!knownKeys.has(key)) {
+      const field: ConnectorField | undefined = fieldsByKey.get(key);
+
+      if (!field) {
         throw new BadDataException(
           `${data.label} contains an unknown setting "${key}" for ${data.definition.title}.`,
         );
@@ -82,6 +91,22 @@ export class Service extends DatabaseService<Model> {
 
       const value: JSONValue = data.values[key] as JSONValue;
 
+      if (
+        field.type === "json" &&
+        value !== null &&
+        value !== undefined &&
+        typeof value === "object"
+      ) {
+        /*
+         * An API client, or a form that converted its editor's text, sent
+         * the document already parsed. "Must be a JSON object" would read
+         * as nonsense for an object, so name the shape that is expected.
+         */
+        throw new BadDataException(
+          `${field.title} must be sent as JSON text (a string), not as a parsed object.`,
+        );
+      }
+
       if (
         value !== null &&
         value !== undefined &&
@@ -138,6 +163,10 @@ export class Service extends DatabaseService<Model> {
         throw new BadDataException(`${field.title} must be true or false.`);
       }
 
+      if (field.type === "json" && !Service.isJsonObjectText(raw)) {
+        throw new BadDataException(`${field.title} must be a JSON object.`);
+      }
+
       if (field.type === "url") {
         let parsed: URL;
 
@@ -164,6 +193,29 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  /*
+   * True for text that parses to a JSON object. An array, a scalar or text
+   * that is not JSON at all cannot be a service-account key, and neither
+   * can a value that is not text (see validateFields).
+   */
+  private static isJsonObjectText(value: unknown): boolean {
+    if (typeof value !== "string") {
+      return false;
+    }
+
+    let parsed: unknown;
+
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      return false;
+    }
+
+    return (
+      Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed)
+    );
+  }
+
   /*
    * Tenant-chosen hosts go through the same egress policy every other
    * outbound connector uses. Validated here so a blocked address is a

package/Server/Services/ServerlessFunctionLabelRuleEngineService.ts

@@ -4,13 +4,38 @@ import ServerlessFunctionLabelRule from "../../Models/DatabaseModels/ServerlessF
 import ServerlessFunctionLabelRuleService from "./ServerlessFunctionLabelRuleService";
 import ServerlessFunctionService from "./ServerlessFunctionService";
 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 {
+  ApplyRulesToExistingResourceData,
+  RuleApplicationResult,
+  RuleApplicationResultUtil,
+  RuleRunEngine,
+} from "../Utils/Rules/RuleRun/RuleApplication";
+
+class ServerlessFunctionLabelRuleEngineServiceClass
+  implements RuleRunEngine<ServerlessFunction, ServerlessFunctionLabelRule>
+{
+  public readonly ruleSelect: Select<ServerlessFunctionLabelRule> = {
+    _id: true,
+    name: true,
+    criteria: true,
+    matchLabels: { _id: true },
+    nameRegexPattern: true,
+    descriptionRegexPattern: true,
+    labelsToAdd: { _id: true },
+  };
+
+  // Evaluation re-reads the function, so a run only has to name it.
+  public readonly resourceSelectForRuleRun: Select<ServerlessFunction> = {
+    _id: true,
+    projectId: true,
+  };
 
-class ServerlessFunctionLabelRuleEngineServiceClass {
   /**
    * Evaluates ServerlessFunctionLabelRule rows for the given function and
    * attaches matched labels. The union is deduped against labels already on
@@ -32,15 +57,7 @@ class ServerlessFunctionLabelRuleEngineServiceClass {
             isEnabled: true,
           },
           props: { isRoot: true },
-          select: {
-            _id: true,
-            name: true,
-            criteria: true,
-            matchLabels: { _id: true },
-            nameRegexPattern: true,
-            descriptionRegexPattern: true,
-            labelsToAdd: { _id: true },
-          },
+          select: this.ruleSelect,
           limit: MAX_RULES_EVALUATED_PER_PROJECT,
           skip: 0,
         });
@@ -55,80 +72,132 @@ class ServerlessFunctionLabelRuleEngineServiceClass {
         return;
       }
 
-      const fnWithDetails: ServerlessFunction | null =
-        await ServerlessFunctionService.findOneById({
-          id: serverlessFunction.id,
-          select: {
-            name: true,
-            description: true,
-            labels: { _id: true },
-          },
-          props: { isRoot: true },
-        });
+      await this.applyRules({
+        serverlessFunction: serverlessFunction,
+        rules: rules,
+      });
+    } catch (error) {
+      logger.error(`Error applying serverless function label rules: ${error}`, {
+        projectId: serverlessFunction.projectId?.toString(),
+        serverlessFunctionId: serverlessFunction.id?.toString(),
+      } as LogAttributes);
+    }
+  }
 
-      if (!fnWithDetails) {
-        return;
-      }
+  /*
+   * "Run now": the same evaluation, for a function that already exists and
+   * only the rules being run.
+   */
+  @CaptureSpan()
+  public async applyRulesToExistingResource(
+    data: ApplyRulesToExistingResourceData<
+      ServerlessFunction,
+      ServerlessFunctionLabelRule
+    >,
+  ): Promise<RuleApplicationResult> {
+    try {
+      return await this.applyRules({
+        serverlessFunction: data.resource,
+        rules: data.rules,
+      });
+    } catch (error) {
+      logger.error(`Error running serverless function label rules: ${error}`, {
+        projectId: data.resource.projectId?.toString(),
+        serverlessFunctionId: data.resource.id?.toString(),
+      } as LogAttributes);
 
-      const labelIdsToAdd: Set<string> = new Set();
+      return RuleApplicationResultUtil.failed();
+    }
+  }
 
-      for (const rule of rules) {
-        if (!this.doesMatchRule(fnWithDetails, rule)) {
-          continue;
-        }
-        for (const label of rule.labelsToAdd || []) {
-          if (label.id) {
-            labelIdsToAdd.add(label.id.toString());
-          }
+  private async applyRules(data: {
+    serverlessFunction: ServerlessFunction;
+    rules: Array<ServerlessFunctionLabelRule>;
+  }): Promise<RuleApplicationResult> {
+    const { serverlessFunction, rules } = data;
+
+    if (
+      !serverlessFunction.id ||
+      !serverlessFunction.projectId ||
+      rules.length === 0
+    ) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    const fnWithDetails: ServerlessFunction | null =
+      await ServerlessFunctionService.findOneById({
+        id: serverlessFunction.id,
+        select: {
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+        props: { isRoot: true },
+      });
+
+    if (!fnWithDetails) {
+      return RuleApplicationResultUtil.noMatch();
+    }
+
+    const labelIdsToAdd: Set<string> = new Set();
+    let anyRuleMatched: boolean = false;
+
+    for (const rule of rules) {
+      if (!this.doesMatchRule(fnWithDetails, rule)) {
+        continue;
+      }
+      anyRuleMatched = true;
+      for (const label of rule.labelsToAdd || []) {
+        if (label.id) {
+          labelIdsToAdd.add(label.id.toString());
         }
       }
+    }
 
-      if (labelIdsToAdd.size === 0) {
-        return;
-      }
+    if (!anyRuleMatched) {
+      return RuleApplicationResultUtil.noMatch();
+    }
 
-      const existingLabelIds: Set<string> = new Set(
-        (fnWithDetails.labels || [])
-          .map((l: Label) => {
-            return l.id?.toString() || "";
-          })
-          .filter((id: string) => {
-            return id !== "";
-          }),
-      );
+    if (labelIdsToAdd.size === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
+    }
 
-      const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
-        (id: string) => {
-          return !existingLabelIds.has(id);
-        },
-      );
-      if (newLabelIds.length === 0) {
-        return;
-      }
+    const existingLabelIds: Set<string> = new Set(
+      (fnWithDetails.labels || [])
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id !== "";
+        }),
+    );
 
-      await ServerlessFunctionService.getRepository()
-        .createQueryBuilder()
-        .relation(ServerlessFunction, "labels")
-        .of(serverlessFunction.id.toString())
-        .add(newLabelIds);
-
-      const mergedLabelIds: Set<string> = new Set([
-        ...existingLabelIds,
-        ...newLabelIds,
-      ]);
-      serverlessFunction.labels = Array.from(mergedLabelIds).map(
-        (id: string) => {
-          const label: Label = new Label();
-          label.id = new ObjectID(id);
-          return label;
-        },
-      );
-    } catch (error) {
-      logger.error(`Error applying serverless function label rules: ${error}`, {
-        projectId: serverlessFunction.projectId?.toString(),
-        serverlessFunctionId: serverlessFunction.id?.toString(),
-      } as LogAttributes);
+    const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
+      (id: string) => {
+        return !existingLabelIds.has(id);
+      },
+    );
+    if (newLabelIds.length === 0) {
+      return RuleApplicationResultUtil.alreadyApplied();
     }
+
+    await ServerlessFunctionService.getRepository()
+      .createQueryBuilder()
+      .relation(ServerlessFunction, "labels")
+      .of(serverlessFunction.id.toString())
+      .add(newLabelIds);
+
+    const mergedLabelIds: Set<string> = new Set([
+      ...existingLabelIds,
+      ...newLabelIds,
+    ]);
+    serverlessFunction.labels = Array.from(mergedLabelIds).map((id: string) => {
+      const label: Label = new Label();
+      label.id = new ObjectID(id);
+      return label;
+    });
+
+    return RuleApplicationResultUtil.updated(newLabelIds.length);
   }
 
   private doesMatchRule(