@oneuptime/common 12.0.12 → 12.0.13

package/Tests/Utils/NetworkSite/SiteStatusRollupUtil.test.ts

@@ -6,6 +6,11 @@ import SiteStatusRollupUtil, {
 /*
  * MonitorStatus priority is HIGHER = WORSE (seeded: Operational 1,
  * Degraded 2, Offline 3).
+ *
+ * The SNMP half of this rollup now asks DeviceReachabilityUtil — "did the
+ * last poll succeed" — rather than "was the last success recent". That is
+ * what stops a site card going red because its probe is behind on a large
+ * fleet while every device under it is answering (issue #3220).
  */
 const OPERATIONAL: RollupStatusOption = {
   monitorStatusId: "status-operational",
@@ -26,12 +31,31 @@ function minutesAgo(minutes: number): Date {
   return new Date(NOW.getTime() - minutes * 60 * 1000);
 }
 
+// A device whose last poll succeeded `minutes` ago.
+function answered(minutes: number): DeviceHealthState {
+  return {
+    isReachable: true,
+    lastPolledAt: minutesAgo(minutes),
+    lastSeenAt: minutesAgo(minutes),
+    pollingIntervalInMinutes: 5,
+  };
+}
+
+// A device whose last poll failed `minutes` ago.
+function failed(minutes: number): DeviceHealthState {
+  return {
+    isReachable: false,
+    lastPolledAt: minutesAgo(minutes),
+    lastSeenAt: minutesAgo(minutes + 60),
+    pollingIntervalInMinutes: 5,
+  };
+}
+
 function worst(
   deviceStates: Array<DeviceHealthState>,
   overrides?: {
     operationalStatus?: RollupStatusOption | null;
     offlineStatus?: RollupStatusOption | null;
-    freshnessWindowInMinutes?: number;
   },
 ): string | null {
   return SiteStatusRollupUtil.worstStatus({
@@ -45,7 +69,6 @@ function worst(
         ? overrides.offlineStatus
         : OFFLINE,
     now: NOW,
-    freshnessWindowInMinutes: overrides?.freshnessWindowInMinutes,
   });
 }
 
@@ -84,65 +107,103 @@ describe("SiteStatusRollupUtil.worstStatus", () => {
     ).toBe(OFFLINE.monitorStatusId);
   });
 
-  it("a fresh unmonitored device maps to the operational equivalent", () => {
-    expect(worst([{ lastSeenAt: minutesAgo(5) }])).toBe(
+  it("a device whose last poll succeeded maps to the operational equivalent", () => {
+    expect(worst([answered(5)])).toBe(OPERATIONAL.monitorStatusId);
+  });
+
+  it("a device whose last poll failed maps to the offline equivalent", () => {
+    expect(worst([failed(2)])).toBe(OFFLINE.monitorStatusId);
+  });
+
+  /*
+   * The rollup half of issue #3220. 21 minutes was the reported lag on a
+   * fleet the probe could not get round in 15, and every device under the
+   * site was answering.
+   */
+  it("issue #3220: a site whose devices are all answering, 21 minutes behind, is operational", () => {
+    expect(worst([answered(21), answered(19), answered(25)])).toBe(
       OPERATIONAL.monitorStatusId,
     );
   });
 
-  it("a stale unmonitored device maps to the offline equivalent", () => {
-    expect(worst([{ lastSeenAt: minutesAgo(30) }])).toBe(
-      OFFLINE.monitorStatusId,
-    );
+  it("a slow-polled device is operational right up to its next poll", () => {
+    expect(
+      worst([
+        {
+          isReachable: true,
+          lastPolledAt: minutesAgo(29),
+          lastSeenAt: minutesAgo(29),
+          pollingIntervalInMinutes: 30,
+        },
+      ]),
+    ).toBe(OPERATIONAL.monitorStatusId);
   });
 
-  it("a never-seen unmonitored device maps to the offline equivalent", () => {
-    expect(worst([{}])).toBe(OFFLINE.monitorStatusId);
-    expect(worst([{ lastSeenAt: null }])).toBe(OFFLINE.monitorStatusId);
+  /*
+   * A site nothing has polled for hours keeps its last known status rather
+   * than flipping offline. Turning "nobody has checked lately" into a red
+   * site card is the same inference this change removed from the device
+   * pill — and doing it here alone would put the site card at odds with
+   * every device under it, which is the inconsistency issue #3220 reported.
+   */
+  it("a device out of contact past its stale window keeps its last verdict", () => {
+    expect(worst([answered(61)])).toBe(OPERATIONAL.monitorStatusId);
+    expect(worst([answered(60 * 24)])).toBe(OPERATIONAL.monitorStatusId);
   });
 
-  it("freshness boundary: exactly 15 minutes is still fresh, beyond is not", () => {
-    expect(worst([{ lastSeenAt: minutesAgo(15) }])).toBe(
-      OPERATIONAL.monitorStatusId,
-    );
-    expect(
-      worst([{ lastSeenAt: new Date(minutesAgo(15).getTime() - 1) }]),
-    ).toBe(OFFLINE.monitorStatusId);
+  it("...but a device that actually failed its last poll still rolls up offline", () => {
+    expect(worst([failed(60 * 24)])).toBe(OFFLINE.monitorStatusId);
+  });
+
+  /*
+   * Changed deliberately: a never-polled device used to be counted as
+   * offline, which pinned a brand-new site red until its first walk landed
+   * — while the device list showed the very same device as a gray
+   * "Pending". It now contributes nothing, and the caller reads null as
+   * "leave the site's status alone".
+   */
+  it("a never-polled device contributes nothing at all", () => {
+    expect(worst([{}])).toBeNull();
+    expect(worst([{ isReachable: null, lastSeenAt: null }])).toBeNull();
+  });
+
+  it("a never-polled device does not drag down a site with healthy devices", () => {
+    expect(worst([answered(1), {}])).toBe(OPERATIONAL.monitorStatusId);
   });
 
-  it("mix: a stale unmonitored device outranks a monitored operational one", () => {
+  it("mix: a failing device outranks a monitored operational one", () => {
     expect(
       worst([
         {
           currentMonitorStatusId: OPERATIONAL.monitorStatusId,
           monitorStatusPriority: OPERATIONAL.priority,
         },
-        { lastSeenAt: minutesAgo(60) },
+        failed(1),
       ]),
     ).toBe(OFFLINE.monitorStatusId);
   });
 
-  it("mix: a monitored offline device outranks fresh unmonitored ones", () => {
+  it("mix: a monitored offline device outranks answering ones", () => {
     expect(
       worst([
-        { lastSeenAt: minutesAgo(1) },
+        answered(1),
         {
           currentMonitorStatusId: OFFLINE.monitorStatusId,
           monitorStatusPriority: OFFLINE.priority,
         },
-        { lastSeenAt: minutesAgo(2) },
+        answered(2),
       ]),
     ).toBe(OFFLINE.monitorStatusId);
   });
 
-  it("a stamped status whose priority is unknown falls back to freshness", () => {
-    // The MonitorStatus row was deleted: treat the device by lastSeenAt.
+  it("a stamped status whose priority is unknown falls back to reachability", () => {
+    // The MonitorStatus row was deleted: treat the device by its last poll.
     expect(
       worst([
         {
           currentMonitorStatusId: "deleted-status",
           monitorStatusPriority: undefined,
-          lastSeenAt: minutesAgo(1),
+          ...answered(1),
         },
       ]),
     ).toBe(OPERATIONAL.monitorStatusId);
@@ -151,7 +212,7 @@ describe("SiteStatusRollupUtil.worstStatus", () => {
         {
           currentMonitorStatusId: "deleted-status",
           monitorStatusPriority: null,
-          lastSeenAt: minutesAgo(120),
+          ...failed(1),
         },
       ]),
     ).toBe(OFFLINE.monitorStatusId);
@@ -172,9 +233,9 @@ describe("SiteStatusRollupUtil.worstStatus", () => {
     ).toBe("status-a");
   });
 
-  it("returns null when only freshness fallbacks apply but the project has no flagged rows", () => {
+  it("returns null when only SNMP fallbacks apply but the project has no flagged rows", () => {
     expect(
-      worst([{ lastSeenAt: minutesAgo(1) }, { lastSeenAt: minutesAgo(60) }], {
+      worst([answered(1), failed(1)], {
         operationalStatus: null,
         offlineStatus: null,
       }),
@@ -185,7 +246,7 @@ describe("SiteStatusRollupUtil.worstStatus", () => {
     expect(
       worst(
         [
-          { lastSeenAt: minutesAgo(60) }, // offline equivalent missing -> skipped
+          failed(1), // offline equivalent missing -> skipped
           {
             currentMonitorStatusId: DEGRADED.monitorStatusId,
             monitorStatusPriority: DEGRADED.priority,
@@ -196,26 +257,34 @@ describe("SiteStatusRollupUtil.worstStatus", () => {
     ).toBe(DEGRADED.monitorStatusId);
   });
 
-  it("honors a custom freshness window", () => {
+  it("a lastPolledAt in the future counts as fresh, not an error", () => {
     expect(
-      worst([{ lastSeenAt: minutesAgo(20) }], {
-        freshnessWindowInMinutes: 30,
-      }),
+      worst([
+        {
+          isReachable: true,
+          lastPolledAt: minutesAgo(-5),
+          lastSeenAt: minutesAgo(-5),
+        },
+      ]),
     ).toBe(OPERATIONAL.monitorStatusId);
-    expect(
-      worst([{ lastSeenAt: minutesAgo(20) }], {
-        freshnessWindowInMinutes: 10,
-      }),
-    ).toBe(OFFLINE.monitorStatusId);
   });
 
-  it("a lastSeenAt in the future counts as fresh, not an error", () => {
-    expect(worst([{ lastSeenAt: minutesAgo(-5) }])).toBe(
+  /*
+   * Rows written before the reachability columns existed carry only
+   * lastSeenAt. They must keep rolling up sensibly until the upgrade
+   * migration (or their next walk) fills the rest in.
+   */
+  it("legacy rows with only lastSeenAt still roll up by freshness", () => {
+    /*
+     * The one place freshness survives: a row written before isReachable
+     * existed has nothing else to go on. The upgrade migration backfills
+     * these, so it is a short-lived path.
+     */
+    expect(worst([{ lastSeenAt: minutesAgo(5) }])).toBe(
       OPERATIONAL.monitorStatusId,
     );
-  });
-
-  it("exposes the default freshness window as 15 minutes", () => {
-    expect(SiteStatusRollupUtil.DEFAULT_FRESHNESS_WINDOW_IN_MINUTES).toBe(15);
+    expect(worst([{ lastSeenAt: minutesAgo(600) }])).toBe(
+      OFFLINE.monitorStatusId,
+    );
   });
 });

package/Types/API/Hostname.ts

@@ -182,6 +182,85 @@ export default class Hostname extends DatabaseProperty {
     return new Hostname(hostname);
   }
 
+  /*
+   * Splits a URL authority into its bare host and its port, using the same
+   * structure isValid() already understands: optional userinfo, then either
+   * a bracketed IPv6 literal, an unbracketed IPv6 literal, or a host with an
+   * optional ":port".
+   *
+   * fromString() is NOT a substitute. It splits on the FIRST colon, so it
+   * turns "[::1]:8080" into a host of "[" and a port of "", and any IPv6
+   * literal into nonsense. Callers that hold an authority (a URL's host
+   * component) and need the two parts apart must use this.
+   *
+   * Userinfo is dropped rather than preserved: the caller asked for a host
+   * to connect to, and credentials are not part of one. Anything that needs
+   * the original string still has the authority it passed in.
+   */
+  public static fromAuthority(authority: string): Hostname {
+    const trimmedAuthority: string = (authority || "").trim();
+
+    if (!trimmedAuthority) {
+      return new Hostname("");
+    }
+
+    /*
+     * Split on the LAST "@" for the same reason isValid() does: userinfo may
+     * itself contain an "@", and everything after the final one is the
+     * authority proper.
+     */
+    const atIndex: number = trimmedAuthority.lastIndexOf("@");
+    const hostAndPort: string =
+      atIndex === -1
+        ? trimmedAuthority
+        : trimmedAuthority.substring(atIndex + 1);
+
+    if (!hostAndPort) {
+      return new Hostname("");
+    }
+
+    // Bracketed IPv6, with or without a port: "[::1]", "[::1]:8080".
+    const bracketedIpv6Match: RegExpMatchArray | null = hostAndPort.match(
+      /^(\[[0-9a-fA-F:.]+\])(?::(\d{1,5}))?$/,
+    );
+
+    if (bracketedIpv6Match) {
+      const ipv6Host: string = bracketedIpv6Match[1] as string;
+      const ipv6Port: string | undefined = bracketedIpv6Match[2];
+
+      return ipv6Port
+        ? new Hostname(ipv6Host, ipv6Port)
+        : new Hostname(ipv6Host);
+    }
+
+    /*
+     * Unbracketed IPv6 literal: two or more colons cannot be a "host:port",
+     * so every colon belongs to the address itself and there is no port.
+     */
+    if ((hostAndPort.match(/:/g) || []).length > 1) {
+      return new Hostname(hostAndPort);
+    }
+
+    const colonIndex: number = hostAndPort.indexOf(":");
+
+    if (colonIndex === -1) {
+      return new Hostname(hostAndPort);
+    }
+
+    const host: string = hostAndPort.substring(0, colonIndex);
+    const port: string = hostAndPort.substring(colonIndex + 1);
+
+    /*
+     * A trailing colon with no digits ("host:") is not a port. Keep the host
+     * and drop the empty port rather than constructing an invalid Port.
+     */
+    if (!port) {
+      return new Hostname(host);
+    }
+
+    return new Hostname(host, port);
+  }
+
   public static override toDatabase(
     value: Hostname | FindOperator<Hostname>,
   ): string | null {

package/Types/Database/AccessControl/ColumnAccessControl.ts

@@ -30,20 +30,42 @@ type GetColumnAccessControlForAllColumnsFunction = <T extends BaseModel>(
   target: T,
 ) => Dictionary<ColumnAccessControl>;
 
+/*
+ * Per-class cache. Safe to key on the constructor because every decorated
+ * column is initialised to `undefined` in the class body, so Object.keys()
+ * is identical for every instance of a class (see OwnerOnlyColumn.ts).
+ * Callers must treat the returned dictionary as read-only.
+ */
+const accessControlCache: WeakMap<
+  { new (): BaseModel },
+  Dictionary<ColumnAccessControl>
+> = new WeakMap();
+
 export const getColumnAccessControlForAllColumns: GetColumnAccessControlForAllColumnsFunction =
   <T extends BaseModel>(target: T): Dictionary<ColumnAccessControl> => {
-    const dictonary: Dictionary<ColumnAccessControl> = {};
-    const keys: Array<string> = Object.keys(target);
-
-    for (const key of keys) {
-      if (Reflect.getMetadata(accessControlSymbol, target, key)) {
-        dictonary[key] = Reflect.getMetadata(
-          accessControlSymbol,
-          target,
-          key,
-        ) as ColumnAccessControl;
+    const modelClass: { new (): BaseModel } = target.constructor as {
+      new (): BaseModel;
+    };
+    let cached: Dictionary<ColumnAccessControl> | undefined =
+      accessControlCache.get(modelClass);
+
+    if (!cached) {
+      const dictonary: Dictionary<ColumnAccessControl> = {};
+      const keys: Array<string> = Object.keys(target);
+
+      for (const key of keys) {
+        const accessControl: ColumnAccessControl | undefined =
+          Reflect.getMetadata(accessControlSymbol, target, key) as
+            | ColumnAccessControl
+            | undefined;
+        if (accessControl) {
+          dictonary[key] = accessControl;
+        }
       }
+
+      cached = dictonary;
+      accessControlCache.set(modelClass, cached);
     }
 
-    return dictonary;
+    return cached;
   };

package/Types/Database/AccessControl/ColumnBillingAccessControl.ts

@@ -30,20 +30,42 @@ type GetColumnBillingAccessControlForAllColumnsFunction = <T extends BaseModel>(
   target: T,
 ) => Dictionary<ColumnBillingAccessControl>;
 
+/*
+ * Per-class cache. Safe to key on the constructor because every decorated
+ * column is initialised to `undefined` in the class body, so Object.keys()
+ * is identical for every instance of a class (see OwnerOnlyColumn.ts).
+ * Callers must treat the returned dictionary as read-only.
+ */
+const billingAccessControlCache: WeakMap<
+  { new (): BaseModel },
+  Dictionary<ColumnBillingAccessControl>
+> = new WeakMap();
+
 export const getColumnBillingAccessControlForAllColumns: GetColumnBillingAccessControlForAllColumnsFunction =
   <T extends BaseModel>(target: T): Dictionary<ColumnBillingAccessControl> => {
-    const dictonary: Dictionary<ColumnBillingAccessControl> = {};
-    const keys: Array<string> = Object.keys(target);
-
-    for (const key of keys) {
-      if (Reflect.getMetadata(accessControlSymbol, target, key)) {
-        dictonary[key] = Reflect.getMetadata(
-          accessControlSymbol,
-          target,
-          key,
-        ) as ColumnBillingAccessControl;
+    const modelClass: { new (): BaseModel } = target.constructor as {
+      new (): BaseModel;
+    };
+    let cached: Dictionary<ColumnBillingAccessControl> | undefined =
+      billingAccessControlCache.get(modelClass);
+
+    if (!cached) {
+      const dictonary: Dictionary<ColumnBillingAccessControl> = {};
+      const keys: Array<string> = Object.keys(target);
+
+      for (const key of keys) {
+        const accessControl: ColumnBillingAccessControl | undefined =
+          Reflect.getMetadata(accessControlSymbol, target, key) as
+            | ColumnBillingAccessControl
+            | undefined;
+        if (accessControl) {
+          dictonary[key] = accessControl;
+        }
       }
+
+      cached = dictonary;
+      billingAccessControlCache.set(modelClass, cached);
     }
 
-    return dictonary;
+    return cached;
   };

package/Types/Database/DatabaseProperty.ts

@@ -39,6 +39,44 @@ export default class DatabaseProperty extends SerializableObject {
       return value as any;
     }
 
+    /*
+     * A FindOperator reaches a transformer when the query value is an
+     * operator rather than a plain value. Two ways in:
+     *
+     *   - Nested. `And(Equal(id), Raw(privacyClause))` — the shape every
+     *     privacy/scope filter builds (Server/Utils/PrivacyFilterUtil.ts).
+     *     TypeORM calls `operator.transformValue(column.transformer)`
+     *     (SelectQueryBuilder.buildWhere), and FindOperator.transformValue
+     *     hands each CHILD OPERATOR to this function whenever the operator
+     *     carries multiple parameters — which And() and Or() both do.
+     *   - Top level. ColumnMetadata.getEntityValue applies the transformer to
+     *     the whole criteria of a .where()/.update()/.delete() call.
+     *
+     * Every toDatabase() below expects a value, so an operator makes it
+     * produce garbage: "[object Object]" from the string-ish types (ObjectID
+     * included — a uuid column then fails with Postgres 22P02 invalid input
+     * syntax for type uuid), `null` from Port, a serialized operator from the
+     * JSON types. The child is REPLACED by that garbage, so the caller's own
+     * predicate is lost and the privacy clause it was ANDed with can no
+     * longer match anything.
+     *
+     * Transform the operator's leaf value(s) in place and hand the operator
+     * back, so `And`/`Or`/`In`/`Not`/`Between` keep their structure and only
+     * the leaves are converted. Recursion terminates because transformValue
+     * always descends into the operator's value, and a leaf is never a
+     * FindOperator.
+     *
+     * NOTE: transformValue mutates. One query object can legitimately be
+     * transformed more than once — BaseAPI.getList shares it between findBy
+     * and countBy — so every toDatabase() has to be a fixpoint: handed its
+     * own output it must return that output unchanged. Tests/Types/Database/
+     * DatabasePropertyFindOperator.test.ts enforces that for each type.
+     */
+    if (value instanceof FindOperator) {
+      value.transformValue(this.getDatabaseTransformer());
+      return value as any;
+    }
+
     return this.toDatabase(value);
   }
 

package/Types/Database/TableColumn.ts

@@ -63,21 +63,48 @@ type GetTableColumnsFunction = <T extends BaseModel>(
   target: T,
 ) => Dictionary<TableColumnMetadata>;
 
+/*
+ * Per-class cache. Safe to key on the constructor because every decorated
+ * column is initialised to `undefined` in the class body, so Object.keys()
+ * is identical for every instance of a class (see OwnerOnlyColumn.ts).
+ */
+const tableColumnsCache: WeakMap<
+  { new (): BaseModel },
+  Dictionary<TableColumnMetadata>
+> = new WeakMap();
+
 export const getTableColumns: GetTableColumnsFunction = <T extends BaseModel>(
   target: T,
 ): Dictionary<TableColumnMetadata> => {
-  const dictonary: Dictionary<TableColumnMetadata> = {};
-  const keys: Array<string> = Object.keys(target);
+  const modelClass: { new (): BaseModel } = target.constructor as {
+    new (): BaseModel;
+  };
+  let cached: Dictionary<TableColumnMetadata> | undefined =
+    tableColumnsCache.get(modelClass);
+
+  if (!cached) {
+    const dictonary: Dictionary<TableColumnMetadata> = {};
+    const keys: Array<string> = Object.keys(target);
 
-  for (const key of keys) {
-    if (Reflect.getMetadata(tableColumn, target, key)) {
-      dictonary[key] = Reflect.getMetadata(
+    for (const key of keys) {
+      const metadata: TableColumnMetadata | undefined = Reflect.getMetadata(
         tableColumn,
         target,
         key,
-      ) as TableColumnMetadata;
+      ) as TableColumnMetadata | undefined;
+      if (metadata) {
+        dictonary[key] = metadata;
+      }
     }
+
+    cached = dictonary;
+    tableColumnsCache.set(modelClass, cached);
   }
 
-  return dictonary;
+  /*
+   * Hand out a copy, not the cached dictionary itself: callers mutate the
+   * result (the API reference docs delete entries from it), which would
+   * otherwise strip columns from every later call for the same class.
+   */
+  return { ...cached };
 };

package/Types/Events/Recurring.ts

@@ -313,7 +313,22 @@ export default class Recurring extends DatabaseProperty {
     value: Recurring | Array<Recurring> | FindOperator<Recurring>,
   ): JSONObject | Array<JSONObject> | null {
     if (Array.isArray(value)) {
-      return this.toJSONArray(value as Array<Recurring>);
+      /*
+       * Per item rather than through toJSONArray, which assumes every item is
+       * still a Recurring instance and throws "item.toJSON is not a function"
+       * on an already-serialized array. TypeORM can hand a transformer its own
+       * output — BaseAPI.getList shares one query object between findBy and
+       * countBy — so this has to be a fixpoint.
+       */
+      return (value as Array<Recurring | JSONObject>).map(
+        (item: Recurring | JSONObject) => {
+          if (item instanceof Recurring) {
+            return item.toJSON();
+          }
+
+          return JSONFunctions.serialize(item as JSONObject);
+        },
+      );
     }
 
     if (value && value instanceof Recurring) {

package/Types/Monitor/MonitorStep.ts

@@ -1156,8 +1156,20 @@ export default class MonitorStep extends DatabaseProperty {
             ),
           )
         : undefined,
+      /*
+       * Normalized for the same reason domainMonitor above is: a config
+       * authored through the API or a template need not carry `resolvers`,
+       * and the probe iterates that list without a guard. A raw passthrough
+       * therefore threw a TypeError inside the probe BEFORE it posted any
+       * result, so the monitor produced nothing at all - no check, no
+       * status change, no error the user could see.
+       */
       dnssecMonitor: json["dnssecMonitor"]
-        ? (json["dnssecMonitor"] as JSONObject)
+        ? MonitorStepDnssecMonitorUtil.toJSON(
+            MonitorStepDnssecMonitorUtil.fromJSON(
+              json["dnssecMonitor"] as JSONObject,
+            ),
+          )
         : undefined,
       sqlMonitor: json["sqlMonitor"]
         ? (json["sqlMonitor"] as JSONObject)