@oneuptime/common 12.0.17 → 12.0.18

package/Tests/Types/Kubernetes/KubernetesRightSizing.test.ts

@@ -7,6 +7,7 @@ import {
   buildRightSizingRecommendation,
   formatCpuCores,
   formatMemoryBytes,
+  getVerdictLabel,
   hasActionableRecommendation,
 } from "../../../Types/Kubernetes/KubernetesRightSizing";
 import { describe, expect, test } from "@jest/globals";
@@ -321,3 +322,55 @@ describe("formatting", () => {
     expect(formatMemoryBytes(null)).toBe("-");
   });
 });
+
+/*
+ * getVerdictLabel turns the internal verdict enum into the human string the
+ * right-sizing UI renders. It is a switch with a default arm, so the failure it
+ * invites is a new verdict added to the enum without a matching case — it would
+ * silently render as "Unavailable". This block pins each label and, crucially,
+ * that every enum member has an explicit, distinct, non-"Unavailable" label
+ * except the one that is meant to be Unavailable.
+ */
+describe("getVerdictLabel", () => {
+  const EXPECTED: Array<[RightSizingVerdict, string]> = [
+    [RightSizingVerdict.Overprovisioned, "Over-provisioned"],
+    [RightSizingVerdict.Underprovisioned, "Under-provisioned"],
+    [RightSizingVerdict.Optimal, "Right-sized"],
+    [RightSizingVerdict.NoRequestSet, "No request set"],
+    [RightSizingVerdict.Unavailable, "Unavailable"],
+  ];
+
+  test.each(EXPECTED)(
+    "maps %s to its label",
+    (verdict: RightSizingVerdict, label: string) => {
+      expect(getVerdictLabel(verdict)).toBe(label);
+    },
+  );
+
+  test("every verdict produces a non-empty label", () => {
+    for (const verdict of Object.values(RightSizingVerdict)) {
+      const label: string = getVerdictLabel(verdict);
+      expect(typeof label).toBe("string");
+      expect(label.length).toBeGreaterThan(0);
+    }
+  });
+
+  test('only the Unavailable verdict resolves to "Unavailable"', () => {
+    /*
+     * If a new verdict fell through to the default arm, more than one enum
+     * member would carry the "Unavailable" label — catch that here.
+     */
+    const unavailableCount: number = Object.values(RightSizingVerdict).filter(
+      (verdict: RightSizingVerdict) => {
+        return getVerdictLabel(verdict) === "Unavailable";
+      },
+    ).length;
+    expect(unavailableCount).toBe(1);
+  });
+
+  test("an unknown verdict falls back to Unavailable", () => {
+    expect(getVerdictLabel("SomethingElse" as RightSizingVerdict)).toBe(
+      "Unavailable",
+    );
+  });
+});

package/Tests/Types/Measurement/MeasurementAggregationType.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "@jest/globals";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import MeasurementAggregationType, {
+  MeasurementAggregationTypeUtil,
+} from "../../../Types/Measurement/MeasurementAggregationType";
+
+/*
+ * MeasurementAggregationType is the deliberately-narrow subset of
+ * AggregationType a measurement chart is allowed to default to (Sum is left
+ * out on purpose: summing durations across incidents is meaningless). The Util
+ * maps each subset member onto the full AggregationType the query layer
+ * understands. The mapping is a switch with a default arm, so the failure it
+ * invites is a member added to the enum without a matching case — it would
+ * silently fall through to Avg. This suite pins the mapping and that
+ * exhaustiveness.
+ */
+
+describe("MeasurementAggregationType", () => {
+  test("is a strict subset of AggregationType and excludes Sum/Count", () => {
+    const full: Array<string> = Object.values(AggregationType);
+    for (const member of Object.values(MeasurementAggregationType)) {
+      // Every measurement member must be a real AggregationType value.
+      expect(full).toContain(member);
+    }
+    // The two intentionally-omitted members must never appear here.
+    expect(Object.values(MeasurementAggregationType)).not.toContain(
+      AggregationType.Sum as unknown as MeasurementAggregationType,
+    );
+    expect(Object.values(MeasurementAggregationType)).not.toContain(
+      AggregationType.Count as unknown as MeasurementAggregationType,
+    );
+  });
+});
+
+describe("MeasurementAggregationTypeUtil.toAggregationType", () => {
+  const CASES: Array<[MeasurementAggregationType, AggregationType]> = [
+    [MeasurementAggregationType.Avg, AggregationType.Avg],
+    [MeasurementAggregationType.Max, AggregationType.Max],
+    [MeasurementAggregationType.Min, AggregationType.Min],
+    [MeasurementAggregationType.P50, AggregationType.P50],
+    [MeasurementAggregationType.P90, AggregationType.P90],
+    [MeasurementAggregationType.P95, AggregationType.P95],
+    [MeasurementAggregationType.P99, AggregationType.P99],
+  ];
+
+  test.each(CASES)(
+    "maps %s to the matching AggregationType",
+    (input: MeasurementAggregationType, expected: AggregationType) => {
+      expect(MeasurementAggregationTypeUtil.toAggregationType(input)).toBe(
+        expected,
+      );
+    },
+  );
+
+  test("covers every enum member (no member falls through to the default)", () => {
+    /*
+     * If a new member is added to MeasurementAggregationType without its own
+     * case, it would resolve to Avg here. Compare against an independently
+     * built expectation so that fall-through is caught rather than accepted.
+     */
+    const mapped: Set<AggregationType> = new Set<AggregationType>(
+      Object.values(MeasurementAggregationType).map(
+        (m: MeasurementAggregationType) => {
+          return MeasurementAggregationTypeUtil.toAggregationType(m);
+        },
+      ),
+    );
+    // Avg, Max, Min, P50, P90, P95, P99 => 7 distinct targets.
+    expect(mapped.size).toBe(Object.values(MeasurementAggregationType).length);
+  });
+
+  test("defaults undefined to Avg", () => {
+    // The picker can be empty; an unset selection must resolve to a safe Avg.
+    expect(MeasurementAggregationTypeUtil.toAggregationType(undefined)).toBe(
+      AggregationType.Avg,
+    );
+  });
+
+  test("an unknown value falls back to Avg rather than throwing", () => {
+    // Defensive: a value outside the enum (bad persisted data) must not crash.
+    expect(
+      MeasurementAggregationTypeUtil.toAggregationType(
+        "NotARealAggregation" as MeasurementAggregationType,
+      ),
+    ).toBe(AggregationType.Avg);
+  });
+
+  test("only ever returns AggregationTypes valid for measurements", () => {
+    /*
+     * The mapping must never emit Sum or Count — those are exactly the
+     * aggregations the measurement subset exists to keep out.
+     */
+    for (const member of Object.values(MeasurementAggregationType)) {
+      const result: AggregationType =
+        MeasurementAggregationTypeUtil.toAggregationType(member);
+      expect(result).not.toBe(AggregationType.Sum);
+      expect(result).not.toBe(AggregationType.Count);
+    }
+  });
+});

package/Tests/Types/Monitor/MonitorStepConfigHelpers.test.ts

@@ -1,7 +1,10 @@
 import {
   DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS,
+  DEFAULT_MONITOR_RETRY_COUNT,
   MAX_MONITOR_REQUEST_TIMEOUT_IN_MS,
+  MAX_MONITOR_RETRY_COUNT,
   clampMonitorRequestTimeoutInMs,
+  clampMonitorRetryCount,
 } from "../../../Types/Monitor/MonitorStep";
 import { describe, expect, test } from "@jest/globals";
 
@@ -163,3 +166,114 @@ describe("clampMonitorRequestTimeoutInMs", () => {
     });
   });
 });
+
+/*
+ * clampMonitorRetryCount constrains how many times a probe retries a step. Its
+ * guard differs from the timeout clamp in one behaviour that matters: the lower
+ * bound is `value < 0`, NOT `value <= 0`. Zero is therefore a VALID retry count
+ * (retry never) and must pass through unchanged, whereas only genuinely invalid
+ * inputs (undefined / null / NaN / negative) fall back to the default. These
+ * tests pin exactly that zero-is-valid distinction plus the usual boundary and
+ * defensive-coercion cases.
+ */
+describe("clampMonitorRetryCount", () => {
+  describe("invalid inputs fall back to the default", () => {
+    test("NaN returns the default", () => {
+      expect(clampMonitorRetryCount(NaN)).toBe(DEFAULT_MONITOR_RETRY_COUNT);
+    });
+
+    test("a negative value returns the default (not a clamp to zero)", () => {
+      expect(clampMonitorRetryCount(-1)).toBe(DEFAULT_MONITOR_RETRY_COUNT);
+    });
+
+    test("negative Infinity returns the default", () => {
+      expect(clampMonitorRetryCount(-Infinity)).toBe(
+        DEFAULT_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("undefined coerced through the signature returns the default", () => {
+      expect(clampMonitorRetryCount(undefined as unknown as number)).toBe(
+        DEFAULT_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("null coerced through the signature returns the default", () => {
+      expect(clampMonitorRetryCount(null as unknown as number)).toBe(
+        DEFAULT_MONITOR_RETRY_COUNT,
+      );
+    });
+  });
+
+  describe("zero is a valid retry count", () => {
+    test("zero passes through unchanged (retry never)", () => {
+      // The whole point of `< 0` rather than `<= 0`: 0 is a real choice.
+      expect(clampMonitorRetryCount(0)).toBe(0);
+    });
+
+    test("negative zero also passes through as a numeric zero", () => {
+      /*
+       * -0 < 0 is false, so -0 is not treated as invalid and passes through.
+       * It stays -0 (toBe uses Object.is, under which -0 !== 0), which is still
+       * numerically zero — assert that rather than the Object.is identity.
+       */
+      const result: number = clampMonitorRetryCount(-0);
+      expect(result === 0).toBe(true);
+      expect(Math.abs(result)).toBe(0);
+    });
+  });
+
+  describe("in-range and boundary values", () => {
+    test("a value between 0 and the cap is returned unchanged", () => {
+      expect(clampMonitorRetryCount(1)).toBe(1);
+      expect(clampMonitorRetryCount(2)).toBe(2);
+    });
+
+    test("a value exactly at the cap is returned, not clamped", () => {
+      expect(clampMonitorRetryCount(MAX_MONITOR_RETRY_COUNT)).toBe(
+        MAX_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("one over the cap is clamped down to the cap", () => {
+      expect(clampMonitorRetryCount(MAX_MONITOR_RETRY_COUNT + 1)).toBe(
+        MAX_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("positive Infinity is clamped to the cap", () => {
+      expect(clampMonitorRetryCount(Infinity)).toBe(MAX_MONITOR_RETRY_COUNT);
+    });
+  });
+
+  describe("stability and invariants", () => {
+    test("the exported cap and default are non-negative finite numbers", () => {
+      expect(Number.isFinite(MAX_MONITOR_RETRY_COUNT)).toBe(true);
+      expect(MAX_MONITOR_RETRY_COUNT).toBeGreaterThanOrEqual(0);
+      expect(DEFAULT_MONITOR_RETRY_COUNT).toBeGreaterThanOrEqual(0);
+      expect(DEFAULT_MONITOR_RETRY_COUNT).toBeLessThanOrEqual(
+        MAX_MONITOR_RETRY_COUNT,
+      );
+    });
+
+    test("across a sweep the result is always within [0, cap]", () => {
+      const samples: Array<number> = [
+        -100,
+        -1,
+        0,
+        1,
+        2,
+        3,
+        4,
+        1000,
+        Infinity,
+        NaN,
+      ];
+      for (const sample of samples) {
+        const result: number = clampMonitorRetryCount(sample);
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(result).toBeLessThanOrEqual(MAX_MONITOR_RETRY_COUNT);
+      }
+    });
+  });
+});

package/Tests/Types/Workspace/WorkspaceType.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "@jest/globals";
+import WorkspaceType, {
+  getWorkspaceTypeDisplayName,
+} from "../../../Types/Workspace/WorkspaceType";
+
+/*
+ * getWorkspaceTypeDisplayName turns the WorkspaceType enum into the label shown
+ * wherever a workspace integration is named in the UI. The only member whose
+ * display name differs from its enum value is MicrosoftTeams ("Microsoft Teams"
+ * with a space); the rest fall through to returning the raw value. The suite
+ * pins that spacing and guards the fall-through: a new workspace type added to
+ * the enum must still yield a non-empty label rather than undefined.
+ */
+
+describe("getWorkspaceTypeDisplayName", () => {
+  test("renders Microsoft Teams with a space", () => {
+    // The enum value is "MicrosoftTeams"; the label must be human-spaced.
+    expect(getWorkspaceTypeDisplayName(WorkspaceType.MicrosoftTeams)).toBe(
+      "Microsoft Teams",
+    );
+  });
+
+  test("renders Slack as-is", () => {
+    expect(getWorkspaceTypeDisplayName(WorkspaceType.Slack)).toBe("Slack");
+  });
+
+  test("every workspace type yields a non-empty display name", () => {
+    for (const type of Object.values(WorkspaceType)) {
+      const label: string = getWorkspaceTypeDisplayName(type);
+      expect(typeof label).toBe("string");
+      expect(label.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("display names are unique across workspace types", () => {
+    const labels: Array<string> = Object.values(WorkspaceType).map(
+      (type: WorkspaceType) => {
+        return getWorkspaceTypeDisplayName(type);
+      },
+    );
+    expect(new Set<string>(labels).size).toBe(labels.length);
+  });
+
+  test("an unknown value falls back to the raw string it was given", () => {
+    /*
+     * The function's default arm returns its argument unchanged. Persisted or
+     * mistyped data must therefore round-trip rather than become undefined.
+     */
+    expect(getWorkspaceTypeDisplayName("Discord" as WorkspaceType)).toBe(
+      "Discord",
+    );
+  });
+});

package/Tests/Utils/Dashboard/Components/DashboardComponentDefaults.test.ts

@@ -0,0 +1,257 @@
+import { describe, expect, test } from "@jest/globals";
+import DashboardComponentType from "../../../../Types/Dashboard/DashboardComponentType";
+import DashboardBaseComponent from "../../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import ObjectID from "../../../../Types/ObjectID";
+import { ObjectType } from "../../../../Types/JSON";
+import DashboardAlertListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardAlertListComponent";
+import DashboardCephOsdListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardCephOsdListComponent";
+import DashboardCephPoolListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardCephPoolListComponent";
+import DashboardChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardChartComponent";
+import DashboardClockComponentUtil from "../../../../Utils/Dashboard/Components/DashboardClockComponent";
+import DashboardDataSourceChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceChartComponent";
+import DashboardDataSourceGaugeComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceGaugeComponent";
+import DashboardDataSourceTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceTableComponent";
+import DashboardDataSourceValueComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceValueComponent";
+import DashboardDockerContainerListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerContainerListComponent";
+import DashboardDockerHostListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerHostListComponent";
+import DashboardDockerImageListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerImageListComponent";
+import DashboardDockerNetworkListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerNetworkListComponent";
+import DashboardDockerSwarmNodeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerSwarmNodeListComponent";
+import DashboardDockerSwarmServiceListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerSwarmServiceListComponent";
+import DashboardDockerVolumeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerVolumeListComponent";
+import DashboardGaugeComponentUtil from "../../../../Utils/Dashboard/Components/DashboardGaugeComponent";
+import DashboardHostListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardHostListComponent";
+import DashboardHtmlComponentUtil from "../../../../Utils/Dashboard/Components/DashboardHtmlComponent";
+import DashboardIncidentListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardIncidentListComponent";
+import DashboardKubernetesCronJobListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesCronJobListComponent";
+import DashboardKubernetesDaemonSetListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesDaemonSetListComponent";
+import DashboardKubernetesDeploymentListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesDeploymentListComponent";
+import DashboardKubernetesJobListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesJobListComponent";
+import DashboardKubernetesNamespaceListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesNamespaceListComponent";
+import DashboardKubernetesNodeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesNodeListComponent";
+import DashboardKubernetesPodListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesPodListComponent";
+import DashboardKubernetesStatefulSetListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesStatefulSetListComponent";
+import DashboardLogChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardLogChartComponent";
+import DashboardLogStreamComponentUtil from "../../../../Utils/Dashboard/Components/DashboardLogStreamComponent";
+import DashboardMonitorListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardMonitorListComponent";
+import DashboardNetworkMapComponentUtil from "../../../../Utils/Dashboard/Components/DashboardNetworkMapComponent";
+import DashboardPodmanContainerListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanContainerListComponent";
+import DashboardPodmanHostListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanHostListComponent";
+import DashboardPodmanImageListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanImageListComponent";
+import DashboardPodmanNetworkListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanNetworkListComponent";
+import DashboardPodmanVolumeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanVolumeListComponent";
+import DashboardProxmoxGuestListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardProxmoxGuestListComponent";
+import DashboardProxmoxNodeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardProxmoxNodeListComponent";
+import DashboardSecurityEventsFlowComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSecurityEventsFlowComponent";
+import DashboardSecurityEventsListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSecurityEventsListComponent";
+import DashboardSloComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSloComponent";
+import DashboardTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTableComponent";
+import DashboardTextComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTextComponent";
+import DashboardTraceChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceChartComponent";
+import DashboardTraceListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceListComponent";
+import DashboardTraceTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceTableComponent";
+import DashboardValueComponentUtil from "../../../../Utils/Dashboard/Components/DashboardValueComponent";
+import DashboardBaseComponentUtil from "../../../../Utils/Dashboard/Components/DashboardBaseComponent";
+
+/*
+ * Every dashboard widget type ships a getDefaultComponent() that returns the
+ * seed component the editor drops onto the canvas when a user first adds that
+ * widget. Unlike getComponentSettingsArguments (dispatched through Index.ts and
+ * already covered by DashboardComponentsUtil.test.ts), these defaults have no
+ * central dispatcher — each util overrides the method independently. That makes
+ * them easy to get subtly wrong in ways the compiler cannot catch:
+ *
+ *   - copy-pasting a util and forgetting to change the componentType field, so
+ *     two widget types seed the same type and the editor renders the wrong one;
+ *   - a min dimension larger than the default dimension, so the widget is born
+ *     smaller than its own minimum and the resize logic clamps it on drop;
+ *   - a zero/negative width or height, so the widget is invisible on the grid;
+ *   - a shared componentId constant instead of a freshly generated ObjectID, so
+ *     two widgets on the same dashboard collide on id.
+ *
+ * This suite pins those invariants for all widget types at once. The TYPE_TO_UTIL
+ * map below must stay in lockstep with the enum; the exhaustiveness test fails
+ * loudly if a new widget type is added without a default to guard here.
+ */
+
+type ComponentUtil = {
+  getDefaultComponent: () => DashboardBaseComponent;
+};
+
+const TYPE_TO_UTIL: Record<DashboardComponentType, ComponentUtil> = {
+  [DashboardComponentType.Chart]: DashboardChartComponentUtil,
+  [DashboardComponentType.Text]: DashboardTextComponentUtil,
+  [DashboardComponentType.Clock]: DashboardClockComponentUtil,
+  [DashboardComponentType.Value]: DashboardValueComponentUtil,
+  [DashboardComponentType.Table]: DashboardTableComponentUtil,
+  [DashboardComponentType.Gauge]: DashboardGaugeComponentUtil,
+  [DashboardComponentType.DataSourceChart]:
+    DashboardDataSourceChartComponentUtil,
+  [DashboardComponentType.DataSourceValue]:
+    DashboardDataSourceValueComponentUtil,
+  [DashboardComponentType.DataSourceGauge]:
+    DashboardDataSourceGaugeComponentUtil,
+  [DashboardComponentType.DataSourceTable]:
+    DashboardDataSourceTableComponentUtil,
+  [DashboardComponentType.LogStream]: DashboardLogStreamComponentUtil,
+  [DashboardComponentType.LogChart]: DashboardLogChartComponentUtil,
+  [DashboardComponentType.SecurityEventsList]:
+    DashboardSecurityEventsListComponentUtil,
+  [DashboardComponentType.SecurityEventsFlow]:
+    DashboardSecurityEventsFlowComponentUtil,
+  [DashboardComponentType.TraceList]: DashboardTraceListComponentUtil,
+  [DashboardComponentType.TraceChart]: DashboardTraceChartComponentUtil,
+  [DashboardComponentType.TraceTable]: DashboardTraceTableComponentUtil,
+  [DashboardComponentType.IncidentList]: DashboardIncidentListComponentUtil,
+  [DashboardComponentType.AlertList]: DashboardAlertListComponentUtil,
+  [DashboardComponentType.MonitorList]: DashboardMonitorListComponentUtil,
+  [DashboardComponentType.Slo]: DashboardSloComponentUtil,
+  [DashboardComponentType.KubernetesPodList]:
+    DashboardKubernetesPodListComponentUtil,
+  [DashboardComponentType.KubernetesNodeList]:
+    DashboardKubernetesNodeListComponentUtil,
+  [DashboardComponentType.KubernetesNamespaceList]:
+    DashboardKubernetesNamespaceListComponentUtil,
+  [DashboardComponentType.KubernetesDeploymentList]:
+    DashboardKubernetesDeploymentListComponentUtil,
+  [DashboardComponentType.KubernetesStatefulSetList]:
+    DashboardKubernetesStatefulSetListComponentUtil,
+  [DashboardComponentType.KubernetesDaemonSetList]:
+    DashboardKubernetesDaemonSetListComponentUtil,
+  [DashboardComponentType.KubernetesJobList]:
+    DashboardKubernetesJobListComponentUtil,
+  [DashboardComponentType.KubernetesCronJobList]:
+    DashboardKubernetesCronJobListComponentUtil,
+  [DashboardComponentType.DockerHostList]: DashboardDockerHostListComponentUtil,
+  [DashboardComponentType.DockerContainerList]:
+    DashboardDockerContainerListComponentUtil,
+  [DashboardComponentType.DockerImageList]:
+    DashboardDockerImageListComponentUtil,
+  [DashboardComponentType.DockerNetworkList]:
+    DashboardDockerNetworkListComponentUtil,
+  [DashboardComponentType.DockerVolumeList]:
+    DashboardDockerVolumeListComponentUtil,
+  [DashboardComponentType.PodmanHostList]: DashboardPodmanHostListComponentUtil,
+  [DashboardComponentType.PodmanContainerList]:
+    DashboardPodmanContainerListComponentUtil,
+  [DashboardComponentType.PodmanImageList]:
+    DashboardPodmanImageListComponentUtil,
+  [DashboardComponentType.PodmanNetworkList]:
+    DashboardPodmanNetworkListComponentUtil,
+  [DashboardComponentType.PodmanVolumeList]:
+    DashboardPodmanVolumeListComponentUtil,
+  [DashboardComponentType.HostList]: DashboardHostListComponentUtil,
+  [DashboardComponentType.ProxmoxNodeList]:
+    DashboardProxmoxNodeListComponentUtil,
+  [DashboardComponentType.ProxmoxGuestList]:
+    DashboardProxmoxGuestListComponentUtil,
+  [DashboardComponentType.DockerSwarmNodeList]:
+    DashboardDockerSwarmNodeListComponentUtil,
+  [DashboardComponentType.DockerSwarmServiceList]:
+    DashboardDockerSwarmServiceListComponentUtil,
+  [DashboardComponentType.CephOsdList]: DashboardCephOsdListComponentUtil,
+  [DashboardComponentType.CephPoolList]: DashboardCephPoolListComponentUtil,
+  [DashboardComponentType.NetworkMap]: DashboardNetworkMapComponentUtil,
+  [DashboardComponentType.Html]: DashboardHtmlComponentUtil,
+};
+
+const ALL_TYPES: Array<DashboardComponentType> = Object.values(
+  DashboardComponentType,
+);
+
+describe("Dashboard component getDefaultComponent()", () => {
+  test("every DashboardComponentType has a default component guarded here", () => {
+    // If a new widget type is added to the enum, this fails until it is mapped.
+    for (const type of ALL_TYPES) {
+      expect(TYPE_TO_UTIL[type]).toBeDefined();
+    }
+    // And nothing stale: the map must not carry keys the enum dropped.
+    expect(Object.keys(TYPE_TO_UTIL).sort()).toEqual([...ALL_TYPES].sort());
+  });
+
+  test.each(ALL_TYPES)(
+    "%s default is a well-formed dashboard component",
+    (type: DashboardComponentType) => {
+      const component: DashboardBaseComponent =
+        TYPE_TO_UTIL[type].getDefaultComponent();
+
+      // It must be tagged as a dashboard component so serialization routes it right.
+      expect(component._type).toBe(ObjectType.DashboardComponent);
+
+      /*
+       * The seeded componentType must match the type the editor asked for; a
+       * copy-paste that leaves the wrong type here makes the widget render as a
+       * different kind than the one the user picked.
+       */
+      expect(component.componentType).toBe(type);
+
+      // A zero/negative footprint means the widget is invisible on the grid.
+      expect(component.widthInDashboardUnits).toBeGreaterThan(0);
+      expect(component.heightInDashboardUnits).toBeGreaterThan(0);
+      expect(component.minWidthInDashboardUnits).toBeGreaterThan(0);
+      expect(component.minHeightInDashboardUnits).toBeGreaterThan(0);
+
+      /*
+       * The default size must not start below its own minimum, or the resize
+       * clamp shrinks the widget the instant it is dropped.
+       */
+      expect(component.widthInDashboardUnits).toBeGreaterThanOrEqual(
+        component.minWidthInDashboardUnits,
+      );
+      expect(component.heightInDashboardUnits).toBeGreaterThanOrEqual(
+        component.minHeightInDashboardUnits,
+      );
+
+      // A widget is dropped at the origin; negative offsets place it off-grid.
+      expect(component.topInDashboardUnits).toBeGreaterThanOrEqual(0);
+      expect(component.leftInDashboardUnits).toBeGreaterThanOrEqual(0);
+
+      // The id must be a real, generated ObjectID (UUID), not a placeholder.
+      expect(component.componentId).toBeInstanceOf(ObjectID);
+      expect(ObjectID.isValidUUID(component.componentId.toString())).toBe(true);
+    },
+  );
+
+  test("no two widget types seed the same componentType", () => {
+    /*
+     * Guards the classic copy-paste bug: duplicating a util and forgetting to
+     * change componentType. Every default must report a distinct type.
+     */
+    const seededTypes: Array<DashboardComponentType> = ALL_TYPES.map(
+      (type: DashboardComponentType) => {
+        return TYPE_TO_UTIL[type].getDefaultComponent().componentType;
+      },
+    );
+    expect(new Set<DashboardComponentType>(seededTypes).size).toBe(
+      seededTypes.length,
+    );
+  });
+
+  test("each call generates a fresh componentId so widgets never collide", () => {
+    /*
+     * Two of the same widget added to one dashboard must not share an id, or
+     * selection/deletion in the editor would act on both at once. This only
+     * holds if getDefaultComponent() calls ObjectID.generate() per call rather
+     * than reusing a module-level constant.
+     */
+    for (const type of ALL_TYPES) {
+      const first: DashboardBaseComponent =
+        TYPE_TO_UTIL[type].getDefaultComponent();
+      const second: DashboardBaseComponent =
+        TYPE_TO_UTIL[type].getDefaultComponent();
+      expect(first.componentId.toString()).not.toBe(
+        second.componentId.toString(),
+      );
+    }
+  });
+
+  test("the base component util refuses to seed a component", () => {
+    /*
+     * The base class intentionally throws so a util that forgets to override
+     * getDefaultComponent() fails fast instead of returning a typeless stub.
+     */
+    expect(() => {
+      return DashboardBaseComponentUtil.getDefaultComponent();
+    }).toThrow();
+  });
+});

package/Types/Billing/PayAsYouGoPricing.ts

@@ -10,7 +10,7 @@
  * worse than quoting no price at all, so there is exactly one copy.
  */
 
-// Telemetry ingest - logs, traces, metrics and profiles.
+// Telemetry ingest - logs, traces, metrics, profiles and security events.
 export const TELEMETRY_PRICE_IN_USD_PER_GB: number = 0.1;
 
 /*

package/build/dist/Server/Services/BillingService.js

@@ -1423,6 +1423,12 @@ export class BillingService extends BaseService {
             }
             return "price_1U0iWJANuQdJ93r7iVAXwhdP";
         }
+        if (productType === ProductType.SecurityEvents) {
+            if (this.isTestEnvironment()) {
+                return "price_1U7efaANuQdJ93r74hFVOgdS";
+            }
+            return "price_1U7edTANuQdJ93r7hR9jpBfv";
+        }
         throw new BadDataException("Plan with productType " + productType + " not found");
     }
     /*