@oneuptime/common 10.0.68 → 10.0.70

package/Types/BaseDatabase/StartsWith.ts

@@ -0,0 +1,41 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+export default class StartsWith<T extends string> extends QueryOperator<T> {
+  private _value!: T;
+
+  public get value(): T {
+    return this._value;
+  }
+
+  public set value(v: T) {
+    this._value = v;
+  }
+
+  public constructor(value: T) {
+    super();
+    this.value = value;
+  }
+
+  public override toString(): T {
+    return this.value;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.StartsWith,
+      value: (this as StartsWith<T>).toString(),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): StartsWith<T> {
+    if (json["_type"] === ObjectType.StartsWith) {
+      return new StartsWith<T>((json["value"] as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/IsolatedVM/ReturnResult.ts

@@ -4,4 +4,10 @@ export default interface ReturnResult {
   returnValue: any;
   logMessages: string[];
   capturedMetrics: CapturedMetric[];
+  /**
+   * Populated when user-supplied code threw (or timed out). The runner still
+   * returns collected side-channel data (logs, metrics, and any host-realm
+   * context objects the caller passed in) so partial state survives the throw.
+   */
+  scriptError?: Error | undefined;
 }

package/Types/JSON.ts

@@ -7,6 +7,11 @@ import GreaterThan from "./BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
 import InBetween from "./BaseDatabase/InBetween";
 import Includes from "./BaseDatabase/Includes";
+import IncludesAll from "./BaseDatabase/IncludesAll";
+import IncludesNone from "./BaseDatabase/IncludesNone";
+import StartsWith from "./BaseDatabase/StartsWith";
+import EndsWith from "./BaseDatabase/EndsWith";
+import NotContains from "./BaseDatabase/NotContains";
 import LessThan from "./BaseDatabase/LessThan";
 import LessThanOrEqual from "./BaseDatabase/LessThanOrEqual";
 import NotEqual from "./BaseDatabase/NotEqual";
@@ -71,6 +76,11 @@ export enum ObjectType {
   NotNull = "NotNull",
   IsNull = "IsNull",
   Includes = "Includes",
+  IncludesAll = "IncludesAll",
+  IncludesNone = "IncludesNone",
+  StartsWith = "StartsWith",
+  EndsWith = "EndsWith",
+  NotContains = "NotContains",
   DashboardComponent = "DashboardComponent",
   DashboardViewConfig = "DashboardViewConfig",
 }
@@ -157,6 +167,16 @@ export type JSONValue =
   | Array<StartAndEndTime>
   | Includes
   | Array<Includes>
+  | IncludesAll
+  | Array<IncludesAll>
+  | IncludesNone
+  | Array<IncludesNone>
+  | StartsWith<string>
+  | Array<StartsWith<string>>
+  | EndsWith<string>
+  | Array<EndsWith<string>>
+  | NotContains<string>
+  | Array<NotContains<string>>
   | DashboardViewConfig;
 
 export interface JSONObject {

package/Types/Kubernetes/KubernetesInventoryExtractor.ts

@@ -79,6 +79,12 @@ export interface ParsedKubernetesResource {
   annotations: JSONObject | null;
   ownerReferences: JSONObject | null;
   spec: JSONObject | null;
+  /*
+   * For Pod kinds: length of spec.containers at parse time. Lets the
+   * overview summary SUM() a plain int column instead of scanning
+   * every pod's JSONB spec on every page load.
+   */
+  containerCount: number | null;
   status: JSONObject | null;
   lastSeenAt: Date;
   resourceCreationTimestamp: Date | null;
@@ -255,13 +261,20 @@ export function extractInventoryResource(data: {
     return null;
   }
 
-  // Pod-specific hot column
+  // Pod-specific hot columns
   let phase: string | null = null;
+  let containerCount: number | null = null;
   if (kind === "Pod") {
     const podStatus: KubernetesPodObject["status"] = (
       parsed as KubernetesPodObject
     ).status;
     phase = podStatus?.phase || null;
+    const podSpec: KubernetesPodObject["spec"] | undefined = (
+      parsed as KubernetesPodObject
+    ).spec;
+    containerCount = Array.isArray(podSpec?.containers)
+      ? podSpec.containers.length
+      : 0;
   }
 
   // Node-specific hot columns
@@ -318,6 +331,7 @@ export function extractInventoryResource(data: {
           } as unknown as JSONObject)
         : null,
     spec: (anyParsed.spec as JSONObject | undefined) || null,
+    containerCount,
     status: (anyParsed.status as JSONObject | undefined) || null,
     lastSeenAt: data.lastSeenAt,
     resourceCreationTimestamp: parseCreationTimestamp(

package/Types/SerializableObjectDictionary.ts

@@ -7,6 +7,11 @@ import GreaterThan from "./BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
 import InBetween from "./BaseDatabase/InBetween";
 import Includes from "./BaseDatabase/Includes";
+import IncludesAll from "./BaseDatabase/IncludesAll";
+import IncludesNone from "./BaseDatabase/IncludesNone";
+import StartsWith from "./BaseDatabase/StartsWith";
+import EndsWith from "./BaseDatabase/EndsWith";
+import NotContains from "./BaseDatabase/NotContains";
 import IsNull from "./BaseDatabase/IsNull";
 import LessThan from "./BaseDatabase/LessThan";
 import LessThanOrEqual from "./BaseDatabase/LessThanOrEqual";
@@ -65,6 +70,11 @@ const SerializableObjectDictionary: Dictionary<any> = {
   [ObjectType.HashedString]: HashedString,
   [ObjectType.InBetween]: InBetween,
   [ObjectType.Includes]: Includes,
+  [ObjectType.IncludesAll]: IncludesAll,
+  [ObjectType.IncludesNone]: IncludesNone,
+  [ObjectType.StartsWith]: StartsWith,
+  [ObjectType.EndsWith]: EndsWith,
+  [ObjectType.NotContains]: NotContains,
   [ObjectType.NotNull]: NotNull,
   [ObjectType.IsNull]: IsNull,
   [ObjectType.Recurring]: Recurring,

package/UI/Components/Filters/BooleanFilter.tsx

@@ -50,6 +50,7 @@ const BooleanFilter: BooleanFilterFunction = <T extends GenericObject>(
           }
         }}
         placeholder={`Filter by ${filter.title}`}
+        className="relative rounded-md w-full overflow-visible"
       />
     );
   }

package/UI/Components/Filters/DateFilter.tsx

@@ -1,11 +1,18 @@
-import { FindWhereProperty } from "../../../Types/BaseDatabase/Query";
-import StartAndEndDate, { StartAndEndDateType } from "../Date/StartAndEndDate";
+import Input, { InputType } from "../Input/Input";
 import FieldType from "../Types/FieldType";
 import Filter from "./Types/Filter";
 import FilterData from "./Types/FilterData";
+import FilterOperator from "./Types/FilterOperator";
+import OperatorSelector from "./OperatorSelector";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
+import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
+import LessThan from "../../../Types/BaseDatabase/LessThan";
+import EqualTo from "../../../Types/BaseDatabase/EqualTo";
+import IsNull from "../../../Types/BaseDatabase/IsNull";
+import NotNull from "../../../Types/BaseDatabase/NotNull";
+import OneUptimeDate from "../../../Types/Date";
 import GenericObject from "../../../Types/GenericObject";
-import React, { ReactElement } from "react";
+import React, { ReactElement, useEffect, useState } from "react";
 
 export interface ComponentProps<T extends GenericObject> {
   filter: Filter<T>;
@@ -17,38 +24,218 @@ type DateFilterFunction = <T extends GenericObject>(
   props: ComponentProps<T>,
 ) => ReactElement;
 
+const DATE_OPERATORS: Array<FilterOperator> = [
+  FilterOperator.Is,
+  FilterOperator.Before,
+  FilterOperator.After,
+  FilterOperator.Between,
+  FilterOperator.IsEmpty,
+  FilterOperator.IsNotEmpty,
+];
+
+type DateState = {
+  operator: FilterOperator;
+  start: Date | null;
+  end: Date | null;
+};
+
+const toDate = (value: unknown): Date | null => {
+  if (!value) {
+    return null;
+  }
+  if (value instanceof Date) {
+    return value;
+  }
+  try {
+    return OneUptimeDate.fromString(value as string);
+  } catch {
+    return null;
+  }
+};
+
+const detectState = (rawValue: unknown): DateState => {
+  if (rawValue instanceof InBetween) {
+    const start: Date | null = toDate(rawValue.startValue as unknown);
+    const end: Date | null = toDate(rawValue.endValue as unknown);
+
+    // If start/end match the bounds of a single day, treat as "Is".
+    if (start && end) {
+      const startOfDay: Date = OneUptimeDate.getStartOfDay(start);
+      const endOfDay: Date = OneUptimeDate.getEndOfDay(start);
+      if (
+        start.getTime() === startOfDay.getTime() &&
+        end.getTime() === endOfDay.getTime()
+      ) {
+        return { operator: FilterOperator.Is, start, end: null };
+      }
+    }
+
+    return { operator: FilterOperator.Between, start, end };
+  }
+  if (rawValue instanceof GreaterThan) {
+    return {
+      operator: FilterOperator.After,
+      start: toDate(rawValue.value as unknown),
+      end: null,
+    };
+  }
+  if (rawValue instanceof LessThan) {
+    return {
+      operator: FilterOperator.Before,
+      start: toDate(rawValue.value as unknown),
+      end: null,
+    };
+  }
+  if (rawValue instanceof EqualTo) {
+    return {
+      operator: FilterOperator.Is,
+      start: toDate(rawValue.value as unknown),
+      end: null,
+    };
+  }
+  if (rawValue instanceof IsNull) {
+    return { operator: FilterOperator.IsEmpty, start: null, end: null };
+  }
+  if (rawValue instanceof NotNull) {
+    return { operator: FilterOperator.IsNotEmpty, start: null, end: null };
+  }
+  return { operator: FilterOperator.Is, start: null, end: null };
+};
+
+const buildValue = (state: DateState, isDateTime: boolean): unknown => {
+  switch (state.operator) {
+    case FilterOperator.Is: {
+      if (!state.start) {
+        return undefined;
+      }
+      if (isDateTime) {
+        return new EqualTo(state.start as any);
+      }
+      return new InBetween(
+        OneUptimeDate.getStartOfDay(state.start) as any,
+        OneUptimeDate.getEndOfDay(state.start) as any,
+      );
+    }
+    case FilterOperator.Before:
+      return state.start ? new LessThan(state.start) : undefined;
+    case FilterOperator.After:
+      return state.start ? new GreaterThan(state.start) : undefined;
+    case FilterOperator.Between: {
+      if (!state.start || !state.end) {
+        return undefined;
+      }
+      return new InBetween(
+        (isDateTime
+          ? state.start
+          : OneUptimeDate.getStartOfDay(state.start)) as any,
+        (isDateTime
+          ? state.end
+          : OneUptimeDate.getEndOfDay(state.end)) as any,
+      );
+    }
+    case FilterOperator.IsEmpty:
+      return new IsNull();
+    case FilterOperator.IsNotEmpty:
+      return new NotNull();
+    default:
+      return undefined;
+  }
+};
+
 const DateFilter: DateFilterFunction = <T extends GenericObject>(
   props: ComponentProps<T>,
 ): ReactElement => {
   const filter: Filter<T> = props.filter;
-  const filterData: FilterData<T> = { ...props.filterData };
 
   if (filter.type !== FieldType.Date && filter.type !== FieldType.DateTime) {
     return <></>;
   }
 
+  const isDateTime: boolean = filter.type === FieldType.DateTime;
+  const detected: DateState = detectState(props.filterData[filter.key]);
+
+  const [localOperator, setLocalOperator] = useState<FilterOperator>(
+    detected.operator,
+  );
+
+  useEffect(() => {
+    const raw: unknown = props.filterData[filter.key];
+    if (raw !== undefined && raw !== null) {
+      setLocalOperator(detected.operator);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [props.filterData[filter.key]]);
+
+  const state: DateState = { ...detected, operator: localOperator };
+
+  const valuelessOperator: boolean =
+    state.operator === FilterOperator.IsEmpty ||
+    state.operator === FilterOperator.IsNotEmpty;
+  const isBetween: boolean = state.operator === FilterOperator.Between;
+
+  type ApplyFunction = (nextState: DateState) => void;
+
+  const apply: ApplyFunction = (nextState: DateState): void => {
+    if (!filter.key) {
+      return;
+    }
+    setLocalOperator(nextState.operator);
+    const next: FilterData<T> = { ...props.filterData };
+    const built: unknown = buildValue(nextState, isDateTime);
+    if (built === undefined) {
+      delete next[filter.key];
+    } else {
+      next[filter.key] = built as any;
+    }
+    props.onFilterChanged?.(next);
+  };
+
+  const inputType: InputType = isDateTime
+    ? InputType.DATETIME_LOCAL
+    : InputType.DATE;
+
   return (
-    <StartAndEndDate
-      value={filterData[filter.key] as InBetween<Date>}
-      onValueChanged={(inBetween: InBetween<Date> | null) => {
-        filterData[filter.key] = inBetween as FindWhereProperty<
-          NonNullable<T[keyof T]>
-        >;
-
-        if (!filterData[filter.key]) {
-          delete filterData[filter.key];
-        }
-
-        if (props.onFilterChanged) {
-          props.onFilterChanged(filterData);
-        }
-      }}
-      type={
-        filter.type === FieldType.DateTime
-          ? StartAndEndDateType.DateTime
-          : StartAndEndDateType.Date
-      }
-    />
+    <div className="flex gap-2 items-start">
+      <OperatorSelector
+        value={state.operator}
+        options={DATE_OPERATORS}
+        onChange={(nextOperator: FilterOperator) => {
+          apply({ ...state, operator: nextOperator });
+        }}
+      />
+      {!valuelessOperator && (
+        <div className={isBetween ? "flex-1 flex gap-2 min-w-0" : "flex-1 min-w-0"}>
+          <div className="flex-1 min-w-0">
+            <Input
+              key={`${filter.key as string}-start-${state.operator}`}
+              onChange={(changed: string | Date) => {
+                const parsed: Date | null = toDate(changed);
+                apply({ ...state, start: parsed });
+              }}
+              value={state.start || ""}
+              placeholder={isBetween ? "From" : `Filter by ${filter.title}`}
+              type={inputType}
+              outerDivClassName="relative rounded-md w-full"
+            />
+          </div>
+          {isBetween && (
+            <div className="flex-1 min-w-0">
+              <Input
+                key={`${filter.key as string}-end-${state.operator}`}
+                onChange={(changed: string | Date) => {
+                  const parsed: Date | null = toDate(changed);
+                  apply({ ...state, end: parsed });
+                }}
+                value={state.end || ""}
+                placeholder="To"
+                type={inputType}
+                outerDivClassName="relative rounded-md w-full"
+              />
+            </div>
+          )}
+        </div>
+      )}
+    </div>
   );
 };
 

package/UI/Components/Filters/DropdownFilter.tsx

@@ -61,6 +61,7 @@ const DropdownFilter: DropdownFilterFunction = <T extends GenericObject>(
         value={dropdownValues}
         isMultiSelect={props.isMultiSelect || false}
         placeholder={`Filter by ${filter.title}`}
+        className="relative rounded-md w-full overflow-visible"
       />
     );
   }