@oneuptime/common 13.0.0 → 13.0.3

package/Utils/Monitor/MonitorTemplateSyncUtil.ts

@@ -0,0 +1,164 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import MonitorStep from "../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../Types/Monitor/MonitorSteps";
+import MonitorTemplateSyncFieldUtil from "../../Types/Monitor/MonitorTemplateSyncField";
+import MonitorType from "../../Types/Monitor/MonitorType";
+
+export default class MonitorTemplateSyncUtil {
+  public static hasExcludedFields(steps: MonitorSteps | undefined): boolean {
+    return Boolean(
+      steps?.data?.monitorStepsInstanceArray.some(
+        (step: MonitorStep): boolean => {
+          return (
+            (MonitorTemplateSyncFieldUtil.parse(step.data?.doNotSyncFields)
+              ?.length || 0) > 0
+          );
+        },
+      ),
+    );
+  }
+
+  public static buildSyncedMonitorSteps(data: {
+    templateMonitorSteps: MonitorSteps | undefined;
+    currentMonitorSteps: MonitorSteps | undefined;
+    monitorType: MonitorType;
+  }): MonitorSteps {
+    if (!data.templateMonitorSteps?.data) {
+      throw new BadDataException(
+        "Monitor template steps are required to sync criteria.",
+      );
+    }
+
+    const result: MonitorSteps = this.cloneValue(data.templateMonitorSteps);
+    const templateSteps: Array<MonitorStep> =
+      data.templateMonitorSteps.data.monitorStepsInstanceArray;
+    const currentSteps: Array<MonitorStep> =
+      data.currentMonitorSteps?.data?.monitorStepsInstanceArray || [];
+
+    for (const [
+      index,
+      step,
+    ] of result.data!.monitorStepsInstanceArray.entries()) {
+      const excludedFields: Array<string> =
+        MonitorTemplateSyncFieldUtil.parse(
+          step.data?.doNotSyncFields,
+          data.monitorType,
+        ) || [];
+
+      // This is a template policy, not a monitor override.
+      if (step.data) {
+        delete step.data.doNotSyncFields;
+      }
+      if (excludedFields.length === 0) {
+        continue;
+      }
+
+      const templateStep: MonitorStep = templateSteps[index]!;
+      const hasUniqueTemplateId: boolean =
+        Boolean(templateStep.data?.id?.trim()) &&
+        templateSteps.filter((candidate: MonitorStep): boolean => {
+          return candidate.data?.id === templateStep.data?.id;
+        }).length === 1;
+      const matches: Array<MonitorStep> = currentSteps.filter(
+        (current: MonitorStep): boolean => {
+          return Boolean(
+            templateStep.data?.id && current.data?.id === templateStep.data.id,
+          );
+        },
+      );
+      const matchingStep: MonitorStep | undefined =
+        matches.length === 1
+          ? matches[0]
+          : matches.length === 0 &&
+              templateSteps.length === 1 &&
+              currentSteps.length === 1
+            ? currentSteps[0]
+            : undefined;
+
+      if (
+        !hasUniqueTemplateId ||
+        !matchingStep?.data?.id?.trim() ||
+        !step.data
+      ) {
+        throw new BadDataException(
+          "Cannot preserve fields because a template step cannot be matched to an existing monitor step. Match step IDs, or use a single-step template with a single-step monitor.",
+        );
+      }
+
+      for (const field of excludedFields) {
+        for (const path of MonitorTemplateSyncFieldUtil.getPaths(field)) {
+          this.preservePath(
+            step.data as unknown as Record<string, unknown>,
+            matchingStep.data as unknown as Record<string, unknown>,
+            path.split("."),
+          );
+        }
+      }
+    }
+
+    return result;
+  }
+
+  private static preservePath(
+    target: Record<string, unknown>,
+    source: Record<string, unknown>,
+    path: Array<string>,
+  ): void {
+    const key: string = path[0]!;
+    if (path.length === 1) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = this.cloneValue(source[key]);
+      } else {
+        delete target[key];
+      }
+      return;
+    }
+
+    const sourceChild: unknown = source[key];
+    const targetChild: unknown = target[key];
+    if (!targetChild || typeof targetChild !== "object") {
+      if (!sourceChild || typeof sourceChild !== "object") {
+        return;
+      }
+      target[key] = {};
+    }
+    this.preservePath(
+      target[key] as Record<string, unknown>,
+      sourceChild && typeof sourceChild === "object"
+        ? (sourceChild as Record<string, unknown>)
+        : {},
+      path.slice(1),
+    );
+  }
+
+  /**
+   * Clone configuration without a serialization round trip: that normalizes
+   * old values and can invent defaults for fields that should remain absent.
+   * Keeping prototypes also keeps URL, ObjectID and criteria methods usable.
+   */
+  private static cloneValue<T>(value: T): T {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (value instanceof Date) {
+      return new Date(value.getTime()) as T;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item: unknown): unknown => {
+        return this.cloneValue(item);
+      }) as T;
+    }
+    const result: Record<string, unknown> = Object.create(
+      Object.getPrototypeOf(value),
+    );
+    for (const key of Object.keys(value)) {
+      Object.defineProperty(result, key, {
+        value: this.cloneValue((value as Record<string, unknown>)[key]),
+        enumerable: true,
+        configurable: true,
+        writable: true,
+      });
+    }
+    return result as T;
+  }
+}

package/Utils/NetworkDiscovery/AutoImportRuleMatcher.ts

@@ -2,6 +2,11 @@ import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDevi
 import ObjectID from "../../Types/ObjectID";
 import CidrMatchUtil from "../NetworkSite/CidrMatchUtil";
 import RulePatternMatchUtil from "../Rules/RulePatternMatchUtil";
+import RuleCriteriaMatcher from "../Rules/RuleCriteriaMatcher";
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../Types/Rules/RuleCriteria";
 import { isPingOnlyDiscoveredHost } from "./DiscoveryImportEligibility";
 import ScanTargetUtil from "./ScanTargetUtil";
 
@@ -32,6 +37,7 @@ import ScanTargetUtil from "./ScanTargetUtil";
  * this structurally, and tests can build literals.
  */
 export interface AutoImportRuleCandidate {
+  criteria?: unknown;
   monitorTemplateId?: ObjectID | string | null | undefined;
   /*
    * The OID Collection Template imported devices are LINKED to. Purely
@@ -164,6 +170,31 @@ export class AutoImportRuleMatcher {
   public static ruleMatchesHost(
     rule: AutoImportRuleCandidate,
     host: DiscoveredNetworkDevice,
+  ): boolean {
+    if (
+      !rule.isExclusion &&
+      !rule.includePingOnlyHosts &&
+      AutoImportRuleMatcher.isPingOnlyHost(host)
+    ) {
+      return false;
+    }
+
+    if (rule.criteria !== undefined && rule.criteria !== null) {
+      return RuleCriteriaMatcher.matchesSync({
+        criteria: rule.criteria,
+        emptyResult: false,
+        matchesFilter: (filter: RuleCriteriaFilter): boolean => {
+          return AutoImportRuleMatcher.matchesConfiguredFilter(filter, host);
+        },
+      });
+    }
+
+    return AutoImportRuleMatcher.ruleMatchesHostLegacy(rule, host);
+  }
+
+  private static ruleMatchesHostLegacy(
+    rule: AutoImportRuleCandidate,
+    host: DiscoveredNetworkDevice,
   ): boolean {
     const ipMatchTarget: string = (rule.ipMatchTarget || "").trim();
     const sysNamePattern: string = (rule.sysNamePattern || "").trim();
@@ -180,14 +211,6 @@ export class AutoImportRuleMatcher {
       return false;
     }
 
-    if (
-      !rule.isExclusion &&
-      !rule.includePingOnlyHosts &&
-      AutoImportRuleMatcher.isPingOnlyHost(host)
-    ) {
-      return false;
-    }
-
     if (ipMatchTarget) {
       if (
         !host.ipAddress ||
@@ -230,6 +253,83 @@ export class AutoImportRuleMatcher {
     return true;
   }
 
+  private static matchesConfiguredFilter(
+    filter: RuleCriteriaFilter,
+    host: DiscoveredNetworkDevice,
+  ): boolean {
+    const expected: string = String(filter.value);
+
+    switch (filter.field) {
+      case "ipMatchTarget":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: host.ipAddress,
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: (
+            actual: string | undefined,
+            pattern: string,
+          ): boolean => {
+            return ScanTargetUtil.contains(pattern, actual || "");
+          },
+        });
+      case "sysNamePattern":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: clampSubject(host.sysName),
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: RulePatternMatchUtil.matches,
+        });
+      case "sysDescrPattern":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: clampSubject(host.sysDescr),
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: RulePatternMatchUtil.matches,
+        });
+      case "sysObjectIdPattern":
+        return AutoImportRuleMatcher.matchesTextOperator({
+          actual: clampSubject(host.sysObjectId),
+          expected: expected,
+          operator: filter.operator,
+          matchesPattern: matchesOidPattern,
+        });
+      default:
+        return false;
+    }
+  }
+
+  private static matchesTextOperator(data: {
+    actual: string | undefined;
+    expected: string;
+    operator: RuleCriteriaOperator;
+    matchesPattern: (actual: string | undefined, pattern: string) => boolean;
+  }): boolean {
+    const actual: string = data.actual || "";
+    const actualLower: string = actual.toLocaleLowerCase();
+    const expectedLower: string = data.expected.toLocaleLowerCase();
+
+    switch (data.operator) {
+      case RuleCriteriaOperator.Equals:
+        return actualLower === expectedLower;
+      case RuleCriteriaOperator.NotEquals:
+        return actualLower !== expectedLower;
+      case RuleCriteriaOperator.Contains:
+        return actualLower.includes(expectedLower);
+      case RuleCriteriaOperator.DoesNotContain:
+        return !actualLower.includes(expectedLower);
+      case RuleCriteriaOperator.StartsWith:
+        return actualLower.startsWith(expectedLower);
+      case RuleCriteriaOperator.EndsWith:
+        return actualLower.endsWith(expectedLower);
+      case RuleCriteriaOperator.MatchesPattern:
+        return data.matchesPattern(data.actual, data.expected);
+      case RuleCriteriaOperator.DoesNotMatchPattern:
+        return !data.matchesPattern(data.actual, data.expected);
+      default:
+        return false;
+    }
+  }
+
   /**
    * What the whole rule set says about one host: import, and through which
    * rules — or vetoed, and by which exclusion.

package/Utils/NetworkDiscovery/DiscoveryScanStatus.ts

@@ -40,6 +40,14 @@ export const DiscoveryScanStatus: {
   Failed: "Failed",
 };
 
+/*
+ * A recurring scan keeps its previous inventory until new results arrive.
+ * The claim marker lets the dashboard distinguish that inventory from current
+ * progress; the first partial or final report replaces it.
+ */
+export const DISCOVERY_SCAN_STARTED_MESSAGE: string =
+  "Scan started. Waiting for the first progress update.";
+
 /*
  * The statuses whose stored results are worth importing from automatically.
  *

package/Utils/NetworkSite/CidrMatchUtil.ts

@@ -5,8 +5,15 @@
  * engine's decisions are unit-testable.
  */
 
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../Types/Rules/RuleCriteria";
+import RuleCriteriaMatcher from "../Rules/RuleCriteriaMatcher";
+
 // The shape NetworkSiteAssignmentRule rows are matched with.
 export interface AssignmentRuleCandidate {
+  criteria?: unknown;
   subnetCidr?: string | null | undefined;
   hostnamePattern?: string | null | undefined;
   priority?: number | null | undefined;
@@ -191,6 +198,23 @@ export class CidrMatchUtil {
   public static ruleMatches(
     rule: AssignmentRuleCandidate,
     target: RuleMatchTarget,
+  ): boolean {
+    if (rule.criteria !== undefined && rule.criteria !== null) {
+      return RuleCriteriaMatcher.matchesSync({
+        criteria: rule.criteria,
+        emptyResult: false,
+        matchesFilter: (filter: RuleCriteriaFilter): boolean => {
+          return CidrMatchUtil.matchesConfiguredFilter(filter, target);
+        },
+      });
+    }
+
+    return CidrMatchUtil.ruleMatchesLegacy(rule, target);
+  }
+
+  private static ruleMatchesLegacy(
+    rule: AssignmentRuleCandidate,
+    target: RuleMatchTarget,
   ): boolean {
     const hasCidr: boolean = Boolean(
       rule.subnetCidr && rule.subnetCidr.trim().length > 0,
@@ -236,6 +260,84 @@ export class CidrMatchUtil {
     return true;
   }
 
+  private static matchesConfiguredFilter(
+    filter: RuleCriteriaFilter,
+    target: RuleMatchTarget,
+  ): boolean {
+    const expected: string = String(filter.value);
+
+    if (filter.field === "subnetCidr") {
+      const matchesCidr: boolean = Boolean(
+        target.ip && CidrMatchUtil.ipInCidr(target.ip, expected),
+      );
+
+      if (filter.operator === RuleCriteriaOperator.MatchesPattern) {
+        return matchesCidr;
+      }
+
+      if (filter.operator === RuleCriteriaOperator.DoesNotMatchPattern) {
+        return !matchesCidr;
+      }
+
+      return false;
+    }
+
+    if (filter.field !== "hostnamePattern") {
+      return false;
+    }
+
+    const candidates: Array<string> = [
+      target.hostname,
+      target.sysName,
+      target.name,
+    ].filter((candidate: string | null | undefined): candidate is string => {
+      return typeof candidate === "string";
+    });
+    const expectedLower: string = expected.toLocaleLowerCase();
+    const anyCandidateMatches: (
+      matches: (value: string) => boolean,
+    ) => boolean = (matches: (value: string) => boolean): boolean => {
+      return candidates.some(matches);
+    };
+
+    switch (filter.operator) {
+      case RuleCriteriaOperator.Equals:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase() === expectedLower;
+        });
+      case RuleCriteriaOperator.NotEquals:
+        return !anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase() === expectedLower;
+        });
+      case RuleCriteriaOperator.Contains:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().includes(expectedLower);
+        });
+      case RuleCriteriaOperator.DoesNotContain:
+        return !anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().includes(expectedLower);
+        });
+      case RuleCriteriaOperator.StartsWith:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().startsWith(expectedLower);
+        });
+      case RuleCriteriaOperator.EndsWith:
+        return anyCandidateMatches((value: string): boolean => {
+          return value.toLocaleLowerCase().endsWith(expectedLower);
+        });
+      case RuleCriteriaOperator.MatchesPattern:
+        return anyCandidateMatches((value: string): boolean => {
+          return CidrMatchUtil.hostnameMatchesWildcard(value, expected);
+        });
+      case RuleCriteriaOperator.DoesNotMatchPattern:
+        return !anyCandidateMatches((value: string): boolean => {
+          return CidrMatchUtil.hostnameMatchesWildcard(value, expected);
+        });
+      default:
+        return false;
+    }
+  }
+
   /*
    * Picks the winning rule for a target: among matching rules the highest
    * priority number wins; ties go to the earlier createdAt when both rows

package/Utils/NetworkSite/TypeHierarchyUtil.ts

@@ -160,8 +160,158 @@ export default class NetworkSiteTypeHierarchyUtil {
   }
 
   /*
-   * Parent picker candidates. A leaf/unit type cannot own child types, and a
-   * type cannot be placed under itself or anything already below it.
+   * SITE placement rule — the one predicate every surface must agree on.
+   *
+   * The type tree says which levels sit above which. A concrete site may
+   * never be placed under a site whose type sits BELOW its own, because that
+   * inverts the hierarchy the operator described. Everything else is allowed:
+   * an unrelated type (a catch-all "Other" owning a "Market"), a skipped
+   * level (a "Unit" straight under a "Region"), and the same type on both
+   * sides (a campus of campuses).
+   *
+   * It deliberately does NOT require the parent to be exactly the configured
+   * direct parent type. That stricter reading made whole estates impossible
+   * to build: a project whose types all ended up top-level — which is what
+   * the parent backfill leaves behind when a type's existing sites are all
+   * roots — could not link a single parent to a single child, by hand or by
+   * CSV. See GitHub issue #3744.
+   *
+   * A unit-level type is the leaf of the hierarchy by definition, so a site
+   * of that type never owns children.
+   */
+  public static isTypeAllowedAsSiteParentOfType(data: {
+    childNetworkSiteTypeId: string | null | undefined;
+    parentNetworkSiteTypeId: string | null | undefined;
+    networkSiteTypes: Array<NetworkSiteType>;
+    index?: NetworkSiteTypeHierarchyIndex | undefined;
+  }): boolean {
+    /*
+     * An untyped parent belongs to no level, so no inversion can be proven;
+     * legacy rows predating site types stay editable rather than becoming
+     * unreachable.
+     */
+    if (!data.parentNetworkSiteTypeId) {
+      return true;
+    }
+
+    const index: NetworkSiteTypeHierarchyIndex =
+      data.index || this.buildIndex(data);
+    const parentTypeId: string = data.parentNetworkSiteTypeId
+      .toString()
+      .toLowerCase();
+    const parentType: NetworkSiteType | undefined =
+      index.byId.get(parentTypeId);
+
+    if (parentType?.isUnitLevel === true) {
+      return false;
+    }
+
+    if (!data.childNetworkSiteTypeId) {
+      return true;
+    }
+
+    const childTypeId: string = data.childNetworkSiteTypeId
+      .toString()
+      .toLowerCase();
+
+    if (childTypeId === parentTypeId) {
+      return true;
+    }
+
+    /*
+     * Walk up from the PARENT type: reaching the child type means the parent
+     * sits below it. The visited set is what keeps a corrupted catalog (a
+     * cycle written straight into the database) from spinning here.
+     */
+    const visited: Set<string> = new Set<string>([parentTypeId]);
+    let ancestorId: string | null = parentType
+      ? this.getParentId(parentType)
+      : null;
+
+    while (ancestorId) {
+      const normalizedAncestorId: string = ancestorId.toLowerCase();
+
+      if (normalizedAncestorId === childTypeId) {
+        return false;
+      }
+
+      if (visited.has(normalizedAncestorId)) {
+        break;
+      }
+      visited.add(normalizedAncestorId);
+
+      const ancestor: NetworkSiteType | undefined =
+        index.byId.get(normalizedAncestorId);
+      if (!ancestor) {
+        break;
+      }
+
+      ancestorId = this.getParentId(ancestor);
+    }
+
+    return true;
+  }
+
+  /*
+   * Types a site of `networkSiteTypeId` may be placed under — the picker side
+   * of isTypeAllowedAsSiteParentOfType.
+   */
+  public static getValidSiteParentTypes(data: {
+    networkSiteTypeId: string | null | undefined;
+    networkSiteTypes: Array<NetworkSiteType>;
+    index?: NetworkSiteTypeHierarchyIndex | undefined;
+  }): Array<NetworkSiteType> {
+    const index: NetworkSiteTypeHierarchyIndex =
+      data.index || this.buildIndex(data);
+
+    return this.sort(
+      data.networkSiteTypes.filter((candidate: NetworkSiteType) => {
+        return (
+          Boolean(candidate.id) &&
+          this.isTypeAllowedAsSiteParentOfType({
+            childNetworkSiteTypeId: data.networkSiteTypeId,
+            parentNetworkSiteTypeId: candidate.id!.toString(),
+            networkSiteTypes: data.networkSiteTypes,
+            index,
+          })
+        );
+      }),
+    );
+  }
+
+  /*
+   * Types a new child site under a parent site of `networkSiteTypeId` may
+   * take. The mirror of getValidSiteParentTypes, so the "add a child site"
+   * form and the "pick my parent" form can never disagree.
+   */
+  public static getValidSiteChildTypes(data: {
+    networkSiteTypeId: string | null | undefined;
+    networkSiteTypes: Array<NetworkSiteType>;
+    index?: NetworkSiteTypeHierarchyIndex | undefined;
+  }): Array<NetworkSiteType> {
+    const index: NetworkSiteTypeHierarchyIndex =
+      data.index || this.buildIndex(data);
+
+    return this.sort(
+      data.networkSiteTypes.filter((candidate: NetworkSiteType) => {
+        return (
+          Boolean(candidate.id) &&
+          this.isTypeAllowedAsSiteParentOfType({
+            childNetworkSiteTypeId: candidate.id!.toString(),
+            parentNetworkSiteTypeId: data.networkSiteTypeId,
+            networkSiteTypes: data.networkSiteTypes,
+            index,
+          })
+        );
+      }),
+    );
+  }
+
+  /*
+   * Parent picker candidates for the TYPE catalog itself. A leaf/unit type
+   * cannot own child types, and a type cannot be placed under itself or
+   * anything already below it. This is the type tree's own shape rule and
+   * stays strict — it is site PLACEMENT that was relaxed, not the catalog.
    */
   public static getValidParentCandidates(data: {
     networkSiteType: NetworkSiteType;