@planningcenter/chat-react-native 3.20.1-rc.0 → 3.20.1-rc.1

package/build/hooks/use_async_storage.d.ts

@@ -1,4 +1,4 @@
 type SetValue<TCacheData> = (_itemValue?: TCacheData | null) => Promise<void>;
-export declare function useAsyncStorage<TCacheData>(key: string, initialValue: TCacheData): [TCacheData, SetValue<TCacheData>];
+export declare function useAsyncStorage<TCacheData>(key: string, initialValue: TCacheData, throwOnError?: boolean): [TCacheData, SetValue<TCacheData>];
 export {};
 //# sourceMappingURL=use_async_storage.d.ts.map

package/build/hooks/use_async_storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use_async_storage.d.ts","sourceRoot":"","sources":["../../src/hooks/use_async_storage.ts"],"names":[],"mappings":"AAMA,KAAK,QAAQ,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE7E,wBAAgB,eAAe,CAAC,UAAU,EACxC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,UAAU,GACvB,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAgCpC"}
+{"version":3,"file":"use_async_storage.d.ts","sourceRoot":"","sources":["../../src/hooks/use_async_storage.ts"],"names":[],"mappings":"AAOA,KAAK,QAAQ,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE7E,wBAAgB,eAAe,CAAC,UAAU,EACxC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,UAAU,EACxB,YAAY,GAAE,OAAe,GAC5B,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CA+CpC"}

package/build/hooks/use_async_storage.js

@@ -1,12 +1,14 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { useSuspenseQuery } from '@tanstack/react-query';
+import { noop } from 'lodash';
 import { useCallback } from 'react';
 const cacheKeyGenerator = (key) => [`AsyncStorageResource:${key}`];
-export function useAsyncStorage(key, initialValue) {
+export function useAsyncStorage(key, initialValue, throwOnError = false) {
     const cacheKey = cacheKeyGenerator(key);
     const { data: value, refetch } = useSuspenseQuery({
         queryKey: cacheKey,
-        queryFn: () => AsyncStorage.getItem(key).then(storedValue => {
+        queryFn: () => AsyncStorage.getItem(key)
+            .then(storedValue => {
             if (!storedValue)
                 return initialValue;
             try {
@@ -15,18 +17,31 @@ export function useAsyncStorage(key, initialValue) {
             catch {
                 return storedValue;
             }
+        })
+            .catch(e => {
+            if (!throwOnError)
+                return initialValue;
+            return Promise.reject(e);
         }),
     });
     const setValue = useCallback(itemValue => {
         if (itemValue === null || itemValue === undefined) {
-            return AsyncStorage.removeItem(key).then(() => {
+            return AsyncStorage.removeItem(key)
+                .then(() => {
                 refetch();
-            });
+            })
+                .catch(noop);
         }
-        return AsyncStorage.setItem(key, JSON.stringify(itemValue)).then(() => {
+        return AsyncStorage.setItem(key, JSON.stringify(itemValue))
+            .then(() => {
             refetch();
+        })
+            .catch(e => {
+            if (!throwOnError)
+                return;
+            return Promise.reject(e);
         });
-    }, [key, refetch]);
+    }, [throwOnError, key, refetch]);
     return [value || initialValue, setValue];
 }
 //# sourceMappingURL=use_async_storage.js.map

package/build/hooks/use_async_storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"use_async_storage.js","sourceRoot":"","sources":["../../src/hooks/use_async_storage.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,2CAA2C,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAEnC,MAAM,iBAAiB,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,CAAC,wBAAwB,GAAG,EAAE,CAAC,CAAA;AAI1E,MAAM,UAAU,eAAe,CAC7B,GAAW,EACX,YAAwB;IAExB,MAAM,QAAQ,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAA;IACvC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAAa;QAC5D,QAAQ,EAAE,QAAQ;QAClB,OAAO,EAAE,GAAG,EAAE,CACZ,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAC3C,IAAI,CAAC,WAAW;gBAAE,OAAO,YAAY,CAAA;YAErC,IAAI,CAAC;gBACH,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;YAChC,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,WAAW,CAAA;YACpB,CAAC;QACH,CAAC,CAAC;KACL,CAAC,CAAA;IAEF,MAAM,QAAQ,GAAyB,WAAW,CAChD,SAAS,CAAC,EAAE;QACV,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAClD,OAAO,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC5C,OAAO,EAAE,CAAA;YACX,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YACpE,OAAO,EAAE,CAAA;QACX,CAAC,CAAC,CAAA;IACJ,CAAC,EACD,CAAC,GAAG,EAAE,OAAO,CAAC,CACf,CAAA;IAED,OAAO,CAAC,KAAK,IAAI,YAAY,EAAE,QAAQ,CAAC,CAAA;AAC1C,CAAC","sourcesContent":["import AsyncStorage from '@react-native-async-storage/async-storage'\nimport { useSuspenseQuery } from '@tanstack/react-query'\nimport { useCallback } from 'react'\n\nconst cacheKeyGenerator = (key: string) => [`AsyncStorageResource:${key}`]\n\ntype SetValue<TCacheData> = (_itemValue?: TCacheData | null) => Promise<void>\n\nexport function useAsyncStorage<TCacheData>(\n  key: string,\n  initialValue: TCacheData\n): [TCacheData, SetValue<TCacheData>] {\n  const cacheKey = cacheKeyGenerator(key)\n  const { data: value, refetch } = useSuspenseQuery<TCacheData>({\n    queryKey: cacheKey,\n    queryFn: () =>\n      AsyncStorage.getItem(key).then(storedValue => {\n        if (!storedValue) return initialValue\n\n        try {\n          return JSON.parse(storedValue)\n        } catch {\n          return storedValue\n        }\n      }),\n  })\n\n  const setValue: SetValue<TCacheData> = useCallback(\n    itemValue => {\n      if (itemValue === null || itemValue === undefined) {\n        return AsyncStorage.removeItem(key).then(() => {\n          refetch()\n        })\n      }\n\n      return AsyncStorage.setItem(key, JSON.stringify(itemValue)).then(() => {\n        refetch()\n      })\n    },\n    [key, refetch]\n  )\n\n  return [value || initialValue, setValue]\n}\n"]}
+{"version":3,"file":"use_async_storage.js","sourceRoot":"","sources":["../../src/hooks/use_async_storage.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,2CAA2C,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAEnC,MAAM,iBAAiB,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,CAAC,wBAAwB,GAAG,EAAE,CAAC,CAAA;AAI1E,MAAM,UAAU,eAAe,CAC7B,GAAW,EACX,YAAwB,EACxB,eAAwB,KAAK;IAE7B,MAAM,QAAQ,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAA;IAEvC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,gBAAgB,CAAa;QAC5D,QAAQ,EAAE,QAAQ;QAClB,OAAO,EAAE,GAAG,EAAE,CACZ,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC;aACtB,IAAI,CAAC,WAAW,CAAC,EAAE;YAClB,IAAI,CAAC,WAAW;gBAAE,OAAO,YAAY,CAAA;YAErC,IAAI,CAAC;gBACH,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;YAChC,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,WAAW,CAAA;YACpB,CAAC;QACH,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,CAAC,EAAE;YACT,IAAI,CAAC,YAAY;gBAAE,OAAO,YAAY,CAAA;YAEtC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;QAC1B,CAAC,CAAC;KACP,CAAC,CAAA;IAEF,MAAM,QAAQ,GAAyB,WAAW,CAChD,SAAS,CAAC,EAAE;QACV,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAClD,OAAO,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC;iBAChC,IAAI,CAAC,GAAG,EAAE;gBACT,OAAO,EAAE,CAAA;YACX,CAAC,CAAC;iBACD,KAAK,CAAC,IAAI,CAAC,CAAA;QAChB,CAAC;QAED,OAAO,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;aACxD,IAAI,CAAC,GAAG,EAAE;YACT,OAAO,EAAE,CAAA;QACX,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,CAAC,EAAE;YACT,IAAI,CAAC,YAAY;gBAAE,OAAM;YAEzB,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;QAC1B,CAAC,CAAC,CAAA;IACN,CAAC,EACD,CAAC,YAAY,EAAE,GAAG,EAAE,OAAO,CAAC,CAC7B,CAAA;IAED,OAAO,CAAC,KAAK,IAAI,YAAY,EAAE,QAAQ,CAAC,CAAA;AAC1C,CAAC","sourcesContent":["import AsyncStorage from '@react-native-async-storage/async-storage'\nimport { useSuspenseQuery } from '@tanstack/react-query'\nimport { noop } from 'lodash'\nimport { useCallback } from 'react'\n\nconst cacheKeyGenerator = (key: string) => [`AsyncStorageResource:${key}`]\n\ntype SetValue<TCacheData> = (_itemValue?: TCacheData | null) => Promise<void>\n\nexport function useAsyncStorage<TCacheData>(\n  key: string,\n  initialValue: TCacheData,\n  throwOnError: boolean = false\n): [TCacheData, SetValue<TCacheData>] {\n  const cacheKey = cacheKeyGenerator(key)\n\n  const { data: value, refetch } = useSuspenseQuery<TCacheData>({\n    queryKey: cacheKey,\n    queryFn: () =>\n      AsyncStorage.getItem(key)\n        .then(storedValue => {\n          if (!storedValue) return initialValue\n\n          try {\n            return JSON.parse(storedValue)\n          } catch {\n            return storedValue\n          }\n        })\n        .catch(e => {\n          if (!throwOnError) return initialValue\n\n          return Promise.reject(e)\n        }),\n  })\n\n  const setValue: SetValue<TCacheData> = useCallback(\n    itemValue => {\n      if (itemValue === null || itemValue === undefined) {\n        return AsyncStorage.removeItem(key)\n          .then(() => {\n            refetch()\n          })\n          .catch(noop)\n      }\n\n      return AsyncStorage.setItem(key, JSON.stringify(itemValue))\n        .then(() => {\n          refetch()\n        })\n        .catch(e => {\n          if (!throwOnError) return\n\n          return Promise.reject(e)\n        })\n    },\n    [throwOnError, key, refetch]\n  )\n\n  return [value || initialValue, setValue]\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planningcenter/chat-react-native",
-  "version": "3.20.1-rc.0",
+  "version": "3.20.1-rc.1",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -58,5 +58,5 @@
     "react-native-url-polyfill": "^2.0.0",
     "typescript": "<5.6.0"
   },
-  "gitHead": "f896400d25cd9b75b7fe6ed67fbda8b03eaade70"
+  "gitHead": "e0a908049cd839fc176a02a3addbf94ec4b9a42d"
 }

package/src/__tests__/hooks/use_async_storage.test.tsx

@@ -0,0 +1,313 @@
+import { renderHook, act } from '@testing-library/react-hooks'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import React, { Suspense } from 'react'
+import AsyncStorage from '@react-native-async-storage/async-storage'
+import { useAsyncStorage } from '../../hooks/use_async_storage'
+
+jest.mock('@react-native-async-storage/async-storage')
+jest.useFakeTimers()
+
+afterAll(() => {
+  jest.useRealTimers()
+})
+
+const mockAsyncStorage = AsyncStorage as jest.Mocked<typeof AsyncStorage>
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  })
+
+  return ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>
+      <Suspense fallback={null}>{children}</Suspense>
+    </QueryClientProvider>
+  )
+}
+
+// Helper to wait for Suspense and async operations to resolve
+const waitForQuery = async () => {
+  await act(async () => {
+    await Promise.resolve()
+    await Promise.resolve()
+    await Promise.resolve()
+  })
+}
+
+describe('useAsyncStorage', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockAsyncStorage.getItem.mockResolvedValue(null)
+    mockAsyncStorage.setItem.mockResolvedValue(undefined)
+    mockAsyncStorage.removeItem.mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('initialization', () => {
+    it('returns initial value when storage is empty', async () => {
+      mockAsyncStorage.getItem.mockResolvedValue(null)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial-value'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial-value')
+    })
+
+    it('returns parsed JSON value from storage', async () => {
+      const storedValue = { foo: 'bar', count: 42 }
+      mockAsyncStorage.getItem.mockResolvedValue(JSON.stringify(storedValue))
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', { default: 'value' }), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toEqual(storedValue)
+    })
+
+    it('returns raw string value when JSON parsing fails', async () => {
+      mockAsyncStorage.getItem.mockResolvedValue('not-valid-json{')
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial-value'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('not-valid-json{')
+    })
+
+    it('returns initial value when getItem throws an error', async () => {
+      const error = new Error('Storage error')
+      mockAsyncStorage.getItem.mockRejectedValue(error)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial-value'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial-value')
+    })
+
+    it('returns initial value when getItem throws quota exceeded error', async () => {
+      const quotaError = new Error('database or disk is full (code 13): SQLITE_FULL')
+      mockAsyncStorage.getItem.mockRejectedValue(quotaError)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial-value'), {
+        wrapper: createWrapper(),
+      })
+
+      await act(async () => {
+        await waitForQuery()
+      })
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial-value')
+    })
+  })
+
+  describe('setValue', () => {
+    it('saves value to storage and refetches', async () => {
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial')
+
+      const newValue = 'new-string-value'
+      await act(async () => {
+        await result.current[1](newValue)
+      })
+
+      expect(mockAsyncStorage.setItem).toHaveBeenCalledWith('test-key', JSON.stringify(newValue))
+    })
+
+    it('saves object value to storage', async () => {
+      const { result } = renderHook(() => useAsyncStorage('test-key', { initial: 'value' }), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+
+      const newValue = { initial: 'new-value', data: 'test' }
+      await act(async () => {
+        await result.current[1](newValue)
+      })
+
+      expect(mockAsyncStorage.setItem).toHaveBeenCalledWith('test-key', JSON.stringify(newValue))
+    })
+
+    it('removes item when value is null', async () => {
+      mockAsyncStorage.getItem.mockResolvedValue(JSON.stringify({ data: 'existing' }))
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toEqual({ data: 'existing' })
+
+      await act(async () => {
+        await result.current[1](null)
+      })
+
+      expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith('test-key')
+      expect(mockAsyncStorage.setItem).not.toHaveBeenCalled()
+    })
+
+    it('removes item when value is undefined', async () => {
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial')
+
+      await act(async () => {
+        await result.current[1](undefined)
+      })
+
+      expect(mockAsyncStorage.removeItem).toHaveBeenCalledWith('test-key')
+      expect(mockAsyncStorage.setItem).not.toHaveBeenCalled()
+    })
+
+    it('does not throw error when setItem throws quota exceeded error by default', async () => {
+      const quotaError = new Error('database or disk is full (code 13): SQLITE_FULL')
+      mockAsyncStorage.setItem.mockRejectedValue(quotaError)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial')
+
+      // Should not throw - errors are caught by default
+      let promiseResult: void | undefined
+      await act(async () => {
+        promiseResult = await result.current[1]('new-value')
+      })
+      expect(promiseResult).toBeUndefined()
+    })
+
+    it('propagates error when setItem throws quota exceeded error with throwOnError=true', async () => {
+      const quotaError = new Error('database or disk is full (code 13): SQLITE_FULL')
+      mockAsyncStorage.setItem.mockRejectedValue(quotaError)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial', true), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial')
+
+      await act(async () => {
+        await expect(result.current[1]('new-value')).rejects.toThrow('database or disk is full')
+      })
+    })
+
+    it('does not throw error when setItem throws other errors by default', async () => {
+      const error = new Error('Storage write failed')
+      mockAsyncStorage.setItem.mockRejectedValue(error)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial')
+
+      // Should not throw - errors are caught by default
+      let promiseResult: void | undefined
+      await act(async () => {
+        promiseResult = await result.current[1]('new-value')
+      })
+      expect(promiseResult).toBeUndefined()
+    })
+
+    it('does not throw error when removeItem throws an error by default', async () => {
+      const error = new Error('Remove failed')
+      mockAsyncStorage.removeItem.mockRejectedValue(error)
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', 'initial'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('initial')
+
+      // Should not throw - errors are caught by default (via noop)
+      let promiseResult: void | undefined
+      await act(async () => {
+        promiseResult = await result.current[1](null)
+      })
+      expect(promiseResult).toBeUndefined()
+    })
+  })
+
+  describe('edge cases', () => {
+    it('handles complex nested objects', async () => {
+      const complexValue = {
+        nested: {
+          array: [1, 2, { deep: 'value' }],
+          date: '2024-01-01',
+        },
+      }
+      mockAsyncStorage.getItem.mockResolvedValue(JSON.stringify(complexValue))
+
+      const { result } = renderHook(() => useAsyncStorage('test-key', {}), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toEqual(complexValue)
+    })
+
+    it('uses correct cache key format', async () => {
+      const { result } = renderHook(() => useAsyncStorage('my-unique-key', 'value'), {
+        wrapper: createWrapper(),
+      })
+
+      await waitForQuery()
+
+      expect(result.current).toBeDefined()
+      expect(result.current[0]).toBe('value')
+      expect(mockAsyncStorage.getItem).toHaveBeenCalledWith('my-unique-key')
+    })
+  })
+})

package/src/hooks/use_async_storage.ts

@@ -1,5 +1,6 @@
 import AsyncStorage from '@react-native-async-storage/async-storage'
 import { useSuspenseQuery } from '@tanstack/react-query'
+import { noop } from 'lodash'
 import { useCallback } from 'react'
 
 const cacheKeyGenerator = (key: string) => [`AsyncStorageResource:${key}`]
@@ -8,36 +9,52 @@ type SetValue<TCacheData> = (_itemValue?: TCacheData | null) => Promise<void>
 
 export function useAsyncStorage<TCacheData>(
   key: string,
-  initialValue: TCacheData
+  initialValue: TCacheData,
+  throwOnError: boolean = false
 ): [TCacheData, SetValue<TCacheData>] {
   const cacheKey = cacheKeyGenerator(key)
+
   const { data: value, refetch } = useSuspenseQuery<TCacheData>({
     queryKey: cacheKey,
     queryFn: () =>
-      AsyncStorage.getItem(key).then(storedValue => {
-        if (!storedValue) return initialValue
-
-        try {
-          return JSON.parse(storedValue)
-        } catch {
-          return storedValue
-        }
-      }),
+      AsyncStorage.getItem(key)
+        .then(storedValue => {
+          if (!storedValue) return initialValue
+
+          try {
+            return JSON.parse(storedValue)
+          } catch {
+            return storedValue
+          }
+        })
+        .catch(e => {
+          if (!throwOnError) return initialValue
+
+          return Promise.reject(e)
+        }),
   })
 
   const setValue: SetValue<TCacheData> = useCallback(
     itemValue => {
       if (itemValue === null || itemValue === undefined) {
-        return AsyncStorage.removeItem(key).then(() => {
+        return AsyncStorage.removeItem(key)
+          .then(() => {
+            refetch()
+          })
+          .catch(noop)
+      }
+
+      return AsyncStorage.setItem(key, JSON.stringify(itemValue))
+        .then(() => {
           refetch()
         })
-      }
+        .catch(e => {
+          if (!throwOnError) return
 
-      return AsyncStorage.setItem(key, JSON.stringify(itemValue)).then(() => {
-        refetch()
-      })
+          return Promise.reject(e)
+        })
     },
-    [key, refetch]
+    [throwOnError, key, refetch]
   )
 
   return [value || initialValue, setValue]