@oneuptime/common 10.0.69 → 10.0.71

package/Types/BaseDatabase/IncludesAll.ts

@@ -0,0 +1,45 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import JSONFunctions from "../JSONFunctions";
+import ObjectID from "../ObjectID";
+import QueryOperator from "./QueryOperator";
+
+export type IncludesAllType = Array<string> | Array<ObjectID> | Array<number>;
+
+export default class IncludesAll extends QueryOperator<IncludesAllType> {
+  private _values: IncludesAllType = [];
+
+  public get values(): IncludesAllType {
+    return this._values;
+  }
+
+  public set values(v: IncludesAllType) {
+    this._values = v;
+  }
+
+  public constructor(values: IncludesAllType) {
+    super();
+    this.values = values;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.IncludesAll,
+      value: (this as IncludesAll)._values,
+    };
+  }
+
+  public static override fromJSON(json: JSONObject): IncludesAll {
+    if (json["_type"] === ObjectType.IncludesAll) {
+      const valuesArray: Array<string> = [];
+
+      for (const value of (json["value"] as Array<string>) || []) {
+        valuesArray.push(JSONFunctions.deserializeValue(value) as string);
+      }
+
+      return new IncludesAll(valuesArray);
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/IncludesNone.ts

@@ -0,0 +1,45 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import JSONFunctions from "../JSONFunctions";
+import ObjectID from "../ObjectID";
+import QueryOperator from "./QueryOperator";
+
+export type IncludesNoneType = Array<string> | Array<ObjectID> | Array<number>;
+
+export default class IncludesNone extends QueryOperator<IncludesNoneType> {
+  private _values: IncludesNoneType = [];
+
+  public get values(): IncludesNoneType {
+    return this._values;
+  }
+
+  public set values(v: IncludesNoneType) {
+    this._values = v;
+  }
+
+  public constructor(values: IncludesNoneType) {
+    super();
+    this.values = values;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.IncludesNone,
+      value: (this as IncludesNone)._values,
+    };
+  }
+
+  public static override fromJSON(json: JSONObject): IncludesNone {
+    if (json["_type"] === ObjectType.IncludesNone) {
+      const valuesArray: Array<string> = [];
+
+      for (const value of (json["value"] as Array<string>) || []) {
+        valuesArray.push(JSONFunctions.deserializeValue(value) as string);
+      }
+
+      return new IncludesNone(valuesArray);
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/NotContains.ts

@@ -0,0 +1,41 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+export default class NotContains<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.NotContains,
+      value: (this as NotContains<T>).toString(),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): NotContains<T> {
+    if (json["_type"] === ObjectType.NotContains) {
+      return new NotContains<T>((json["value"] as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

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/Email.ts

@@ -75,6 +75,56 @@ export default class Email extends DatabaseProperty {
     return new Email(value);
   }
 
+  public static parseList(value: string | null | undefined): Array<Email> {
+    if (!value) {
+      return [];
+    }
+
+    const seen: Set<string> = new Set<string>();
+    const emails: Array<Email> = [];
+
+    for (const part of value.split(/[,;\s]+/)) {
+      const trimmed: string = part.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const email: Email = new Email(trimmed);
+      const key: string = email.toString();
+      if (!seen.has(key)) {
+        seen.add(key);
+        emails.push(email);
+      }
+    }
+
+    return emails;
+  }
+
+  public static isValidList(value: string | null | undefined): boolean {
+    if (!value) {
+      return true;
+    }
+
+    const parts: Array<string> = value
+      .split(/[,;\s]+/)
+      .map((p: string): string => {
+        return p.trim();
+      })
+      .filter((p: string): boolean => {
+        return p.length > 0;
+      });
+
+    if (parts.length === 0) {
+      return false;
+    }
+
+    for (const part of parts) {
+      if (!Email.isValid(part)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   public static override fromJSON(json: JSONObject): Email {
     if (json["_type"] === ObjectType.Email) {
       return new Email((json["value"] as string) || "");

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/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,226 @@ 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;
+};
+
+type ToDateFunction = (value: unknown) => Date | null;
+
+const toDate: ToDateFunction = (value: unknown): Date | null => {
+  if (!value) {
+    return null;
+  }
+  if (value instanceof Date) {
+    return value;
+  }
+  try {
+    return OneUptimeDate.fromString(value as string);
+  } catch {
+    return null;
+  }
+};
+
+type DetectStateFunction = (rawValue: unknown) => DateState;
+
+const detectState: DetectStateFunction = (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 };
+};
+
+type BuildValueFunction = (state: DateState, isDateTime: boolean) => unknown;
+
+const buildValue: BuildValueFunction = (
+  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);
+    }
+  }, [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"
       />
     );
   }