@oneuptime/common 10.0.85 → 10.0.88

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -15,6 +15,7 @@ import AnalyticsTableColumn, {
   SkipIndexType,
 } from "../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+import EqualTo from "../../../Types/BaseDatabase/EqualTo";
 import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
@@ -25,7 +26,11 @@ import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
 import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
 import NotEqual from "../../../Types/BaseDatabase/NotEqual";
+import NotContains from "../../../Types/BaseDatabase/NotContains";
+import NotNull from "../../../Types/BaseDatabase/NotNull";
 import Search from "../../../Types/BaseDatabase/Search";
+import StartsWith from "../../../Types/BaseDatabase/StartsWith";
+import EndsWith from "../../../Types/BaseDatabase/EndsWith";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../../Types/Date";
 import BadDataException from "../../../Types/Exception/BadDataException";
@@ -447,33 +452,195 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
         tableColumn.type === TableColumnType.MapStringString &&
         typeof value === "object"
       ) {
-        const mapValue: Record<string, string | Search<string>> =
-          value as Record<string, string | Search<string>>;
+        const mapValue: Record<string, unknown> = value as Record<
+          string,
+          unknown
+        >;
         for (const mapKey in mapValue) {
-          if (mapValue[mapKey] === undefined) {
+          const mapEntry: unknown = mapValue[mapKey];
+          if (mapEntry === undefined || mapEntry === null) {
             continue;
           }
-          if (mapValue[mapKey] instanceof Search) {
+
+          /*
+           * ClickHouse Map columns return the value type's default for
+           * missing keys (empty string for String values), so to express
+           * "is empty" we have to cover both the missing-key and the
+           * empty-string case explicitly.
+           */
+          if (mapEntry instanceof IsNull) {
+            whereStatement.append(
+              SQL`AND ((NOT mapContains(${key}, ${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }})) OR ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] = '')`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof NotNull) {
+            whereStatement.append(
+              SQL`AND mapContains(${key}, ${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}) AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] != ''`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof Search) {
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] ILIKE ${{
+                value: mapEntry as Search<string>,
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof NotContains) {
+            const literalValue: string = `%${(mapEntry.value as string) || ""}%`;
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] NOT ILIKE ${{
+                value: literalValue,
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof StartsWith) {
+            const literalValue: string = `${(mapEntry.value as string) || ""}%`;
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] ILIKE ${{
+                value: literalValue,
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof EndsWith) {
+            const literalValue: string = `%${(mapEntry.value as string) || ""}`;
             whereStatement.append(
               SQL`AND ${key}[${{
                 value: mapKey,
                 type: TableColumnType.Text,
               }}] ILIKE ${{
-                value: mapValue[mapKey] as Search<string>,
+                value: literalValue,
                 type: TableColumnType.Text,
               }}`,
             );
-          } else {
+            continue;
+          }
+
+          if (mapEntry instanceof NotEqual) {
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] != ${{
+                value: String((mapEntry as NotEqual<string>).value ?? ""),
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof EqualTo) {
             whereStatement.append(
               SQL`AND ${key}[${{
                 value: mapKey,
                 type: TableColumnType.Text,
               }}] = ${{
-                value: mapValue[mapKey] as string,
+                value: String((mapEntry as EqualTo<any>).value ?? ""),
                 type: TableColumnType.Text,
               }}`,
             );
+            continue;
           }
+
+          /*
+           * Map values are stored as text; cast to Float64 for numeric
+           * comparisons and skip rows where the cast fails (non-numeric).
+           */
+          if (mapEntry instanceof GreaterThan) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) > ${{
+                value: Number((mapEntry as GreaterThan<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof GreaterThanOrEqual) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) >= ${{
+                value: Number((mapEntry as GreaterThanOrEqual<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof LessThan) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) < ${{
+                value: Number((mapEntry as LessThan<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof LessThanOrEqual) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) <= ${{
+                value: Number((mapEntry as LessThanOrEqual<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          // Bare string/number/boolean — back-compat with existing data.
+          whereStatement.append(
+            SQL`AND ${key}[${{
+              value: mapKey,
+              type: TableColumnType.Text,
+            }}] = ${{
+              value: String(mapEntry),
+              type: TableColumnType.Text,
+            }}`,
+          );
         }
       } else if (
         (tableColumn.type === TableColumnType.JSON ||

package/Tests/Types/Date.test.ts

@@ -250,4 +250,50 @@ describe("class OneUptimeDate", () => {
       expect(result[0]).not.toContain("EST");
     });
   });
+
+  describe("getDateAsFormattedArrayInMultipleTimezones default timezones", () => {
+    test("defaults include UTC, London, New York, LA, Kolkata, Sydney", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-07-15T17:00:00Z"),
+          use12HourFormat: true,
+        });
+      expect(result).toHaveLength(6);
+      expect(result[0]).toContain("UTC");
+    });
+
+    test("summer (DST) event shows EDT and BST in defaults, not EST or GMT", () => {
+      /*
+       * Apr 27 2026 21:30 UTC — both US and UK are in DST. Use word
+       * boundaries so AEST/AEDT (Sydney) doesn't match EST/EDT.
+       */
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-04-27T21:30:00Z"),
+          use12HourFormat: true,
+        });
+      const joined: string = result.join("\n");
+      expect(joined).toMatch(/\bEDT\b/);
+      expect(joined).toMatch(/\bBST\b/);
+      expect(joined).not.toMatch(/\bEST\b/);
+      expect(joined).not.toMatch(/\bGMT\b/);
+    });
+
+    test("winter (no DST) event shows EST and GMT in defaults, not EDT or BST", () => {
+      /*
+       * Jan 15 2026 17:00 UTC — both US and UK are on standard time. Use
+       * word boundaries so AEDT (Sydney) doesn't match EDT.
+       */
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-01-15T17:00:00Z"),
+          use12HourFormat: true,
+        });
+      const joined: string = result.join("\n");
+      expect(joined).toMatch(/\bEST\b/);
+      expect(joined).toMatch(/\bGMT\b/);
+      expect(joined).not.toMatch(/\bEDT\b/);
+      expect(joined).not.toMatch(/\bBST\b/);
+    });
+  });
 });

package/Types/Date.ts

@@ -1385,13 +1385,18 @@ export default class OneUptimeDate {
       formatstring = "MMM DD, YYYY";
     }
 
-    // convert this date into GMT, EST, PST, IST, ACT with moment
     const timezoneDates: Array<string> = [];
 
     if (!timezones || timezones.length === 0) {
+      /*
+       * Use IANA region zones (not fixed-offset zones like "EST") so the
+       * abbreviation reflects DST at the event's date — e.g. EST/EDT for
+       * America/New_York and GMT/BST for Europe/London.
+       */
       timezones = [
         Timezone.UTC,
-        Timezone.EST,
+        Timezone.EuropeLondon,
+        Timezone.AmericaNew_York,
         Timezone.AmericaLos_Angeles,
         Timezone.AsiaKolkata,
         Timezone.AustraliaSydney,
@@ -1416,7 +1421,7 @@ export default class OneUptimeDate {
   public static getDateAsFormattedHTMLInMultipleTimezones(data: {
     date: string | Date;
     onlyShowDate?: boolean;
-    timezones?: Array<Timezone> | undefined; // if this is skipped, then it will show the default timezones in the order of UTC, EST, PST, IST, ACT
+    timezones?: Array<Timezone> | undefined; // if skipped, defaults to UTC, Europe/London, America/New_York, America/Los_Angeles, Asia/Kolkata, Australia/Sydney (DST-aware)
     use12HourFormat?: boolean | undefined;
   }): string {
     const date: string | Date = data.date;
@@ -1435,7 +1440,7 @@ export default class OneUptimeDate {
   public static getDateAsFormattedStringInMultipleTimezones(data: {
     date: string | Date;
     onlyShowDate?: boolean | undefined;
-    timezones?: Array<Timezone> | undefined; // if this is skipped, then it will show the default timezones in the order of UTC, EST, PST, IST, ACT
+    timezones?: Array<Timezone> | undefined; // if skipped, defaults to UTC, Europe/London, America/New_York, America/Los_Angeles, Asia/Kolkata, Australia/Sydney (DST-aware)
     use12HourFormat?: boolean | undefined;
   }): string {
     const date: string | Date = data.date;

package/UI/Components/AutocompleteTextInput/AutocompleteTextInput.tsx

@@ -21,6 +21,9 @@ export interface ComponentProps {
   onBlur?: (() => void) | undefined;
   outerDivClassName?: string | undefined;
   disableSpellCheck?: boolean | undefined;
+  isLoadingSuggestions?: boolean | undefined;
+  loadingMessage?: string | undefined;
+  noSuggestionsMessage?: string | undefined;
 }
 
 const BASE_INPUT_CLASS: string =
@@ -90,7 +93,9 @@ const AutocompleteTextInput: FunctionComponent<ComponentProps> = (
       .slice(0, MAX_SUGGESTIONS);
   }, [inputValue, props.suggestions]);
 
-  const showMenu: boolean = isMenuVisible && suggestions.length > 0;
+  const isLoadingSuggestions: boolean = Boolean(props.isLoadingSuggestions);
+  const showMenu: boolean =
+    isMenuVisible && (suggestions.length > 0 || isLoadingSuggestions);
 
   const getInputClassName: () => string = (): string => {
     let className: string = props.className || BASE_INPUT_CLASS;
@@ -145,7 +150,7 @@ const AutocompleteTextInput: FunctionComponent<ComponentProps> = (
   const handleKeyDown: (
     event: React.KeyboardEvent<HTMLInputElement>,
   ) => void = (event: React.KeyboardEvent<HTMLInputElement>) => {
-    if (!showMenu) {
+    if (!showMenu || suggestions.length === 0) {
       return;
     }
 
@@ -221,26 +226,60 @@ const AutocompleteTextInput: FunctionComponent<ComponentProps> = (
           id={listboxIdRef.current}
           role="listbox"
         >
-          {suggestions.map((suggestion: string, index: number) => {
-            const isActive: boolean = index === highlightedIndex;
-            return (
-              <button
-                key={`${suggestion}-${index}`}
-                type="button"
-                role="option"
-                aria-selected={isActive}
-                className={`flex w-full items-center px-3 py-2 text-left hover:bg-indigo-50 ${isActive ? "bg-indigo-600 text-white hover:bg-indigo-500" : "text-gray-700"}`}
-                onMouseDown={(event: React.MouseEvent<HTMLButtonElement>) => {
-                  event.preventDefault();
-                }}
-                onClick={() => {
-                  handleSuggestionSelect(suggestion);
-                }}
+          {isLoadingSuggestions && (
+            <div className="flex w-full items-center px-3 py-2 text-left text-gray-500">
+              <svg
+                className="animate-spin -ml-0.5 mr-2 h-4 w-4 text-indigo-500"
+                xmlns="http://www.w3.org/2000/svg"
+                fill="none"
+                viewBox="0 0 24 24"
+                aria-hidden="true"
               >
-                {suggestion}
-              </button>
-            );
-          })}
+                <circle
+                  className="opacity-25"
+                  cx="12"
+                  cy="12"
+                  r="10"
+                  stroke="currentColor"
+                  strokeWidth="4"
+                ></circle>
+                <path
+                  className="opacity-75"
+                  fill="currentColor"
+                  d="M4 12a8 8 0 018-8v4a4 4 0 00-4 4H4z"
+                ></path>
+              </svg>
+              <span>{props.loadingMessage || "Loading..."}</span>
+            </div>
+          )}
+          {!isLoadingSuggestions &&
+            suggestions.length === 0 &&
+            props.noSuggestionsMessage && (
+              <div className="flex w-full items-center px-3 py-2 text-left text-gray-500">
+                {props.noSuggestionsMessage}
+              </div>
+            )}
+          {!isLoadingSuggestions &&
+            suggestions.map((suggestion: string, index: number) => {
+              const isActive: boolean = index === highlightedIndex;
+              return (
+                <button
+                  key={`${suggestion}-${index}`}
+                  type="button"
+                  role="option"
+                  aria-selected={isActive}
+                  className={`flex w-full items-center px-3 py-2 text-left hover:bg-indigo-50 ${isActive ? "bg-indigo-600 text-white hover:bg-indigo-500" : "text-gray-700"}`}
+                  onMouseDown={(event: React.MouseEvent<HTMLButtonElement>) => {
+                    event.preventDefault();
+                  }}
+                  onClick={() => {
+                    handleSuggestionSelect(suggestion);
+                  }}
+                >
+                  {suggestion}
+                </button>
+              );
+            })}
         </div>
       )}
     </div>