@oneuptime/common 12.0.25 → 12.0.27

package/Server/Services/MonitorService.ts

@@ -44,6 +44,7 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Typeof from "../../Types/Typeof";
 import Model from "../../Models/DatabaseModels/Monitor";
+import MonitorTemplate from "../../Models/DatabaseModels/MonitorTemplate";
 import MonitorOwnerTeam from "../../Models/DatabaseModels/MonitorOwnerTeam";
 import MonitorOwnerUser from "../../Models/DatabaseModels/MonitorOwnerUser";
 import MonitorProbe from "../../Models/DatabaseModels/MonitorProbe";
@@ -89,6 +90,14 @@ import ExceptionMessages from "../../Types/Exception/ExceptionMessages";
 import Project from "../../Models/DatabaseModels/Project";
 import { createWhatsAppMessageFromTemplate } from "../Utils/WhatsAppTemplateUtil";
 import { WhatsAppMessagePayload } from "../../Types/WhatsApp/WhatsAppMessage";
+import MonitorTemplateService from "./MonitorTemplateService";
+import RelationIdUtil from "../Utils/Database/RelationIdUtil";
+import NetworkDeviceMonitorTemplateUtil from "../../Utils/Monitor/NetworkDeviceMonitorTemplateUtil";
+
+const MONITOR_TEMPLATE_RELATION_KEYS: Array<string> = [
+  "monitorTemplateId",
+  "monitorTemplate",
+];
 
 export interface MonitorDestinationInfo {
   monitorDestination: string;
@@ -101,6 +110,55 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  private async validateMonitorTemplateReference(data: {
+    monitorTemplateId: ObjectID;
+    projectId: ObjectID | undefined;
+    monitorType: MonitorType | undefined;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<void> {
+    if (!data.projectId) {
+      throw new BadDataException(
+        "Project ID is required when linking a monitor template.",
+      );
+    }
+
+    const monitorTemplate: MonitorTemplate | null =
+      await MonitorTemplateService.findOneById({
+        id: data.monitorTemplateId,
+        select: {
+          _id: true,
+          projectId: true,
+          monitorType: true,
+        },
+        /*
+         * Linking is also a read of the template. Keep the caller's tenant,
+         * ownership and label scopes so a generic Monitor write cannot attach
+         * a hidden template and expose its configuration through a later sync.
+         * Internal callers already use root props and retain that behavior.
+         */
+        props: data.props,
+      });
+
+    if (!monitorTemplate) {
+      throw new BadDataException("Monitor template not found.");
+    }
+
+    if (
+      !monitorTemplate.projectId ||
+      monitorTemplate.projectId.toString() !== data.projectId.toString()
+    ) {
+      throw new BadDataException(
+        "Monitor template must belong to the same project as the monitor.",
+      );
+    }
+
+    if (!data.monitorType || monitorTemplate.monitorType !== data.monitorType) {
+      throw new BadDataException(
+        "Monitor template type must match the monitor type.",
+      );
+    }
+  }
+
   public getMonitorDestinationInfo(monitor: Model): MonitorDestinationInfo {
     let monitorDestination: string = "";
     let requestType: string = "";
@@ -407,7 +465,15 @@ export class Service extends DatabaseService<Model> {
       resolveReferenceId(updateBy.data.currentMonitorStatusId) ||
       resolveReferenceId(updateBy.data.currentMonitorStatus);
 
-    if (updateBy.data.monitorSteps) {
+    const updateDataKeys: Array<string> = Object.keys(updateBy.data || {});
+    const isMonitorStepsWritten: boolean =
+      updateDataKeys.includes("monitorSteps");
+    const isMonitorTemplateWritten: boolean = RelationIdUtil.isWritten(
+      updateDataKeys,
+      MONITOR_TEMPLATE_RELATION_KEYS,
+    );
+
+    if (isMonitorStepsWritten || isMonitorTemplateWritten) {
       /*
        * Validated per matched monitor rather than per distinct project, because
        * the check needs that monitor's CURRENT monitorSteps: a reference id it
@@ -416,10 +482,16 @@ export class Service extends DatabaseService<Model> {
        * MonitorStepsProjectValidator.
        */
       const monitors: Array<Model> = await this.findBy({
-        query: updateBy.query,
+        query:
+          !updateBy.props.isRoot && updateBy.props.tenantId
+            ? { ...updateBy.query, projectId: updateBy.props.tenantId }
+            : updateBy.query,
         select: {
           projectId: true,
+          monitorType: true,
           monitorSteps: true,
+          monitorTemplateId: true,
+          autoProvisionedNetworkDeviceId: true,
         },
         limit: LIMIT_MAX,
         skip: 0,
@@ -429,16 +501,66 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+      const writtenMonitorTemplateId: ObjectID | null =
+        RelationIdUtil.readConsistent(
+          updateBy.data as unknown as Record<string, unknown>,
+          MONITOR_TEMPLATE_RELATION_KEYS,
+          "Monitor Template",
+        );
+
       for (const monitor of monitors) {
-        await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({
-          monitorSteps: updateBy.data.monitorSteps as MonitorSteps | JSONObject,
-          /*
-           * Root/API updates do not always carry a tenantId, so fall back to
-           * the project of the monitor being updated.
-           */
-          projectId: updateBy.props.tenantId || monitor.projectId,
-          alreadyStoredMonitorSteps: monitor.monitorSteps,
-        });
+        if (isMonitorStepsWritten) {
+          if (updateBy.data.monitorSteps) {
+            await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject(
+              {
+                monitorSteps: updateBy.data.monitorSteps as
+                  | MonitorSteps
+                  | JSONObject,
+                /*
+                 * Root/API updates do not always carry a tenantId, so fall back
+                 * to the project of the monitor being updated.
+                 */
+                projectId: updateBy.props.tenantId || monitor.projectId,
+                alreadyStoredMonitorSteps: monitor.monitorSteps,
+              },
+            );
+          }
+
+          if (monitor.autoProvisionedNetworkDeviceId) {
+            NetworkDeviceMonitorTemplateUtil.assertMonitorStepsBoundToNetworkDevice(
+              {
+                monitorSteps: updateBy.data.monitorSteps as
+                  | MonitorSteps
+                  | JSONObject,
+                networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
+              },
+            );
+          }
+        }
+
+        if (isMonitorTemplateWritten) {
+          if (monitor.autoProvisionedNetworkDeviceId) {
+            const storedTemplateId: string =
+              monitor.monitorTemplateId?.toString() || "";
+            const writtenTemplateId: string =
+              writtenMonitorTemplateId?.toString() || "";
+
+            if (storedTemplateId !== writtenTemplateId) {
+              throw new BadDataException(
+                "An auto-provisioned monitor cannot be relinked or unlinked from its template. Delete it and let the intended rule recreate it, or create a manual monitor instead.",
+              );
+            }
+          }
+
+          if (writtenMonitorTemplateId) {
+            await this.validateMonitorTemplateReference({
+              monitorTemplateId: writtenMonitorTemplateId,
+              projectId: updateBy.props.tenantId || monitor.projectId,
+              monitorType: monitor.monitorType,
+              props: updateBy.props,
+            });
+          }
+        }
       }
     }
 
@@ -1023,6 +1145,33 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    if (!createBy.props.tenantId) {
+      throw new BadDataException("ProjectId required to create monitor.");
+    }
+
+    /*
+     * Validate the request's shape before consulting billing. A conflicting
+     * Monitor Template reference, or one hidden by the caller's read scope, is
+     * a bad request regardless of the project's plan - and resolving it here,
+     * ahead of the plan lookup, keeps the checks reachable without a database
+     * (the billing lookup queries the DB) and mirrors onBeforeUpdate, which
+     * validates the template before any other work.
+     */
+    const monitorTemplateId: ObjectID | null = RelationIdUtil.readConsistent(
+      createBy.data as unknown as Record<string, unknown>,
+      MONITOR_TEMPLATE_RELATION_KEYS,
+      "Monitor Template",
+    );
+
+    if (monitorTemplateId) {
+      await this.validateMonitorTemplateReference({
+        monitorTemplateId: monitorTemplateId,
+        projectId: createBy.props.tenantId,
+        monitorType: createBy.data.monitorType,
+        props: createBy.props,
+      });
+    }
+
     if (IsBillingEnabled && createBy.props.tenantId) {
       const currentPlan: CurrentPlan = await ProjectService.getCurrentPlan(
         createBy.props.tenantId,
@@ -1070,8 +1219,23 @@ export class Service extends DatabaseService<Model> {
       createBy.data.incomingEmailSecretKey = ObjectID.generate();
     }
 
-    if (!createBy.props.tenantId) {
-      throw new BadDataException("ProjectId required to create monitor.");
+    if (createBy.data.autoProvisionedNetworkDeviceId) {
+      if (!monitorTemplateId) {
+        throw new BadDataException(
+          "An auto-provisioned Network Device monitor must be linked to a monitor template.",
+        );
+      }
+
+      if (createBy.data.monitorType !== MonitorType.NetworkDevice) {
+        throw new BadDataException(
+          "Only Network Device monitors can carry auto-provisioning provenance.",
+        );
+      }
+
+      NetworkDeviceMonitorTemplateUtil.assertMonitorStepsBoundToNetworkDevice({
+        monitorSteps: createBy.data.monitorSteps,
+        networkDeviceId: createBy.data.autoProvisionedNetworkDeviceId,
+      });
     }
 
     await MonitorStepsProjectValidator.validateMonitorStepsBelongToProject({

package/Server/Services/MonitorTemplateService.ts

@@ -9,11 +9,16 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import { JSONObject } from "../../Types/JSON";
 import MonitorSteps from "../../Types/Monitor/MonitorSteps";
+import MonitorType from "../../Types/Monitor/MonitorType";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "../../Models/DatabaseModels/MonitorTemplate";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import NetworkDeviceMonitorTemplateUtil from "../../Utils/Monitor/NetworkDeviceMonitorTemplateUtil";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import ModelPermission from "../Types/Database/Permissions/Index";
+import Query from "../Types/Database/Query";
 
 export interface SyncLinkedMonitorsResult {
   totalLinkedMonitors: number;
@@ -189,6 +194,7 @@ export class Service extends DatabaseService<Model> {
       select: {
         _id: true,
         projectId: true,
+        monitorType: true,
         monitorSteps: true,
         monitoringInterval: true,
         minimumProbeAgreement: true,
@@ -228,6 +234,93 @@ export class Service extends DatabaseService<Model> {
       };
     }
 
+    /*
+     * A Network Device template contains a design-time device reference,
+     * while each linked monitor has its own device. A bulk JSON assignment
+     * would retarget the entire fleet to the template editor's device. Sync
+     * those rows individually and rebind cloned template steps to each
+     * monitor's current (or provenance-backed) device instead.
+     */
+    if (
+      template.monitorType === MonitorType.NetworkDevice &&
+      fields.includes("monitorSteps")
+    ) {
+      let syncedMonitors: number = 0;
+      const linkedMonitorQuery: Query<Monitor> = {
+        monitorTemplateId: template.id!,
+        projectId: template.projectId,
+      };
+
+      /*
+       * Resolve the caller's complete update-authorized set before the first
+       * per-monitor write. Root-enumerating every linked row made a mixed
+       * label scope order-dependent: accessible rows could update before a
+       * later hidden row threw. This is the same permission-narrowed subset
+       * the ordinary bulk update path applies atomically.
+       */
+      const authorizedMonitorQuery: Query<Monitor> =
+        await ModelPermission.checkUpdateQueryPermissions(
+          Monitor,
+          linkedMonitorQuery,
+          updateData as any,
+          data.props,
+        );
+      const monitorsToSync: Array<Monitor> = [];
+
+      for (let skip: number = 0; ; skip += LIMIT_MAX) {
+        const monitors: Array<Monitor> = await MonitorService.findBy({
+          query: authorizedMonitorQuery,
+          select: {
+            _id: true,
+            monitorSteps: true,
+            autoProvisionedNetworkDeviceId: true,
+          },
+          sort: { createdAt: SortOrder.Ascending },
+          limit: LIMIT_MAX,
+          skip: skip,
+          props: { isRoot: true },
+        });
+
+        monitorsToSync.push(...monitors);
+
+        if (monitors.length < LIMIT_MAX) {
+          break;
+        }
+      }
+
+      /* Validate and materialize every instance-specific rebind first. */
+      const updates: Array<{
+        monitor: Monitor;
+        data: Partial<Monitor>;
+      }> = monitorsToSync.map((monitor: Monitor) => {
+        return {
+          monitor,
+          data: {
+            ...updateData,
+            monitorSteps: monitor.autoProvisionedNetworkDeviceId
+              ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
+                  monitorSteps: template.monitorSteps,
+                  networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
+                })
+              : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
+                  templateMonitorSteps: template.monitorSteps,
+                  currentMonitorSteps: monitor.monitorSteps,
+                }),
+          },
+        };
+      });
+
+      for (const update of updates) {
+        syncedMonitors += await MonitorService.updateOneById({
+          id: update.monitor.id!,
+          data: update.data as any,
+          props: data.props,
+        });
+      }
+
+      return { totalLinkedMonitors, syncedMonitors };
+    }
+
     const syncedMonitors: number = await MonitorService.updateBy({
       query: {
         monitorTemplateId: template.id!,
@@ -270,6 +363,7 @@ export class Service extends DatabaseService<Model> {
       select: {
         _id: true,
         projectId: true,
+        monitorType: true,
         monitorSteps: true,
         monitoringInterval: true,
         minimumProbeAgreement: true,
@@ -294,6 +388,8 @@ export class Service extends DatabaseService<Model> {
         _id: true,
         projectId: true,
         monitorTemplateId: true,
+        monitorSteps: true,
+        autoProvisionedNetworkDeviceId: true,
       },
       props: { isRoot: true },
     });
@@ -320,6 +416,21 @@ export class Service extends DatabaseService<Model> {
 
     const updateData: Partial<Monitor> = this.buildUpdateData(template, fields);
 
+    if (
+      template.monitorType === MonitorType.NetworkDevice &&
+      fields.includes("monitorSteps")
+    ) {
+      updateData.monitorSteps = monitor.autoProvisionedNetworkDeviceId
+        ? NetworkDeviceMonitorTemplateUtil.rebindMonitorSteps({
+            monitorSteps: template.monitorSteps,
+            networkDeviceId: monitor.autoProvisionedNetworkDeviceId,
+          })
+        : NetworkDeviceMonitorTemplateUtil.buildSyncedMonitorSteps({
+            templateMonitorSteps: template.monitorSteps,
+            currentMonitorSteps: monitor.monitorSteps,
+          });
+    }
+
     if (Object.keys(updateData).length === 0) {
       return;
     }