chore: service code modification

Author: shivani170

src/components/common/hooks/useOnline/service.ts

@@ -1,26 +1,49 @@
 import { Routes } from '@Config/constants'
 
 import { INTERNET_CONNECTIVITY_INTERVAL } from '../constants'
+import { CheckConnectivityParamsType, FetchConnectivityParamsType } from './types'
 
-const fetchWithTimeout = (url: string, options: RequestInit, controller: AbortController): Promise<any> => {
+const fetchWithTimeout = ({
+    url,
+    options,
+    controller,
+    setTimeoutRef,
+    checkConnectivity,
+}: FetchConnectivityParamsType): Promise<any> => {
     const timeoutId = setTimeout(() => controller.abort(), INTERNET_CONNECTIVITY_INTERVAL)
 
-    return fetch(url, { ...options, signal: controller.signal }).finally(() => clearTimeout(timeoutId))
+    return fetch(url, { ...options, signal: controller.signal }).finally(() => {
+        clearTimeout(timeoutId)
+        const nextRef = setTimeout(checkConnectivity, INTERNET_CONNECTIVITY_INTERVAL)
+        setTimeoutRef(nextRef)
+    })
 }
 
-export const getFallbackInternetConnectivity = (controller: AbortController): Promise<any> =>
-    fetchWithTimeout(
-        'https://www.google.com/favicon.ico',
-        {
+export const getFallbackInternetConnectivity = ({
+    controller,
+    setTimeoutRef,
+    checkConnectivity,
+}: CheckConnectivityParamsType): Promise<any> =>
+    fetchWithTimeout({
+        url: 'https://www.google.com/favicon.ico',
+        options: {
             method: 'HEAD',
             mode: 'no-cors',
         },
         controller,
-    )
+        setTimeoutRef,
+        checkConnectivity,
+    })
 
-export const getInternetConnectivity = (controller: AbortController): Promise<any> => {
+export const getInternetConnectivity = ({
+    controller,
+    setTimeoutRef,
+    checkConnectivity,
+}: CheckConnectivityParamsType): Promise<any> => {
     const baseUrl = window._env_?.CENTRAL_API_ENDPOINT ?? 'https://api.devtron.ai'
     const url = `${baseUrl}/${Routes.HEALTH}`
 
-    return fetchWithTimeout(url, {}, controller).then((res) => res.json())
+    return fetchWithTimeout({ url, options: {}, controller, setTimeoutRef, checkConnectivity }).then((res) =>
+        res.json(),
+    )
 }

src/components/common/hooks/useOnline/types.ts

@@ -0,0 +1,10 @@
+export interface FetchConnectivityParamsType {
+    url: string
+    options: RequestInit
+    controller: AbortController
+    setTimeoutRef: (ref: NodeJS.Timeout) => void
+    checkConnectivity: () => void
+}
+
+export interface CheckConnectivityParamsType
+    extends Pick<FetchConnectivityParamsType, 'controller' | 'setTimeoutRef' | 'checkConnectivity'> {}

src/components/common/hooks/useOnline/useOnline.ts

@@ -25,6 +25,13 @@ export const useOnline = ({ onOnline = noop }: { onOnline?: () => void }) => {
         })
     }
 
+    const setTimeoutRef = (ref: NodeJS.Timeout) => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current)
+        }
+        timeoutRef.current = ref
+    }
+
     const checkConnectivity = async () => {
         if (isAirgapped) return
 
@@ -33,20 +40,23 @@ export const useOnline = ({ onOnline = noop }: { onOnline?: () => void }) => {
         abortControllerRef.current = controller
 
         try {
-            await getInternetConnectivity(abortControllerRef.current)
+            await getInternetConnectivity({ controller: abortControllerRef.current, setTimeoutRef, checkConnectivity })
             onConnectivitySuccess()
-
-            timeoutRef.current = setTimeout(checkConnectivity, INTERNET_CONNECTIVITY_INTERVAL)
         } catch (error) {
             if (getIsRequestAborted(error)) return
             const fallbackController = new AbortController()
             abortControllerRef.current = fallbackController
             try {
-                await getFallbackInternetConnectivity(fallbackController)
+                await getFallbackInternetConnectivity({
+                    controller: abortControllerRef.current,
+                    setTimeoutRef,
+                    checkConnectivity,
+                })
                 onConnectivitySuccess()
-            } catch {
-                setOnline(false)
-            } finally {
+            } catch (fallbackError) {
+                if (!getIsRequestAborted(fallbackError)) {
+                    setOnline(false)
+                }
                 timeoutRef.current = setTimeout(checkConnectivity, INTERNET_CONNECTIVITY_INTERVAL)
             }
         }