@oneuptime/common 12.0.1 → 12.0.3

package/Types/Date.ts

@@ -9,6 +9,12 @@ import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 
 export const Moment: typeof moment = moment;
 
+/*
+ * The units a calendar (rather than a fixed-length) interval can be measured in.
+ * See getStartOfCalendarUnit / addRemoveCalendarUnits below.
+ */
+export type CalendarUnit = "hour" | "day" | "week" | "month" | "year";
+
 export default class OneUptimeDate {
   // get date time from unix timestamp
 
@@ -363,6 +369,27 @@ export default class OneUptimeDate {
     ).trim();
   }
 
+  /*
+   * Format an instant with an explicit moment format string, resolved in an
+   * IANA timezone. The formatted-string helpers above each bake in a layout;
+   * this one is for callers that need a specific shape ("MMMM YYYY" for the
+   * month a status page report covers) and know exactly which zone it must be
+   * read in. Falls back to the viewer's / process's zone without one.
+   */
+  public static getDateAsCustomFormattedStringInTimezone(data: {
+    date: Date | string;
+    format: string;
+    timezone?: string | undefined;
+  }): string {
+    const date: Date = this.fromString(data.date);
+
+    if (!data.timezone) {
+      return this.inCurrentTimezone(date).format(data.format);
+    }
+
+    return moment(date).tz(data.timezone).format(data.format);
+  }
+
   /**
    * Reinterpret the wall-clock components of `date` — read in the CURRENT
    * timezone, i.e. the one the pickers render in — as the SAME wall-clock in
@@ -1213,6 +1240,91 @@ export default class OneUptimeDate {
     return moment(date).endOf("day").toDate();
   }
 
+  /*
+   * Calendar arithmetic - "the previous calendar month", "add 3 calendar
+   * months" - as opposed to the fixed-length arithmetic the rest of this class
+   * does. A calendar month is 28-31 days long and a calendar day is 23-25 hours
+   * long across a DST transition, so anything that has to line up with a wall
+   * clock (a status page report that must read "Jul 1 - Jul 31", a schedule that
+   * must keep firing at 09:00 local) cannot be expressed by adding milliseconds.
+   *
+   * Every helper below takes an optional IANA timezone. Without one the
+   * boundaries land in the process's local zone, which on a server is UTC.
+   */
+  private static toMomentCalendarUnit(
+    unit: CalendarUnit,
+    forStartOf: boolean,
+  ): moment.unitOfTime.StartOf & moment.unitOfTime.DurationConstructor {
+    /*
+     * moment's "week" starts on the locale's first day, which differs between
+     * environments and would make a weekly report cover Sun-Sat on one host and
+     * Mon-Sun on another. ISO weeks are always Monday-Sunday, so the boundary is
+     * the same everywhere. Durations have no such ambiguity - a week is 7 days -
+     * and moment has no "isoWeek" duration, so only startOf is remapped.
+     */
+    if (unit === "week" && forStartOf) {
+      return "isoWeek" as moment.unitOfTime.StartOf &
+        moment.unitOfTime.DurationConstructor;
+    }
+
+    return unit as moment.unitOfTime.StartOf &
+      moment.unitOfTime.DurationConstructor;
+  }
+
+  private static inTimezone(
+    date: Date,
+    timezone?: string | undefined,
+  ): moment.Moment {
+    return timezone ? moment.tz(date, timezone) : moment(date);
+  }
+
+  /*
+   * The instant the calendar unit containing `date` began - e.g. the first
+   * millisecond of that month, in `timezone`.
+   */
+  public static getStartOfCalendarUnit(
+    date: Date,
+    unit: CalendarUnit,
+    timezone?: string | undefined,
+  ): Date {
+    return this.inTimezone(this.fromString(date), timezone)
+      .startOf(this.toMomentCalendarUnit(unit, true))
+      .toDate();
+  }
+
+  /*
+   * Move `date` by whole calendar units, keeping the wall clock in `timezone`.
+   * Adding one month to Jan 31 lands on Feb 28/29 (moment clamps), and adding a
+   * day across a DST boundary still lands at the same local time.
+   */
+  public static addRemoveCalendarUnits(
+    date: Date,
+    unit: CalendarUnit,
+    count: number,
+    timezone?: string | undefined,
+  ): Date {
+    return this.inTimezone(this.fromString(date), timezone)
+      .add(count, this.toMomentCalendarUnit(unit, false))
+      .toDate();
+  }
+
+  /*
+   * How many whole calendar units fit between the two instants, measured in
+   * `timezone`. Used to jump a recurrence forward to "now" in one step instead
+   * of looping one interval at a time.
+   */
+  public static getCalendarUnitsBetween(
+    startDate: Date,
+    endDate: Date,
+    unit: CalendarUnit,
+    timezone?: string | undefined,
+  ): number {
+    return this.inTimezone(this.fromString(endDate), timezone).diff(
+      this.inTimezone(this.fromString(startDate), timezone),
+      this.toMomentCalendarUnit(unit, false),
+    );
+  }
+
   public static isBetween(date: Date, startDate: Date, endDate: Date): boolean {
     date = this.fromString(date);
     startDate = this.fromString(startDate);

package/Types/Decimal.ts

@@ -35,14 +35,26 @@ export default class Decimal extends DatabaseProperty {
     return this.value.toString();
   }
 
+  /*
+   * A decimal column is declared `TableColumnType.Number`, so what reaches
+   * the transformer may be a Decimal, a string, or a plain number depending
+   * on how far the request body got through deserialization.
+   *
+   * Both raw forms are handled before the truthiness check, because `0` is a
+   * perfectly good decimal and the old `if (value)` sent it to `null` — on a
+   * NOT NULL column that is a constraint violation for a value the caller
+   * supplied.
+   */
   protected static override toDatabase(
     value: Decimal | FindOperator<Decimal>,
   ): string | null {
-    if (value) {
-      if (typeof value === "string") {
-        value = new Decimal(value);
-      }
+    const rawValue: unknown = value;
+
+    if (typeof rawValue === "string" || typeof rawValue === "number") {
+      return new Decimal(rawValue).toString();
+    }
 
+    if (value) {
       return value.toString();
     }
 

package/Types/Events/Recurring.ts

@@ -1,5 +1,5 @@
 import DatabaseProperty from "../Database/DatabaseProperty";
-import OneUptimeDate from "../Date";
+import OneUptimeDate, { CalendarUnit } from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONArray, JSONObject, ObjectType } from "../JSON";
 import JSONFunctions from "../JSONFunctions";
@@ -109,6 +109,104 @@ export default class Recurring extends DatabaseProperty {
     return nextDate;
   }
 
+  /*
+   * The calendar unit this interval is expressed in, for the date helpers that
+   * do calendar (rather than fixed-millisecond) arithmetic.
+   */
+  public static toCalendarUnit(intervalType: EventInterval): CalendarUnit {
+    switch (intervalType) {
+      case EventInterval.Hour:
+        return "hour";
+      case EventInterval.Day:
+        return "day";
+      case EventInterval.Week:
+        return "week";
+      case EventInterval.Month:
+        return "month";
+      case EventInterval.Year:
+        return "year";
+      default:
+        throw new BadDataException("Invalid Interval Type: " + intervalType);
+    }
+  }
+
+  /**
+   * The first occurrence of `recurring` (anchored at `startDate`) strictly after
+   * `afterDate`, stepping in whole CALENDAR units in `timezone`.
+   *
+   * getNextDate() approximates a month as 30.4375 days and a year as 365.25
+   * days, which is fine for hours/days/weeks but makes a monthly recurrence
+   * walk backwards through the calendar: anchored on 1 Jul it fires on 31 Jul,
+   * then 30 Aug, and eventually skips a month entirely. This steps 1 Jul ->
+   * 1 Aug -> 1 Sep instead, and holds the local time of day across DST.
+   *
+   * A start date already after `afterDate` is returned unchanged - the first
+   * occurrence has not happened yet.
+   */
+  public static getNextDateAfter(data: {
+    startDate: Date;
+    recurring: Recurring;
+    afterDate: Date;
+    timezone?: string | undefined;
+  }): Date {
+    const startDate: Date = OneUptimeDate.fromString(data.startDate);
+    const recurring: Recurring = Recurring.fromJSON(data.recurring);
+    const unit: CalendarUnit = Recurring.toCalendarUnit(recurring.intervalType);
+
+    const intervalCount: number = Math.max(
+      1,
+      Math.floor(recurring.intervalCount.toNumber()),
+    );
+
+    if (startDate.getTime() > data.afterDate.getTime()) {
+      return startDate;
+    }
+
+    /*
+     * Jump most of the way in one step so a status page left disabled for a year
+     * does not loop 365 times, then walk the remainder. The estimate can only be
+     * off by a single interval either way (calendar units are not uniform), so
+     * the two loops below run a handful of times at most.
+     */
+    const elapsedUnits: number = OneUptimeDate.getCalendarUnitsBetween(
+      startDate,
+      data.afterDate,
+      unit,
+      data.timezone,
+    );
+
+    let intervals: number = Math.max(
+      0,
+      Math.floor(elapsedUnits / intervalCount),
+    );
+
+    type OccurrenceFunction = (intervalsToAdd: number) => Date;
+
+    const occurrence: OccurrenceFunction = (intervalsToAdd: number): Date => {
+      return OneUptimeDate.addRemoveCalendarUnits(
+        startDate,
+        unit,
+        intervalsToAdd * intervalCount,
+        data.timezone,
+      );
+    };
+
+    // Overshot - come back until we are at or before the cutoff.
+    while (
+      intervals > 0 &&
+      occurrence(intervals - 1).getTime() > data.afterDate.getTime()
+    ) {
+      intervals--;
+    }
+
+    // Undershot - advance until we are strictly after it.
+    while (occurrence(intervals).getTime() <= data.afterDate.getTime()) {
+      intervals++;
+    }
+
+    return occurrence(intervals);
+  }
+
   private data: RecurringData = Recurring.getDefaultRotationData();
 
   public get intervalType(): EventInterval {

package/Types/Permission.ts

@@ -484,6 +484,12 @@ enum Permission {
   EditStatusPageLabelRule = "EditStatusPageLabelRule",
   ReadStatusPageLabelRule = "ReadStatusPageLabelRule",
 
+  // Status Page Monitor Rule Permissions
+  CreateStatusPageMonitorRule = "CreateStatusPageMonitorRule",
+  DeleteStatusPageMonitorRule = "DeleteStatusPageMonitorRule",
+  EditStatusPageMonitorRule = "EditStatusPageMonitorRule",
+  ReadStatusPageMonitorRule = "ReadStatusPageMonitorRule",
+
   // Host Owner Rule Permissions
   CreateHostOwnerRule = "CreateHostOwnerRule",
   DeleteHostOwnerRule = "DeleteHostOwnerRule",
@@ -11104,6 +11110,48 @@ export class PermissionHelper {
         group: PermissionGroup.StatusPage,
       },
 
+      // Status Page Monitor Rule Permissions
+      {
+        permission: Permission.CreateStatusPageMonitorRule,
+        title: "Create Status Page Monitor Rule",
+        description:
+          "This permission can create Status Page Monitor Rules in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.StatusPage,
+      },
+      {
+        permission: Permission.DeleteStatusPageMonitorRule,
+        title: "Delete Status Page Monitor Rule",
+        description:
+          "This permission can delete Status Page Monitor Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.StatusPage,
+      },
+      {
+        permission: Permission.EditStatusPageMonitorRule,
+        title: "Edit Status Page Monitor Rule",
+        description:
+          "This permission can edit Status Page Monitor Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.StatusPage,
+      },
+      {
+        permission: Permission.ReadStatusPageMonitorRule,
+        title: "Read Status Page Monitor Rule",
+        description:
+          "This permission can read Status Page Monitor Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.StatusPage,
+      },
+
       // Host Owner Rule Permissions
       {
         permission: Permission.CreateHostOwnerRule,

package/Types/Port.ts

@@ -59,17 +59,29 @@ export default class Port extends DatabaseProperty {
     this.port = new PositiveNumber(port);
   }
 
+  /*
+   * A port column is declared `TableColumnType.Number`, so a raw number is
+   * as legitimate an incoming value as a raw string — the SMTP forms send
+   * one or the other depending on how far the value got through
+   * deserialization. Dropping a number on the floor here wrote NULL over a
+   * port the user had just typed, with no error anywhere.
+   */
   public static override toDatabase(
     value: Port | FindOperator<Port>,
   ): number | null {
-    if (typeof value === "string") {
-      value = new Port(value);
+    /*
+     * The declared parameter type stays Port-shaped so this still overrides
+     * DatabaseProperty.toDatabase, but a raw string or number genuinely
+     * arrives here — see the note above — so widen at the check instead.
+     */
+    const rawValue: unknown = value;
+
+    if (typeof rawValue === "string" || typeof rawValue === "number") {
+      value = new Port(rawValue);
     }
 
     if (value instanceof Port) {
       return value.toNumber();
-    } else if (typeof value === "string") {
-      return parseInt(value);
     }
 
     return null;

package/Types/StatusPage/StatusPageReport.ts

@@ -85,6 +85,17 @@ export interface StatusPageReportRow {
 
 export interface StatusPageReport {
   reportDates: string; // start date and end date in string. e.g. "01 July 2021 - 14 July 2021"
+  /*
+   * How a sentence refers to the period this report covers - "the last 30
+   * days", "July 2026", "the week of Jul 27, 2026". `reportDates` is the raw
+   * range; this is the phrase that goes after "your status summary for ...".
+   */
+  reportPeriodName: string;
+  // The two ends of the window on their own, for templates that lay them out.
+  reportStartDate: string;
+  reportEndDate: string;
+  // The IANA zone every date above was resolved in, e.g. "America/New_York".
+  reportTimezone: string;
   totalResources: number;
   totalIncidents: number;
   averageUptimePercent: string;

package/Types/StatusPage/StatusPageReportPeriodType.ts

@@ -0,0 +1,21 @@
+/*
+ * What stretch of time a scheduled status page report covers.
+ *
+ * The report used to only ever cover "the last N days counted back from the
+ * moment the email went out", which can never line up with a calendar month -
+ * a monthly report sent on 1 Aug covered 2 Jul - 1 Aug rather than the July
+ * everyone reading it expects, and consecutive reports silently overlapped or
+ * left gaps whenever the day count did not match the send frequency.
+ */
+enum StatusPageReportPeriodType {
+  // The window ends when the email is sent and runs back `reportDataInDays`.
+  Rolling = "Rolling",
+  /*
+   * The last whole calendar period before the email is sent, sized by the send
+   * frequency: a report sent monthly covers 1 Jul 00:00 - 31 Jul 23:59:59.999
+   * in the status page's report timezone.
+   */
+  PreviousCalendarPeriod = "Previous Calendar Period",
+}
+
+export default StatusPageReportPeriodType;

package/UI/Components/LogsViewer/useLiveLogsRefresh.ts

@@ -0,0 +1,86 @@
+import React, { useEffect, useRef } from "react";
+
+export interface LiveLogsRefreshOptions {
+  /** Whether the user has switched live mode on. */
+  isLive: boolean;
+  /**
+   * Whether the current view can be refreshed in place. Live tailing only
+   * makes sense on the first page sorted newest-first — on page 3, or sorted
+   * by severity, "the newest logs" is not what the viewer is showing.
+   */
+  isEligible: boolean;
+  /** How often to poll while live mode is on. */
+  intervalInMs: number;
+  /** Pull the newest page of logs. */
+  refreshLogs: () => void;
+  /**
+   * Re-run the histogram query. The chart is driven by its own aggregation
+   * request rather than by the rows in the table, so it goes stale unless it
+   * is refreshed on the same beat as the list.
+   */
+  refreshHistogram: () => void;
+}
+
+export type UseLiveLogsRefreshFunction = (
+  options: LiveLogsRefreshOptions,
+) => void;
+
+/**
+ * Drives the polling loop behind the log viewer's live mode.
+ *
+ * Every tick refreshes the log list *and* the histogram together. That
+ * pairing is the point of this hook: the two come from different endpoints,
+ * and refreshing only the list leaves a chart that stops moving while rows
+ * keep arriving underneath it.
+ *
+ * The callbacks are read through refs, so a parent that re-renders (which it
+ * does on every poll, as results land) does not tear down and re-arm the
+ * timer — that would reset the cadence and fire an extra immediate poll each
+ * time. Only the gating flags and the interval restart the loop.
+ */
+const useLiveLogsRefresh: UseLiveLogsRefreshFunction = (
+  options: LiveLogsRefreshOptions,
+): void => {
+  const { isLive, isEligible, intervalInMs } = options;
+
+  const refreshLogsRef: React.MutableRefObject<() => void> = useRef<() => void>(
+    options.refreshLogs,
+  );
+  const refreshHistogramRef: React.MutableRefObject<() => void> = useRef<
+    () => void
+  >(options.refreshHistogram);
+
+  /*
+   * Declared before the polling effect so the refs are already current by the
+   * time that effect (re-)runs — effects fire in declaration order.
+   */
+  useEffect(() => {
+    refreshLogsRef.current = options.refreshLogs;
+    refreshHistogramRef.current = options.refreshHistogram;
+  });
+
+  useEffect(() => {
+    if (!isLive || !isEligible) {
+      return;
+    }
+
+    const poll: () => void = (): void => {
+      refreshLogsRef.current();
+      refreshHistogramRef.current();
+    };
+
+    // Switching live mode on should show fresh data immediately, not one tick later.
+    poll();
+
+    const intervalId: ReturnType<typeof setInterval> = setInterval(
+      poll,
+      intervalInMs,
+    );
+
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [isLive, isEligible, intervalInMs]);
+};
+
+export default useLiveLogsRefresh;

package/UI/Components/LogsViewer/useLogsHistogram.ts

@@ -0,0 +1,113 @@
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { HistogramBucket } from "./types";
+
+export interface LogsHistogramRefreshOptions {
+  /**
+   * A background refresh: no loader, no blanking on failure, and no stacking
+   * if the previous one has not come back yet. This is what live mode uses.
+   */
+  silent?: boolean | undefined;
+}
+
+export interface LogsHistogramState {
+  buckets: Array<HistogramBucket>;
+  isLoading: boolean;
+  refresh: (options?: LogsHistogramRefreshOptions) => Promise<void>;
+}
+
+export type FetchHistogramBucketsFunction = () => Promise<
+  Array<HistogramBucket>
+>;
+
+export type UseLogsHistogramFunction = (
+  fetchBuckets: FetchHistogramBucketsFunction,
+) => LogsHistogramState;
+
+/**
+ * Owns the log histogram's data, loading flag and refresh loop.
+ *
+ * The chart is fed by its own aggregation query rather than by the rows in
+ * the table, so it needs refreshing in its own right — including on every
+ * live-mode tick. A poll is a *silent* refresh, which is what keeps live mode
+ * from looking broken:
+ *
+ * - it does not raise the loading flag, so the chart does not flash a loader
+ *   every few seconds;
+ * - it keeps the buckets already on screen if the request fails, so one bad
+ *   response does not blank the chart;
+ * - it is dropped while an earlier poll is still running, so a slow
+ *   aggregation cannot pile requests up behind it.
+ *
+ * `fetchBuckets` doubles as the query identity: hand over a new callback (a
+ * new time range, filter or scope) and the histogram reloads.
+ */
+const useLogsHistogram: UseLogsHistogramFunction = (
+  fetchBuckets: FetchHistogramBucketsFunction,
+): LogsHistogramState => {
+  const [buckets, setBuckets] = useState<Array<HistogramBucket>>([]);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+
+  const silentRequestInFlight: React.MutableRefObject<boolean> =
+    useRef<boolean>(false);
+
+  /*
+   * The query the viewer is on right now. A request that comes back after the
+   * reader has moved to another time range or filter is dropped rather than
+   * painted over the window they are actually looking at.
+   */
+  const currentQuery: React.MutableRefObject<FetchHistogramBucketsFunction> =
+    useRef<FetchHistogramBucketsFunction>(fetchBuckets);
+
+  useEffect(() => {
+    currentQuery.current = fetchBuckets;
+  }, [fetchBuckets]);
+
+  const refresh: (options?: LogsHistogramRefreshOptions) => Promise<void> =
+    useCallback(
+      async (options: LogsHistogramRefreshOptions = {}): Promise<void> => {
+        const isSilent: boolean = options.silent === true;
+
+        if (isSilent) {
+          if (silentRequestInFlight.current) {
+            return;
+          }
+
+          silentRequestInFlight.current = true;
+        } else {
+          setIsLoading(true);
+        }
+
+        try {
+          const nextBuckets: Array<HistogramBucket> = await fetchBuckets();
+
+          if (currentQuery.current === fetchBuckets) {
+            setBuckets(nextBuckets);
+          }
+        } catch {
+          // The histogram is non-critical; degrade rather than fail the page.
+          if (!isSilent && currentQuery.current === fetchBuckets) {
+            setBuckets([]);
+          }
+        } finally {
+          if (isSilent) {
+            silentRequestInFlight.current = false;
+          } else if (currentQuery.current === fetchBuckets) {
+            setIsLoading(false);
+          }
+        }
+      },
+      [fetchBuckets],
+    );
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  return {
+    buckets: buckets,
+    isLoading: isLoading,
+    refresh: refresh,
+  };
+};
+
+export default useLogsHistogram;

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 { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
 import {
   CustomFieldDropdownOption,
   parseCustomFieldDropdownOptions,
@@ -45,12 +46,7 @@ import React, { ReactElement } from "react";
  * fall-through text branch understands a dotted key.
  */
 
-export interface CustomFieldDefinition {
-  name: string;
-  description?: string | undefined;
-  customFieldType?: CustomFieldType | undefined;
-  dropdownOptions?: string | undefined;
-}
+export type { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
 
 export const CustomFieldsColumnKey: string = "customFields";
 

package/UI/Components/ModelTable/useCustomFieldColumns.ts

@@ -55,18 +55,37 @@ const useCustomFieldColumns: UseCustomFieldColumnsFunction = <
   const [definitions, setDefinitions] = useState<Array<CustomFieldDefinition>>(
     [],
   );
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [error, setError] = useState<string>("");
 
   const projectId: ObjectID | null =
     data.projectId ?? ProjectUtil.getCurrentProjectId();
 
+  /*
+   * Starts true whenever a request is actually going to happen, rather than
+   * false-until-the-effect-runs.
+   *
+   * Columns did not care — they only ever appear — but a caller that has to
+   * distinguish "no custom fields" from "not yet" does. The facet bar is one:
+   * on the first render it must know that a chip restored from a shared link
+   * may still be on its way, or it drops the link's filter before the request
+   * has even been sent.
+   */
+  const [isLoading, setIsLoading] = useState<boolean>(
+    Boolean(data.customFieldsModelType && projectId),
+  );
+  const [error, setError] = useState<string>("");
+
   const projectIdString: string = projectId?.toString() || "";
   const modelName: string = customFieldsModelType?.name || "";
 
   useEffect(() => {
     if (!customFieldsModelType || !projectId) {
       setDefinitions([]);
+      /*
+       * Nothing to wait for. Said explicitly because the initial state is now
+       * "loading" whenever a request is expected, and a model type that goes
+       * away between renders would otherwise leave it stuck there.
+       */
+      setIsLoading(false);
       return;
     }