@oneuptime/common 13.0.7 → 13.0.8

package/UI/Components/Forms/Fields/FormField.tsx

@@ -354,6 +354,13 @@ const FormField: <T extends GenericObject>(
           : (props.field.defaultValue as boolean)) || false;
     }
 
+    const storedInputValue: unknown =
+      props.currentValues?.[props.fieldName as keyof FormValues<T>];
+    const inputInitialValue: unknown =
+      storedInputValue === undefined
+        ? props.field.defaultValue
+        : storedInputValue;
+
     return (
       <div className="sm:col-span-4 mt-0 mb-2" key={props.fieldName}>
         {/*** Do not display label on checkbox because checkbox can display its own label */}
@@ -964,10 +971,9 @@ const FormField: <T extends GenericObject>(
                 props.setFieldTouched(props.fieldName, true);
               }}
               initialValue={
-                props.currentValues &&
-                (props.currentValues as any)[props.fieldName]
-                  ? (props.currentValues as any)[props.fieldName]
-                  : props.field.defaultValue || ""
+                inputInitialValue instanceof Date
+                  ? inputInitialValue
+                  : String(inputInitialValue ?? "")
               }
               placeholder={translatedPlaceholder || ""}
             />

package/UI/Components/Forms/FormSummary.tsx

@@ -209,6 +209,13 @@ const FormSummary: <T extends GenericObject>(
                 description: field.description || "",
                 getElement: (field.getSummaryElement ||
                   defaultSummaryElement) as any,
+                /*
+                 * A dropdown's form value is only the chosen ID. The options
+                 * ModelForm already fetched are what turn it back into a
+                 * name — without them a single select prints nothing and a
+                 * multi select prints raw IDs.
+                 */
+                dropdownOptions: field.dropdownOptions,
                 sideLink: field.sideLink,
                 key: (Object.keys(field.field || {})[0]?.toString() ||
                   "") as keyof T,

package/UI/Components/Forms/Types/Field.ts

@@ -44,6 +44,13 @@ export interface CategoryCheckboxProps {
   options: Array<CategoryCheckboxOption>;
 }
 
+export interface FormFieldCollapsibleSection<TEntity> {
+  id: string;
+  title: string;
+  description?: string | undefined;
+  isConfigured: (values: FormValues<TEntity>) => boolean;
+}
+
 export default interface Field<TEntity> {
   name?: string; // form field name, should be unique in thr form. If not provided, the field will be auto generated.
   title?: string;
@@ -178,4 +185,7 @@ export default interface Field<TEntity> {
    */
   sectionTitle?: string | undefined;
   sectionDescription?: string | ReactElement | undefined;
+
+  // Consecutive visible fields with the same id share one collapsible section.
+  collapsibleSection?: FormFieldCollapsibleSection<TEntity> | undefined;
 }

package/UI/Components/Markdown.tsx/MarkdownViewer.tsx

@@ -79,6 +79,7 @@ SyntaxHighlighter.registerLanguage("php", php);
 SyntaxHighlighter.registerLanguage("graphql", graphql);
 SyntaxHighlighter.registerLanguage("http", http);
 import DOMPurify from "dompurify";
+import SessionAwareImage from "./SessionAwareImage";
 import OneUptimeDate from "../../../Types/Date";
 import { Theme, useTheme } from "../../Utils/Theme";
 import {
@@ -598,7 +599,7 @@ const MarkdownViewer: FunctionComponent<ComponentProps> = (
           ) : null;
         }
         return (
-          <img
+          <SessionAwareImage
             className="max-w-full h-auto rounded-md border border-gray-200 my-3"
             loading="lazy"
             alt={alt}

package/UI/Components/Markdown.tsx/SessionAwareImage.tsx

@@ -0,0 +1,122 @@
+import UserUtil from "../../Utils/User";
+import React, {
+  FunctionComponent,
+  ReactElement,
+  SyntheticEvent,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+} from "react";
+
+/*
+ * Private inline images (pasted into notes, postmortems, runbooks) are served
+ * from this route, and only to a request that carries a session.
+ */
+export const PRIVATE_IMAGE_ROUTE_SEGMENT: string = "/image/access-token/";
+
+export const isPrivateImageUrl: (src: unknown) => boolean = (
+  src: unknown,
+): boolean => {
+  return typeof src === "string" && src.includes(PRIVATE_IMAGE_ROUTE_SEGMENT);
+};
+
+export const withCacheBuster: (src: string, value: string) => string = (
+  src: string,
+  value: string,
+): string => {
+  return `${src}${src.includes("?") ? "&" : "?"}sessionRetry=${encodeURIComponent(value)}`;
+};
+
+export type RefreshSessionFunction = () => Promise<boolean>;
+
+/*
+ * Which session an image may refresh is the app's decision, not this
+ * component's: the same markdown renders on status pages and public
+ * dashboards, where a failed dashboard refresh would log the reader out and
+ * send them to the dashboard's login page - and on a status page served from
+ * the OneUptime host that shares the dashboard's storage, "signed in" in local
+ * storage does not tell the two apart. So nothing is refreshed unless the app
+ * has registered its refresh here (the Dashboard and Admin Dashboard do, at
+ * startup) or the caller passes one.
+ */
+let appRefreshSession: RefreshSessionFunction | null = null;
+
+export const enablePrivateImageSessionRefresh: (
+  refreshSession: RefreshSessionFunction | null,
+) => void = (refreshSession: RefreshSessionFunction | null): void => {
+  appRefreshSession = refreshSession;
+};
+
+export interface ComponentProps
+  extends React.ImgHTMLAttributes<HTMLImageElement> {
+  refreshSession?: RefreshSessionFunction | undefined;
+  isSignedIn?: (() => boolean) | undefined;
+}
+
+/*
+ * An <img> cannot refresh an expired session the way a request through the API
+ * class does: once the access-token cookie lapses, a private image comes back
+ * 404 and stays broken until something else happens to refresh the session.
+ * So on the first failure of a private image, refresh once and load it again -
+ * where the app has opted in (see enablePrivateImageSessionRefresh) and the
+ * user is signed in.
+ */
+const SessionAwareImage: FunctionComponent<ComponentProps> = ({
+  refreshSession,
+  isSignedIn,
+  onError,
+  src,
+  ...imageProps
+}: ComponentProps): ReactElement => {
+  const [currentSrc, setCurrentSrc] = useState<string | undefined>(src);
+  const hasRetriedRef: React.MutableRefObject<boolean> = useRef(false);
+
+  // A new source is a new image, with its own one retry.
+  useEffect(() => {
+    setCurrentSrc(src);
+    hasRetriedRef.current = false;
+  }, [src]);
+
+  const handleError: (event: SyntheticEvent<HTMLImageElement>) => void =
+    useCallback(
+      (event: SyntheticEvent<HTMLImageElement>): void => {
+        const signedIn: boolean = isSignedIn
+          ? isSignedIn()
+          : UserUtil.isLoggedIn();
+
+        const refresh: RefreshSessionFunction | null =
+          refreshSession || appRefreshSession;
+
+        if (
+          !refresh ||
+          hasRetriedRef.current ||
+          !isPrivateImageUrl(src) ||
+          !signedIn
+        ) {
+          onError?.(event);
+          return;
+        }
+
+        hasRetriedRef.current = true;
+
+        void refresh()
+          .then((refreshed: boolean) => {
+            if (refreshed && typeof src === "string") {
+              setCurrentSrc(withCacheBuster(src, Date.now().toString()));
+              return;
+            }
+
+            onError?.(event);
+          })
+          .catch(() => {
+            onError?.(event);
+          });
+      },
+      [src, onError, refreshSession, isSignedIn],
+    );
+
+  return <img {...imageProps} src={currentSrc} onError={handleError} />;
+};
+
+export default SessionAwareImage;

package/UI/Components/ModelTable/BaseModelTable.tsx

@@ -323,6 +323,18 @@ export interface BaseTableProps<
 
   onFilterApplied?: ((isFilterApplied: boolean) => void) | undefined;
 
+  /**
+   * Called with the query the rows are fetched with - the caller's `query`,
+   * the column filters and the search box, merged exactly as the list request
+   * merges them - on mount and whenever that set of matching rows changes.
+   *
+   * For a surface that summarizes the same rows the table lists (a volume
+   * chart above it, say): reading the filters any other way would let the
+   * summary and the list quietly disagree about what "these events" means.
+   * Sort and page are not part of it; they re-order the same matching set.
+   */
+  onQueryChange?: ((query: Query<TBaseModel>) => void) | undefined;
+
   formSummary?: FormSummaryConfig | undefined;
 
   onAdvancedFiltersToggle?:
@@ -2029,6 +2041,27 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
     clearBulkSelectionState();
   }, [effectiveQueryKey]);
 
+  type BuildEffectiveQueryFunction = () => Query<TBaseModel>;
+
+  // The one merge the list request and `onQueryChange` both read.
+  const buildEffectiveQuery: BuildEffectiveQueryFunction =
+    (): Query<TBaseModel> => {
+      return {
+        ...props.query,
+        ...query,
+        ...buildSearchQueryFragment(),
+      };
+    };
+
+  /*
+   * Keyed on effectiveQueryKey rather than on the query object, which is a
+   * fresh literal every render: a caller that stores what it is handed here
+   * re-renders, and must not be handed the same query again for it.
+   */
+  useEffect(() => {
+    props.onQueryChange?.(buildEffectiveQuery());
+  }, [effectiveQueryKey]);
+
   const fetchItems: PromiseVoidFunction = async (): Promise<void> => {
     setError("");
     setIsLoading(true);
@@ -2047,11 +2080,7 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
         modelType: props.modelType as
           | DatabaseBaseModelType
           | AnalyticsBaseModelType,
-        query: {
-          ...props.query,
-          ...query,
-          ...buildSearchQueryFragment(),
-        },
+        query: buildEffectiveQuery(),
         groupBy: {
           ...props.groupBy,
         },

package/UI/Components/ModelTable/TableView.tsx

@@ -6,7 +6,7 @@ import MoreMenuItem from "../MoreMenu/MoreMenuItem";
 import ModelAPI from "../../Utils/ModelAPI/ModelAPI";
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
-import API from "../../../Utils/API";
+import API from "../../Utils/API/API";
 import MoreMenuSection from "../MoreMenu/MoreMenuSection";
 import { ButtonStyleType } from "../Button/Button";
 import IconProp from "../../../Types/Icon/IconProp";

package/UI/Components/TelemetryViewer/components/TelemetryHistogram.tsx

@@ -118,8 +118,15 @@ const TelemetryHistogram: FunctionComponent<TelemetryHistogramProps> = (
   const activeSeries: Array<HistogramSeriesOption> = useMemo(() => {
     const present: Set<string> = new Set<string>();
 
+    /*
+     * A zero-count bucket holds a slot on the time axis (so a quiet stretch
+     * reads as a gap rather than being squeezed out); it is not a sighting
+     * of its series, which draws nothing and must not be legended.
+     */
     for (const bucket of props.buckets) {
-      present.add(bucket.series);
+      if (bucket.count > 0) {
+        present.add(bucket.series);
+      }
     }
 
     return props.series.filter((option: HistogramSeriesOption): boolean => {

package/UI/Components/Tooltip/Tooltip.tsx

@@ -15,6 +15,13 @@ export interface ComponentProps {
   richContent?: ReactElement | undefined;
   // Large collections can wait to create a tooltip until first opened.
   lazy?: boolean | undefined;
+  /*
+   * Rich tooltips are interactive by default, and Tippy mounts an interactive
+   * tooltip inside the trigger's parent - where an overflow-clipped ancestor
+   * (a scrolling grid, say) cuts it off. Pass false for rich content that has
+   * nothing to click: it then mounts on <body> and hides on mouse-out.
+   */
+  interactive?: boolean | undefined;
 }
 
 interface PopupProps extends ComponentProps {
@@ -61,7 +68,7 @@ const TooltipPopup: FunctionComponent<PopupProps> = (
       {...(props.reference
         ? { reference: props.reference, showOnCreate: true }
         : { children: props.children })}
-      interactive={isRich}
+      interactive={props.interactive ?? isRich}
       trigger="mouseenter focus"
       hideOnClick={false}
       maxWidth={isRich ? 380 : 350}

package/UI/Utils/API/API.ts

@@ -22,8 +22,25 @@ import {
 import API, { AuthRetryContext } from "../../../Utils/API";
 import { IDENTITY_URL } from "../../Config";
 
+/*
+ * One in-flight refresh per session, shared by every caller in this tab: the
+ * dashboard's BaseAPI, any subclass that inherits its refresh, and callers of
+ * refreshSession() that are not going through a request at all (raw fetch,
+ * navigations, the realtime socket). Keyed by session name rather than kept on
+ * `this`, because a static field read through `this` gives every subclass its
+ * own slot, and two slots for one session means two refreshes racing with the
+ * same rotating refresh token.
+ */
+const inFlightSessionRefreshes: Map<string, Promise<boolean>> = new Map();
+
 class BaseAPI extends API {
-  private static refreshPromise: Promise<boolean> | null = null;
+  /*
+   * A refresh another tab finished this recently is one this tab can reuse:
+   * tabs share cookies, so its new access token is already ours. Comfortably
+   * longer than a refresh round trip, far shorter than the token lifetime.
+   */
+  public static readonly RECENT_SESSION_REFRESH_WINDOW_IN_MS: number =
+    15 * 1000;
 
   public constructor(protocol: Protocol, hostname: Hostname, route?: Route) {
     super(protocol, hostname, route);
@@ -117,6 +134,14 @@ class BaseAPI extends API {
 
       this.logoutUser();
 
+      /*
+       * Already there: a forced navigation would reload the login page, whose
+       * requests would fail the same way and reload it again.
+       */
+      if (Navigation.getCurrentRoute().toString() === loginRoute.toString()) {
+        return error;
+      }
+
       if (Navigation.getQueryStringByName("token")) {
         Navigation.navigate(loginRoute.addRouteParam("sso", "true"), {
           forceNavigate: true,
@@ -140,14 +165,79 @@ class BaseAPI extends API {
     return error;
   }
 
+  /*
+   * A refresh that got no answer at all (network down, identity unreachable)
+   * rejects here rather than resolving false: the request that asked for it
+   * then fails with that transport error, instead of logging the user out
+   * over a blip.
+   */
   protected static override async tryRefreshAuth(
     _context: AuthRetryContext,
   ): Promise<boolean> {
-    if (!this.refreshPromise) {
-      this.refreshPromise = (async () => {
-        const refreshUrl: URL = URL.fromString(
-          IDENTITY_URL.toString(),
-        ).addRoute("/refresh-token");
+    return await this.refreshSessionOrThrow();
+  }
+
+  /*
+   * Where this client's session is refreshed, or null when it has no session
+   * that can be (a public dashboard, a status page with no id yet).
+   */
+  protected static getRefreshSessionUrl(): URL | null {
+    return URL.fromString(IDENTITY_URL.toString()).addRoute("/refresh-token");
+  }
+
+  // Names the session for the in-tab single flight, the cross-tab lock and the "recently refreshed" marker.
+  protected static getSessionName(): string {
+    return "dashboard";
+  }
+
+  /*
+   * Refresh the session now, and say whether it worked.
+   *
+   * Requests made through this class already do this for themselves when they
+   * come back 401. This is for the paths that cannot: a raw fetch() (binary
+   * responses), a navigation or new tab pointed at an authenticated route, the
+   * realtime socket's handshake. Those call it before (or after) and carry on.
+   *
+   * Concurrent callers share one refresh, in this tab and across tabs. The
+   * server rotates the refresh token on every use, and a token that has
+   * already been rotated no longer matches a session: that refresh gets a 401
+   * and a response that clears every session cookie, including the ones the
+   * winning refresh just set. So two tabs that both notice an expired session
+   * and both refresh would log each other out. The refresh therefore runs
+   * under a cross-tab lock, and a tab that gets the lock just after another
+   * tab refreshed reuses that result instead of spending the stale token.
+   */
+  public static async refreshSession(): Promise<boolean> {
+    try {
+      return await this.refreshSessionOrThrow();
+    } catch {
+      // No answer at all; callers outside a request just carry on.
+      return false;
+    }
+  }
+
+  private static async refreshSessionOrThrow(): Promise<boolean> {
+    const refreshUrl: URL | null = this.getRefreshSessionUrl();
+
+    if (!refreshUrl) {
+      return false;
+    }
+
+    const sessionName: string = this.getSessionName();
+
+    const inFlight: Promise<boolean> | undefined =
+      inFlightSessionRefreshes.get(sessionName);
+
+    if (inFlight) {
+      return await inFlight;
+    }
+
+    const refresh: Promise<boolean> = this.runWithSessionLock(
+      sessionName,
+      async (): Promise<boolean> => {
+        if (this.wasSessionRefreshedRecently(sessionName)) {
+          return true;
+        }
 
         const result: HTTPResponse<JSONObject> | HTTPErrorResponse =
           await super.fetch<JSONObject>({
@@ -156,20 +246,91 @@ class BaseAPI extends API {
             options: {
               skipAuthRefresh: true,
               hasAttemptedAuthRefresh: true,
+              /*
+               * A refresh that fails because the identity service is
+               * restarting is not a dead session, and treating it as one logs
+               * the user out. Retry what a retry can fix; a 401 is final.
+               */
+              retries: 2,
+              exponentialBackoff: true,
+              retryOnlyOnRetryableErrors: true,
             },
           });
 
-        if (result instanceof HTTPResponse && result.isSuccess()) {
-          return true;
+        const refreshed: boolean =
+          result instanceof HTTPResponse && result.isSuccess();
+
+        if (refreshed) {
+          this.markSessionRefreshed(sessionName);
         }
 
+        return refreshed;
+      },
+    ).finally(() => {
+      inFlightSessionRefreshes.delete(sessionName);
+    });
+
+    inFlightSessionRefreshes.set(sessionName, refresh);
+
+    return await refresh;
+  }
+
+  private static getSessionRefreshedAtKey(sessionName: string): string {
+    return `session-refreshed-at:${sessionName}`;
+  }
+
+  private static wasSessionRefreshedRecently(sessionName: string): boolean {
+    try {
+      const refreshedAt: number = Number(
+        LocalStorage.getItem(this.getSessionRefreshedAtKey(sessionName)),
+      );
+
+      if (!refreshedAt) {
         return false;
-      })().finally(() => {
-        this.refreshPromise = null;
-      });
+      }
+
+      const ageInMs: number = Date.now() - refreshedAt;
+
+      return (
+        ageInMs >= 0 && ageInMs < BaseAPI.RECENT_SESSION_REFRESH_WINDOW_IN_MS
+      );
+    } catch {
+      // Storage can be unavailable (privacy modes); then every tab refreshes.
+      return false;
+    }
+  }
+
+  private static markSessionRefreshed(sessionName: string): void {
+    try {
+      LocalStorage.setItem(
+        this.getSessionRefreshedAtKey(sessionName),
+        Date.now().toString(),
+      );
+    } catch {
+      // Best effort, as above.
+    }
+  }
+
+  /*
+   * Web Locks serialise the refresh across every tab of this origin. Where
+   * they are unavailable the refresh simply runs, which is what happened
+   * before this lock existed.
+   */
+  private static async runWithSessionLock(
+    sessionName: string,
+    work: () => Promise<boolean>,
+  ): Promise<boolean> {
+    const locks: LockManager | undefined =
+      typeof navigator !== "undefined" ? navigator.locks : undefined;
+
+    if (!locks || typeof locks.request !== "function") {
+      return await work();
     }
 
-    return await this.refreshPromise;
+    return await locks.request(
+      `oneuptime-session-refresh:${sessionName}`,
+      work,
+    );
   }
 
   protected static getLoginRoute(): Route {

package/UI/Utils/API/RequestOptions.ts

@@ -2,10 +2,21 @@ import URL from "../../../Types/API/URL";
 import type { RequestOptions as CoreRequestOptions } from "../../../Utils/API";
 import Dictionary from "../../../Types/Dictionary";
 import { JSONObject } from "../../../Types/JSON";
+import type BaseAPI from "./API";
 
 export default interface RequestOptions {
   requestHeaders?: Dictionary<string> | undefined;
   overrideRequestUrl?: URL | undefined;
+  /*
+   * The client that sends THIS request instead of the model API's default
+   * (the dashboard client, or a subclass's getApiClient()). Set by callers
+   * that route a shared model request to another app's endpoint - a public
+   * dashboard widget's /public-dashboard-api/resource-list read - so that
+   * endpoint's 401/403 is handled by that app's client (its master-password
+   * page), never by the dashboard's refresh-token + User.logout +
+   * /accounts/login.
+   */
+  apiClient?: typeof BaseAPI | undefined;
   apiRequestOptions?: CoreRequestOptions | undefined;
   /*
    * Extra top-level fields merged into a list request body before the

package/UI/Utils/AnalyticsModelAPI/AnalyticsModelAPI.ts

@@ -28,6 +28,24 @@ export type ListResult<TAnalyticsBaseModel extends AnalyticsBaseModel> =
   BaseListResult<TAnalyticsBaseModel>;
 
 export default class ModelAPI {
+  /**
+   * The API client used for analytics model requests: the authenticated
+   * dashboard client.
+   */
+  protected static getApiClient(): typeof API {
+    return API;
+  }
+
+  /*
+   * The client for ONE request: a client the caller routed this request
+   * through (RequestOptions.apiClient) wins; otherwise this class's client.
+   */
+  protected static getApiClientForRequest(
+    requestOptions?: RequestOptions | undefined,
+  ): typeof API {
+    return requestOptions?.apiClient || this.getApiClient();
+  }
+
   public static async create<
     TAnalyticsBaseModel extends AnalyticsBaseModel,
   >(data: {
@@ -103,7 +121,7 @@ export default class ModelAPI {
           | JSONArray
           | TAnalyticsBaseModel
           | Array<TAnalyticsBaseModel>
-        > = await API.fetch<
+        > = await this.getApiClientForRequest(requestOptions).fetch<
       JSONObject | JSONArray | TAnalyticsBaseModel | Array<TAnalyticsBaseModel>
     >({
       method: HTTPMethod.PUT,
@@ -155,7 +173,9 @@ export default class ModelAPI {
     }
 
     const apiResult: HTTPErrorResponse | HTTPResponse<TAnalyticsBaseModel> =
-      await API.fetch<TAnalyticsBaseModel>({
+      await this.getApiClientForRequest(
+        requestOptions,
+      ).fetch<TAnalyticsBaseModel>({
         method: httpMethod,
         url: apiUrl,
         data: {
@@ -221,7 +241,7 @@ export default class ModelAPI {
     const headers: Dictionary<string> = this.getCommonHeaders(requestOptions);
 
     const result: HTTPResponse<JSONArray> | HTTPErrorResponse =
-      await API.fetch<JSONArray>({
+      await this.getApiClientForRequest(requestOptions).fetch<JSONArray>({
         method: HTTPMethod.POST,
         url: apiUrl,
         data: {
@@ -288,7 +308,7 @@ export default class ModelAPI {
     const headers: Dictionary<string> = this.getCommonHeaders(requestOptions);
 
     const result: HTTPResponse<JSONArray> | HTTPErrorResponse =
-      await API.fetch<JSONArray>({
+      await this.getApiClientForRequest(requestOptions).fetch<JSONArray>({
         method: HTTPMethod.POST,
         url: apiUrl,
         data: {
@@ -355,7 +375,7 @@ export default class ModelAPI {
     const headers: Dictionary<string> = this.getCommonHeaders(requestOptions);
 
     const result: HTTPResponse<JSONObject> | HTTPErrorResponse =
-      await API.fetch<JSONObject>({
+      await this.getApiClientForRequest(requestOptions).fetch<JSONObject>({
         method: HTTPMethod.POST,
         url: apiUrl,
         data: {
@@ -440,7 +460,9 @@ export default class ModelAPI {
     requestOptions?: RequestOptions | undefined,
   ): Promise<TAnalyticsBaseModel | null> {
     const result: HTTPResponse<TAnalyticsBaseModel> | HTTPErrorResponse =
-      await API.fetch<TAnalyticsBaseModel>({
+      await this.getApiClientForRequest(
+        requestOptions,
+      ).fetch<TAnalyticsBaseModel>({
         method: HTTPMethod.POST,
         url: apiUrl,
         data: {
@@ -488,7 +510,9 @@ export default class ModelAPI {
     }
 
     const result: HTTPResponse<TAnalyticsBaseModel> | HTTPErrorResponse =
-      await API.fetch<TAnalyticsBaseModel>({
+      await this.getApiClientForRequest(
+        requestOptions,
+      ).fetch<TAnalyticsBaseModel>({
         method: HTTPMethod.DELETE,
         url: apiUrl,
         headers: this.getCommonHeaders(requestOptions),