@oneuptime/common 12.0.10 → 12.0.11

package/Types/CustomField/CustomFieldType.ts

@@ -1,9 +1,37 @@
+/*
+ * The member VALUES are load-bearing beyond this enum.
+ *
+ * CustomFieldsDetail passes a definition's `customFieldType` straight through
+ * as the `fieldType` of a Detail field and of a form field, so every member
+ * here has to name a member of BOTH `FieldType` (Detail) and
+ * `FormFieldSchemaType` (Forms) by value. `Boolean` is the standing example:
+ * it reaches the form as FormFieldSchemaType.Toggle, which is spelled
+ * `Toggle = "Boolean"` for exactly this reason.
+ *
+ * Adding a member without that correspondence compiles fine and then renders
+ * an empty cell and an input the user cannot type into.
+ */
 enum CustomFieldType {
   Text = "Text",
   Number = "Number",
   Boolean = "Boolean",
   Dropdown = "Dropdown",
   MultiSelectDropdown = "MultiSelectDropdown",
+
+  /**
+   * A calendar date with no time of day — purchase date, warranty expiry,
+   * end-of-life. Stored in the `customFields` jsonb bag as an ISO-8601 string,
+   * which is what makes it comparable: ISO-8601 sorts identically as text and
+   * as an instant, so the range filters work over a jsonb key without a cast
+   * (see JSONColumnQuery.compareText).
+   */
+  Date = "Date",
+
+  /**
+   * As `Date`, but the time of day is part of the answer — last audited at,
+   * decommissioned at.
+   */
+  DateTime = "DateTime",
 }
 
 export default CustomFieldType;

package/Types/Monitor/MonitorType.ts

@@ -170,6 +170,17 @@ export class MonitorTypeHelper {
     return monitorType === MonitorType.Manual;
   }
 
+  /*
+   * Whether a monitor of this type adds to the project's Active Monitoring
+   * bill. Mirrors what the server actually meters -
+   * ActiveMonitoringMeteredPlan counts every monitor whose type is not
+   * Manual - so the dashboard can warn a Free plan user about a charge using
+   * the same rule that produces it. Manual monitors are free and unlimited.
+   */
+  public static isBilledAsActiveMonitor(monitorType: MonitorType): boolean {
+    return !this.isManualMonitor(monitorType);
+  }
+
   public static getAllMonitorTypeProps(): Array<MonitorTypeProps> {
     const monitorTypeProps: Array<MonitorTypeProps> = [
       {

package/Types/Monitor/SnmpMonitor/NetworkTopology.ts

@@ -156,6 +156,19 @@ export interface NetworkTopologyEdge {
   monitorState?: "up" | "down" | undefined;
   // Operator-supplied label, set only on manual links.
   name?: string | undefined;
+  /*
+   * Which end of this edge is the parent, when somebody has SAID so —
+   * either on the link itself or through a link rule, which is stated in
+   * child/parent labels and so knows the answer by construction.
+   *
+   * Always one of `fromNodeId`/`toNodeId`. Absent on every discovered
+   * edge: LLDP and CDP report a cable, not a hierarchy, and the direction
+   * a neighbour entry happens to be read from says nothing about which
+   * box is upstream. Layouts that draw a tree must therefore treat this as
+   * a constraint where it is present and keep inferring where it is not —
+   * absent is "not stated", never "these are peers".
+   */
+  parentNodeId?: string | undefined;
 }
 
 export default interface NetworkTopology {

package/UI/Components/Charts/Area/AreaChart.tsx

@@ -13,7 +13,9 @@ import SeriesPoint from "../Types/SeriesPoints";
 import { XAxis } from "../Types/XAxis/XAxis";
 import YAxis from "../Types/YAxis/YAxis";
 import ChartCurve from "../Types/ChartCurve";
-import ChartDataPoint from "../ChartLibrary/Types/ChartDataPoint";
+import ChartDataPoint, {
+  CHART_DATA_POINT_X_AXIS_KEY,
+} from "../ChartLibrary/Types/ChartDataPoint";
 import FormattedExemplarPoint from "../ChartLibrary/Types/FormattedExemplarPoint";
 import FormattedReferenceRegion from "../ChartLibrary/Types/FormattedReferenceRegion";
 import FormattedTimeReferenceLine from "../ChartLibrary/Types/FormattedTimeReferenceLine";
@@ -185,7 +187,7 @@ const AreaChartElement: FunctionComponent<AreaInternalProps> = (
       <AreaChart
         data={records}
         tickGap={30}
-        index={"Time"}
+        index={CHART_DATA_POINT_X_AXIS_KEY}
         categories={categories}
         colors={
           props.colors && props.colors.length > 0

package/UI/Components/Charts/Bar/BarChart.tsx

@@ -12,7 +12,9 @@ import React, {
 import SeriesPoint from "../Types/SeriesPoints";
 import { XAxis } from "../Types/XAxis/XAxis";
 import YAxis from "../Types/YAxis/YAxis";
-import ChartDataPoint from "../ChartLibrary/Types/ChartDataPoint";
+import ChartDataPoint, {
+  CHART_DATA_POINT_X_AXIS_KEY,
+} from "../ChartLibrary/Types/ChartDataPoint";
 import FormattedReferenceRegion from "../ChartLibrary/Types/FormattedReferenceRegion";
 import FormattedTimeReferenceLine from "../ChartLibrary/Types/FormattedTimeReferenceLine";
 import DataPointUtil from "../Utils/DataPoint";
@@ -119,7 +121,7 @@ const BarChartElement: FunctionComponent<BarInternalProps> = (
       <BarChart
         data={records}
         tickGap={30}
-        index={"Time"}
+        index={CHART_DATA_POINT_X_AXIS_KEY}
         categories={categories}
         colors={
           props.colors && props.colors.length > 0

package/UI/Components/Charts/ChartLibrary/Types/ChartDataPoint.ts

@@ -5,6 +5,19 @@
  */
 export const CHART_DATA_POINT_DATE_KEY: string = "__date";
 
+/**
+ * Per-row field carrying the FORMATTED x-axis label.
+ *
+ * This is the recharts `XAxis` dataKey — the Line / Bar / Area wrappers all
+ * pass it down as their `index` prop. `DataPointUtil` must therefore write
+ * the label under exactly this key: a row keyed anything else leaves every
+ * point with an undefined category, and recharts then draws no line, bar or
+ * area at all (the axes and grid still render, so the chart looks alive but
+ * empty). Keeping the single constant on both sides is what stops that from
+ * being an invisible coupling between two distant files.
+ */
+export const CHART_DATA_POINT_X_AXIS_KEY: string = "Time";
+
 export default interface ChartDataPoint {
   [x: string]: number | string;
 }

package/UI/Components/Charts/Line/LineChart.tsx

@@ -13,7 +13,9 @@ import SeriesPoint from "../Types/SeriesPoints";
 import { XAxis } from "../Types/XAxis/XAxis";
 import YAxis from "../Types/YAxis/YAxis";
 import ChartCurve from "../Types/ChartCurve";
-import ChartDataPoint from "../ChartLibrary/Types/ChartDataPoint";
+import ChartDataPoint, {
+  CHART_DATA_POINT_X_AXIS_KEY,
+} from "../ChartLibrary/Types/ChartDataPoint";
 import FormattedExemplarPoint from "../ChartLibrary/Types/FormattedExemplarPoint";
 import FormattedReferenceRegion from "../ChartLibrary/Types/FormattedReferenceRegion";
 import FormattedTimeReferenceLine from "../ChartLibrary/Types/FormattedTimeReferenceLine";
@@ -165,7 +167,7 @@ const LineChartElement: FunctionComponent<LineInternalProps> = (
       <LineChart
         data={records}
         tickGap={30}
-        index={"Time"}
+        index={CHART_DATA_POINT_X_AXIS_KEY}
         categories={categories}
         colors={
           props.colors && props.colors.length > 0

package/UI/Components/Charts/Types/XAxis/XAxis.ts

@@ -16,6 +16,12 @@ export interface XAxisOptions {
 }
 
 export interface XAxis {
+  /*
+   * Human-readable name for the axis. Purely descriptive: the per-row key
+   * the charts read is CHART_DATA_POINT_X_AXIS_KEY, never this string. It
+   * used to double as that key, which meant a caller passing anything but
+   * "Time" got a chart with axes and no series drawn on them.
+   */
   legend: string;
   options: XAxisOptions;
 }

package/UI/Components/Charts/Utils/DataPoint.ts

@@ -10,6 +10,7 @@
 import BadDataException from "../../../../Types/Exception/BadDataException";
 import ChartDataPoint, {
   CHART_DATA_POINT_DATE_KEY,
+  CHART_DATA_POINT_X_AXIS_KEY,
 } from "../ChartLibrary/Types/ChartDataPoint";
 import SeriesPoints from "../Types/SeriesPoints";
 import { XAxis, XAxisAggregateType } from "../Types/XAxis/XAxis";
@@ -30,18 +31,14 @@ export default class DataPointUtil {
     xAxis: XAxis;
     yAxis: YAxis;
   }): Array<ChartDataPoint> {
-    const { xAxisLegend, intervals, formatter } = this.initializeXAxisData(
-      data.xAxis,
-    );
+    const { intervals, formatter } = this.initializeXAxisData(data.xAxis);
     const arrayOfData: ChartDataPoint[] = this.initializeArrayOfData(
       intervals,
-      xAxisLegend,
       formatter,
     );
     this.processSeriesData(
       data.seriesPoints,
       arrayOfData,
-      xAxisLegend,
       formatter,
       data.xAxis.options.aggregateType,
     );
@@ -51,13 +48,11 @@ export default class DataPointUtil {
   private static initializeXAxisData(xAxis: XAxis): {
     xAxisMax: XAxisMaxMin;
     xAxisMin: XAxisMaxMin;
-    xAxisLegend: string;
     intervals: Array<Date>;
     formatter: (value: Date) => string;
   } {
     const xAxisMax: XAxisMaxMin = xAxis.options.max;
     const xAxisMin: XAxisMaxMin = xAxis.options.min;
-    const xAxisLegend: string = xAxis.legend;
     const intervals: Array<Date> = XAxisUtil.getPrecisionIntervals({
       xAxisMax,
       xAxisMin,
@@ -66,18 +61,25 @@ export default class DataPointUtil {
       xAxisMax,
       xAxisMin,
     });
-    return { xAxisMax, xAxisMin, xAxisLegend, intervals, formatter };
+    return { xAxisMax, xAxisMin, intervals, formatter };
   }
 
   private static initializeArrayOfData(
     intervals: Array<Date>,
-    xAxisLegend: string,
     formatter: (value: Date) => string,
   ): Array<ChartDataPoint> {
     const arrayOfData: Array<ChartDataPoint> = [];
     for (const interval of intervals) {
       const dataPoint: ChartDataPoint = {};
-      dataPoint[xAxisLegend] = formatter(interval);
+      /*
+       * Always the canonical key, NEVER `xAxis.legend`. The wrappers hand
+       * recharts this exact key as the XAxis dataKey, so keying rows off a
+       * caller-supplied string meant one caller passing anything else
+       * (the SLO dashboard widget passed "") produced rows recharts could
+       * not read — every point landed on an undefined category and the
+       * line silently vanished while the axes still drew.
+       */
+      dataPoint[CHART_DATA_POINT_X_AXIS_KEY] = formatter(interval);
       /*
        * The formatted label is not round-trippable back to a Date, so
        * keep the raw bucket start on the row — charts use it to recover
@@ -92,7 +94,6 @@ export default class DataPointUtil {
   private static processSeriesData(
     seriesPoints: Array<SeriesPoints>,
     arrayOfData: Array<ChartDataPoint>,
-    xAxisLegend: string,
     formatter: (value: Date) => string,
     aggregateType: XAxisAggregateType,
   ): { [key: string]: SeriesData } {
@@ -123,7 +124,9 @@ export default class DataPointUtil {
 
         const target: ChartDataPoint | undefined = arrayOfData.find(
           (chartDataPoint: ChartDataPoint) => {
-            return chartDataPoint[xAxisLegend] === formattedDate;
+            return (
+              chartDataPoint[CHART_DATA_POINT_X_AXIS_KEY] === formattedDate
+            );
           },
         );
         if (!target) {

package/UI/Components/ModelTable/CustomFieldColumns.tsx

@@ -5,6 +5,7 @@ import DropdownValueBadge from "../Dropdown/DropdownValueBadge";
 import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import OneUptimeDate from "../../../Types/Date";
 import { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
 import {
   CustomFieldDropdownOption,
@@ -200,6 +201,60 @@ export const renderCustomFieldValue: RenderCustomFieldValueFunction = (data: {
     );
   }
 
+  if (
+    definition.customFieldType === CustomFieldType.Date ||
+    definition.customFieldType === CustomFieldType.DateTime
+  ) {
+    /*
+     * Stored as ISO-8601 (the shared date Input normalises every entry through
+     * OneUptimeDate.toString()), which is unreadable in a cell, so it is shown
+     * in the viewer's own timezone — the same rendering Detail gives a date
+     * field, so the list and the item page agree.
+     */
+    const isDateOnly: boolean =
+      definition.customFieldType === CustomFieldType.Date;
+    const raw: string = String(value);
+
+    /*
+     * Validity is decided here rather than by inspecting what the formatter
+     * returned, because the formatter never reports failure: OneUptimeDate
+     * .fromString swallows moment's parse error and falls back to `new
+     * Date(str)`, so junk becomes an Invalid Date and moment renders it as the
+     * literal, truthy string "Invalid date" (and "Invalid date UTC" for the
+     * DateTime variant). A `formatted || raw` fallback therefore never fires.
+     *
+     * Showing the raw text instead matters because the value is not
+     * necessarily one this UI wrote — a project can PUT anything into the
+     * `customFields` bag over the API, and may well have been storing dates as
+     * free text before this field became a date. "Invalid date" hides which
+     * value is wrong; the value itself is the thing that lets someone fix it.
+     */
+    let parsed: Date | null = null;
+
+    try {
+      parsed = OneUptimeDate.fromString(raw);
+    } catch {
+      parsed = null;
+    }
+
+    if (!parsed || isNaN(parsed.getTime())) {
+      return <span>{raw}</span>;
+    }
+
+    try {
+      return (
+        <span>
+          {OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(
+            parsed,
+            isDateOnly,
+          )}
+        </span>
+      );
+    } catch {
+      return <span>{raw}</span>;
+    }
+  }
+
   if (definition.customFieldType === CustomFieldType.MultiSelectDropdown) {
     /*
      * Tolerant on the way out: an older single-select value that was later

package/Utils/Monitor/NetworkDeviceRoleUtil.ts

@@ -531,3 +531,48 @@ export function labelForDeviceRole(
   }
   return DEVICE_ROLE_LABELS[role] || DEVICE_ROLE_LABELS.unknown;
 }
+
+/**
+ * Read an operator's stored role override off a NetworkDevice row.
+ *
+ * The classifier above is evidence-driven, and its evidence is SNMP: a
+ * device nothing walks — a ping-only device imported by discovery, say —
+ * offers it a hostname and nothing else, so it comes back "unknown" and
+ * stays there forever. `NetworkDevice.deviceRole` is the operator saying
+ * what the box actually is, and it is the only statement about a role that
+ * is not an inference, so it outranks everything the classifier can find.
+ *
+ * Undefined means "no override" — NOT "unknown". The two are different
+ * answers and the difference decides whether the classifier gets to run at
+ * all, which is why an unrecognised or empty column reads as undefined
+ * rather than falling back to a role. "unknown" is itself refused as an
+ * override for the same reason: storing it would silently disable the
+ * classifier on a device the operator was only declining to classify.
+ */
+export function parseDeviceRoleOverride(
+  value: string | undefined | null,
+): NetworkTopologyDeviceRole | undefined {
+  const normalized: string = (value || "").trim().toLowerCase();
+  if (!normalized) {
+    return undefined;
+  }
+  return DEVICE_ROLES_IN_LEGEND_ORDER.find(
+    (role: NetworkTopologyDeviceRole) => {
+      return role.toLowerCase() === normalized;
+    },
+  );
+}
+
+/**
+ * The role to draw a managed device with: the operator's override when
+ * there is one, otherwise whatever the evidence supports.
+ *
+ * One function so the topology builder, the forms and the tests cannot
+ * drift about which of the two wins.
+ */
+export function resolveDeviceRole(
+  roleOverride: string | undefined | null,
+  signals: DeviceRoleSignals,
+): NetworkTopologyDeviceRole {
+  return parseDeviceRoleOverride(roleOverride) ?? classifyDeviceRole(signals);
+}

package/Utils/Monitor/NetworkTopologyUtil.ts

@@ -11,6 +11,7 @@ import { normalizeMac } from "./EndpointAttachmentUtil";
 import {
   classifyDeviceRole,
   classifyEndpointRole,
+  resolveDeviceRole,
 } from "./NetworkDeviceRoleUtil";
 
 export interface TopologyDeviceInput {
@@ -29,6 +30,14 @@ export interface TopologyDeviceInput {
    */
   sysDescr?: string | undefined;
   sysObjectId?: string | undefined;
+  /*
+   * The operator's own answer to what this device is, when they gave one.
+   * Outranks the classifier below, because it is the only statement about
+   * the role that is not an inference — and on a device nothing walks it
+   * is the ONLY statement available at all, the classifier having nothing
+   * but a hostname to go on.
+   */
+  deviceRole?: string | undefined;
   /*
    * ENTITY-MIB chassis serial. Not rendered — it is here because LLDP
    * chassis-id subtype 7 ("locally assigned") is very often exactly this
@@ -109,6 +118,13 @@ export interface TopologyManualLinkInput {
   toPortName?: string | undefined;
   // Health from a bound Monitor, already reduced by the caller.
   monitorStatus?: "up" | "down" | undefined;
+  /*
+   * Whichever end the operator declared the parent, when they declared
+   * one. Must be `fromDeviceId` or `toDeviceId`; anything else is dropped
+   * rather than drawn, because a parent that is not on the link cannot be
+   * rendered as one and a wrong hierarchy is worse than an inferred one.
+   */
+  parentDeviceId?: string | undefined;
 }
 
 /*
@@ -232,7 +248,10 @@ export default class NetworkTopologyUtil {
    * alias are one unmanaged node, however many switches saw it. Edges are
    * undirected and deduplicated — a link reported from both ends, or by
    * both protocols, appears once with the union of what each report knew
-   * (ports, protocols, per-end interface state). When `interfaces` rows are
+   * (ports, protocols, per-end interface state). Undirected in the sense
+   * that neither end is privileged by how the edge was discovered: an edge
+   * carries a direction only where an operator declared one, as
+   * `parentNodeId`. When `interfaces` rows are
    * provided, each edge end whose interface is identifiable carries its
    * operational state (up/down, utilization, rates). When `endpoints` rows
    * are provided, each one that attaches to a device in the graph becomes an
@@ -306,7 +325,7 @@ export default class NetworkTopologyUtil {
         name: device.name,
         isManaged: true,
         kind: "device",
-        role: classifyDeviceRole({
+        role: resolveDeviceRole(device.deviceRole, {
           sysDescr: device.sysDescr,
           sysObjectId: device.sysObjectId,
           vendor: device.vendor,
@@ -520,6 +539,18 @@ export default class NetworkTopologyUtil {
         continue;
       }
 
+      /*
+       * A declared parent is only meaningful if it is one of the two ends.
+       * The service refuses anything else at write time, so this is a
+       * second line rather than the only one — it also covers rule-derived
+       * links, which never pass through that service.
+       */
+      const declaredParentId: string | undefined =
+        link.parentDeviceId === link.fromDeviceId ||
+        link.parentDeviceId === link.toDeviceId
+          ? link.parentDeviceId
+          : undefined;
+
       const edgeKey: string = [link.fromDeviceId, link.toDeviceId]
         .sort()
         .join("::");
@@ -534,6 +565,7 @@ export default class NetworkTopologyUtil {
           protocols: ["manual"],
           monitorState: link.monitorStatus,
           name: link.name,
+          parentNodeId: declaredParentId,
         });
         continue;
       }
@@ -557,6 +589,14 @@ export default class NetworkTopologyUtil {
       }
       existing.name = existing.name || link.name;
       existing.monitorState = existing.monitorState ?? link.monitorStatus;
+      /*
+       * First declaration wins, matching the ordering the caller already
+       * relies on: explicit links are merged before rule-derived ones, so
+       * a hierarchy somebody set on the link itself beats a rule that
+       * happens to cover the same pair. The specific statement beats the
+       * general one — the same precedence the ports and the name use.
+       */
+      existing.parentNodeId = existing.parentNodeId || declaredParentId;
     }
 
     const edges: Array<NetworkTopologyEdge> = Array.from(edgeByKey.values());

package/build/dist/Models/DatabaseModels/NetworkDevice.js

@@ -50,6 +50,7 @@ let NetworkDevice = class NetworkDevice extends BaseModel {
         this.currentMonitorStatus = undefined;
         this.currentMonitorStatusId = undefined;
         this.monitoringMethod = undefined;
+        this.deviceRole = undefined;
         this.monitor = undefined;
         this.monitorId = undefined;
         this.snmpVersion = undefined;
@@ -641,6 +642,50 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], NetworkDevice.prototype, "monitoringMethod", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.SettingsAdmin,
+            Permission.SettingsMember,
+            Permission.CreateNetworkDevice,
+        ],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.Viewer,
+            Permission.SettingsAdmin,
+            Permission.SettingsMember,
+            Permission.SettingsViewer,
+            Permission.ReadNetworkDevice,
+        ],
+        update: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.SettingsAdmin,
+            Permission.SettingsMember,
+            Permission.EditNetworkDevice,
+        ],
+    }),
+    TableColumn({
+        required: false,
+        type: TableColumnType.ShortText,
+        canReadOnRelationQuery: true,
+        title: "Device Role",
+        description: "What this device does on the network — router, switch, access point and so on. Left empty, the role is worked out from the device's own SNMP identity. Set it when there is no SNMP to read: a ping-only device has no identity to classify, and the role decides both the shape it is drawn with and where it sits in the topology hierarchy.",
+        example: "switch",
+    }),
+    Column({
+        nullable: true,
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+    }),
+    __metadata("design:type", String)
+], NetworkDevice.prototype, "deviceRole", void 0);
 __decorate([
     ColumnAccessControl({
         create: [