stream-chat-react-native-core 5.44.2-beta.1 → 6.0.0-beta.1

package/src/components/Chat/Chat.tsx

@@ -24,11 +24,10 @@ import { useStreami18n } from '../../hooks/useStreami18n';
 import init from '../../init';
 
 import { SDK } from '../../native';
-import { QuickSqliteClient } from '../../store/QuickSqliteClient';
+import { SqliteClient } from '../../store/SqliteClient';
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { DBSyncManager } from '../../utils/DBSyncManager';
 import type { Streami18n } from '../../utils/i18n/Streami18n';
-import { StreamChatRN } from '../../utils/StreamChatRN';
 import { version } from '../../version.json';
 
 init();
@@ -36,12 +35,7 @@ init();
 export type ChatProps<
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 > = Pick<ChatContextValue<StreamChatGenerics>, 'client'> &
-  Partial<
-    Pick<
-      ChatContextValue<StreamChatGenerics>,
-      'ImageComponent' | 'resizableCDNHosts' | 'isMessageAIGenerated'
-    >
-  > & {
+  Partial<Pick<ChatContextValue<StreamChatGenerics>, 'ImageComponent' | 'isMessageAIGenerated'>> & {
     /**
      * When false, ws connection won't be disconnection upon backgrounding the app.
      * To receive push notifications, its necessary that user doesn't have active
@@ -156,7 +150,6 @@ const ChatWithContext = <
     ImageComponent = Image,
     isMessageAIGenerated,
     LoadingIndicator = null,
-    resizableCDNHosts = ['.stream-io-cdn.com'],
     style,
   } = props;
 
@@ -178,6 +171,7 @@ const ChatWithContext = <
     userID?: string;
   }>({
     initialised: false,
+    userID: client.userID,
   });
 
   /**
@@ -191,9 +185,6 @@ const ChatWithContext = <
 
   const userID = client.userID;
 
-  // Set the `resizableCDNHosts` as per the prop.
-  StreamChatRN.setConfig({ resizableCDNHosts });
-
   useEffect(() => {
     if (client) {
       client.setUserAgent(`${SDK}-${Platform.OS}-${version}`);
@@ -216,15 +207,30 @@ const ChatWithContext = <
   const setActiveChannel = (newChannel?: Channel<StreamChatGenerics>) => setChannel(newChannel);
 
   useEffect(() => {
-    if (userID && enableOfflineSupport) {
+    if (!(userID && enableOfflineSupport)) return;
+
+    const initializeDatabase = () => {
       // This acts as a lock for some very rare occurrences of concurrency
       // issues we've encountered before with the QuickSqliteClient being
       // uninitialized before it's being invoked.
       setInitialisedDatabaseConfig({ initialised: false, userID });
-      QuickSqliteClient.initializeDatabase();
-      setInitialisedDatabaseConfig({ initialised: true, userID });
-      DBSyncManager.init(client as unknown as StreamChat);
-    }
+      SqliteClient.initializeDatabase()
+        .then(async () => {
+          setInitialisedDatabaseConfig({ initialised: true, userID });
+          await DBSyncManager.init(client as unknown as StreamChat);
+        })
+        .catch((error) => {
+          console.log('Error Initializing DB:', error);
+        });
+    };
+
+    initializeDatabase();
+
+    return () => {
+      if (userID && enableOfflineSupport) {
+        SqliteClient.closeDB();
+      }
+    };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [userID, enableOfflineSupport]);
 
@@ -259,7 +265,6 @@ const ChatWithContext = <
     isMessageAIGenerated,
     isOnline,
     mutedUsers,
-    resizableCDNHosts,
     setActiveChannel,
   });
 

package/src/components/Chat/__tests__/Chat.test.js

@@ -1,9 +1,10 @@
 import React from 'react';
 import { View } from 'react-native';
 
+import NetInfo from '@react-native-community/netinfo';
+
 import { act, cleanup, render, waitFor } from '@testing-library/react-native';
 
-import { setNetInfoFetchMock } from '../../../../jest-setup';
 import { useChatContext } from '../../../contexts/chatContext/ChatContext';
 
 import { useTranslationContext } from '../../../contexts/translationContext/TranslationContext';
@@ -43,8 +44,6 @@ describe('Chat', () => {
 
   it('listens and updates state on a connection changed event', async () => {
     let context;
-    const netInfoFetch = jest.fn();
-    setNetInfoFetchMock(netInfoFetch);
 
     render(
       <Chat client={chatClient}>
@@ -56,7 +55,7 @@ describe('Chat', () => {
       </Chat>,
     );
 
-    await waitFor(() => expect(netInfoFetch).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(NetInfo.fetch).toHaveBeenCalledTimes(1));
 
     const { connectionRecovering } = context;
     act(() => dispatchConnectionChangedEvent(chatClient, false));
@@ -83,215 +82,237 @@ describe('Chat', () => {
 
     await waitFor(() => expect(context.connectionRecovering).toStrictEqual(false));
   });
+});
 
-  describe('ChatContext', () => {
-    it('exposes the chat context', async () => {
-      let context;
-
-      render(
-        <Chat client={chatClient}>
-          <ChatContextConsumer
-            fn={(ctx) => {
-              context = ctx;
-            }}
-          ></ChatContextConsumer>
-        </Chat>,
-      );
+describe('ChatContext', () => {
+  afterEach(cleanup);
+  const chatClient = getTestClient();
+  it('exposes the chat context', async () => {
+    let context;
 
-      await waitFor(() => {
-        expect(context).toBeInstanceOf(Object);
-        expect(context.channel).toBeUndefined();
-        expect(context.client).toBe(chatClient);
-        expect(context.connectionRecovering).toBeFalsy();
-        expect(context.setActiveChannel).toBeInstanceOf(Function);
-      });
+    render(
+      <Chat client={chatClient}>
+        <ChatContextConsumer
+          fn={(ctx) => {
+            context = ctx;
+          }}
+        ></ChatContextConsumer>
+      </Chat>,
+    );
+
+    await waitFor(() => {
+      expect(context).toBeInstanceOf(Object);
+      expect(context.channel).toBeUndefined();
+      expect(context.client).toBe(chatClient);
+      expect(context.connectionRecovering).toBeFalsy();
+      expect(context.setActiveChannel).toBeInstanceOf(Function);
     });
+  });
 
-    it('calls setActiveChannel to set a new channel in context', async () => {
-      let context;
-
-      render(
-        <Chat client={chatClient}>
-          <ChatContextConsumer
-            fn={(ctx) => {
-              context = ctx;
-            }}
-          ></ChatContextConsumer>
-        </Chat>,
-      );
+  it('calls setActiveChannel to set a new channel in context', async () => {
+    let context;
 
-      const channel = { cid: 'cid', id: 'cid', query: jest.fn() };
+    render(
+      <Chat client={chatClient}>
+        <ChatContextConsumer
+          fn={(ctx) => {
+            context = ctx;
+          }}
+        ></ChatContextConsumer>
+      </Chat>,
+    );
+
+    const channel = { cid: 'cid', id: 'cid', query: jest.fn() };
+
+    await waitFor(() => expect(context.channel).toBeUndefined());
+    act(() => context.setActiveChannel(channel));
+
+    await waitFor(() => expect(context.channel).toStrictEqual(channel));
+  });
+});
+
+describe('TranslationContext', () => {
+  beforeEach(() => {
+    jest.spyOn(DBSyncManager, 'init');
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    cleanup();
+  });
 
-      await waitFor(() => expect(context.channel).toBeUndefined());
-      act(() => context.setActiveChannel(channel));
+  const chatClient = getTestClient();
+  it('exposes the translation context', async () => {
+    let context;
 
-      await waitFor(() => expect(context.channel).toStrictEqual(channel));
+    render(
+      <Chat client={chatClient}>
+        <TranslationContextConsumer
+          fn={(ctx) => {
+            context = ctx;
+          }}
+        ></TranslationContextConsumer>
+      </Chat>,
+    );
+
+    await waitFor(() => {
+      expect(context).toBeInstanceOf(Object);
+      expect(context.t).toBeInstanceOf(Function);
+      expect(context.tDateTimeParser).toBeInstanceOf(Function);
     });
   });
 
-  describe('TranslationContext', () => {
-    it('exposes the translation context', async () => {
-      let context;
-
-      render(
-        <Chat client={chatClient}>
-          <TranslationContextConsumer
-            fn={(ctx) => {
-              context = ctx;
-            }}
-          ></TranslationContextConsumer>
-        </Chat>,
-      );
+  it('uses the i18nInstance provided in props', async () => {
+    let context;
+    const i18nInstance = new Streami18n();
+    const { t, tDateTimeParser } = await i18nInstance.getTranslators();
 
-      await waitFor(() => {
-        expect(context).toBeInstanceOf(Object);
-        expect(context.t).toBeInstanceOf(Function);
-        expect(context.tDateTimeParser).toBeInstanceOf(Function);
-      });
+    i18nInstance.t = () => 't';
+    i18nInstance.tDateTimeParser = () => 'tDateTimeParser';
+
+    render(
+      <Chat client={chatClient} i18nInstance={i18nInstance}>
+        <TranslationContextConsumer
+          fn={(ctx) => {
+            context = ctx;
+          }}
+        ></TranslationContextConsumer>
+      </Chat>,
+    );
+
+    await waitFor(() => {
+      expect(context.t).not.toBe(t);
+      expect(context.t).toBe(i18nInstance.t);
+      expect(context.tDateTimeParser).not.toBe(tDateTimeParser);
+      expect(context.tDateTimeParser).toBe(i18nInstance.tDateTimeParser);
     });
+  });
 
-    it('uses the i18nInstance provided in props', async () => {
-      let context;
-      const i18nInstance = new Streami18n();
-      const { t, tDateTimeParser } = await i18nInstance.getTranslators();
-
-      i18nInstance.t = () => 't';
-      i18nInstance.tDateTimeParser = () => 'tDateTimeParser';
-
-      render(
-        <Chat client={chatClient} i18nInstance={i18nInstance}>
-          <TranslationContextConsumer
-            fn={(ctx) => {
-              context = ctx;
-            }}
-          ></TranslationContextConsumer>
-        </Chat>,
-      );
+  it('updates the context when props change', async () => {
+    let context;
+    const i18nInstance = new Streami18n();
+
+    i18nInstance.t = () => 't';
+    i18nInstance.tDateTimeParser = () => 'tDateTimeParser';
 
-      await waitFor(() => {
-        expect(context.t).not.toBe(t);
-        expect(context.t).toBe(i18nInstance.t);
-        expect(context.tDateTimeParser).not.toBe(tDateTimeParser);
-        expect(context.tDateTimeParser).toBe(i18nInstance.tDateTimeParser);
-      });
+    const { rerender } = render(
+      <Chat client={chatClient} i18nInstance={i18nInstance}>
+        <TranslationContextConsumer
+          fn={(ctx) => {
+            context = ctx;
+          }}
+        ></TranslationContextConsumer>
+      </Chat>,
+    );
+
+    await waitFor(() => {
+      expect(context.t).toBe(i18nInstance.t);
+      expect(context.tDateTimeParser).toBe(i18nInstance.tDateTimeParser);
     });
 
-    it('updates the context when props change', async () => {
-      let context;
-      const i18nInstance = new Streami18n();
-
-      i18nInstance.t = () => 't';
-      i18nInstance.tDateTimeParser = () => 'tDateTimeParser';
-
-      const { rerender } = render(
-        <Chat client={chatClient} i18nInstance={i18nInstance}>
-          <TranslationContextConsumer
-            fn={(ctx) => {
-              context = ctx;
-            }}
-          ></TranslationContextConsumer>
-        </Chat>,
-      );
+    const newI18nInstance = new Streami18n();
 
-      await waitFor(() => {
-        expect(context.t).toBe(i18nInstance.t);
-        expect(context.tDateTimeParser).toBe(i18nInstance.tDateTimeParser);
-      });
+    newI18nInstance.t = () => 'newT';
+    newI18nInstance.tDateTimeParser = () => 'newtDateTimeParser';
 
-      const newI18nInstance = new Streami18n();
+    rerender(
+      <Chat client={chatClient} i18nInstance={newI18nInstance}>
+        <TranslationContextConsumer
+          fn={(ctx) => {
+            context = ctx;
+          }}
+        ></TranslationContextConsumer>
+      </Chat>,
+    );
+    await waitFor(() => {
+      expect(context.t).not.toBe(i18nInstance.t);
+      expect(context.t).toBe(newI18nInstance.t);
+      expect(context.tDateTimeParser).not.toBe(i18nInstance.tDateTimeParser);
+      expect(context.tDateTimeParser).toBe(newI18nInstance.tDateTimeParser);
+    });
+  });
 
-      newI18nInstance.t = () => 'newT';
-      newI18nInstance.tDateTimeParser = () => 'newtDateTimeParser';
+  it('makes sure DBSyncManager listeners are cleaned up after Chat remount', async () => {
+    const chatClientWithUser = await getTestClientWithUser({ id: 'testID' });
 
-      rerender(
-        <Chat client={chatClient} i18nInstance={newI18nInstance}>
-          <TranslationContextConsumer
-            fn={(ctx) => {
-              context = ctx;
-            }}
-          ></TranslationContextConsumer>
-        </Chat>,
-      );
-      await waitFor(() => {
-        expect(context.t).not.toBe(i18nInstance.t);
-        expect(context.t).toBe(newI18nInstance.t);
-        expect(context.tDateTimeParser).not.toBe(i18nInstance.tDateTimeParser);
-        expect(context.tDateTimeParser).toBe(newI18nInstance.tDateTimeParser);
-      });
+    // initial mount and render
+    const { rerender } = render(<Chat client={chatClientWithUser} enableOfflineSupport key={1} />);
+
+    let unsubscribeSpy;
+    let listenersAfterInitialMount;
+
+    await waitFor(() => {
+      // the unsubscribe fn changes during init(), so we keep a reference to the spy
+      unsubscribeSpy = jest.spyOn(DBSyncManager.connectionChangedListener, 'unsubscribe');
+      listenersAfterInitialMount = chatClientWithUser.listeners['connection.changed'];
     });
 
-    it('makes sure DBSyncManager listeners are cleaned up after Chat remount', async () => {
-      const chatClientWithUser = await getTestClientWithUser({ id: 'testID' });
-      jest.spyOn(DBSyncManager, 'init');
+    // remount
+    rerender(<Chat client={chatClientWithUser} enableOfflineSupport key={2} />);
 
-      // initial mount and render
-      const { rerender } = render(
-        <Chat client={chatClientWithUser} enableOfflineSupport key={1} />,
+    await waitFor(() => {
+      expect(DBSyncManager.init).toHaveBeenCalledTimes(2);
+      expect(unsubscribeSpy).toHaveBeenCalledTimes(2);
+      expect(chatClientWithUser.listeners['connection.changed'].length).toBe(
+        listenersAfterInitialMount.length,
       );
+    });
+  });
+
+  it('makes sure DBSyncManager listeners are cleaned up if the user changes', async () => {
+    const chatClientWithUser = await getTestClientWithUser({ id: 'testID1' });
+
+    // initial render
+    const { rerender } = render(<Chat client={chatClientWithUser} enableOfflineSupport />);
+
+    let unsubscribeSpy;
+    let listenersAfterInitialMount;
 
+    await waitFor(() => {
       // the unsubscribe fn changes during init(), so we keep a reference to the spy
-      const unsubscribeSpy = jest.spyOn(DBSyncManager.connectionChangedListener, 'unsubscribe');
-      const listenersAfterInitialMount = chatClientWithUser.listeners['connection.changed'];
-
-      // remount
-      rerender(<Chat client={chatClientWithUser} enableOfflineSupport key={2} />);
-
-      await waitFor(() => {
-        expect(DBSyncManager.init).toHaveBeenCalledTimes(2);
-        expect(unsubscribeSpy).toHaveBeenCalledTimes(2);
-        expect(chatClientWithUser.listeners['connection.changed'].length).toBe(
-          listenersAfterInitialMount.length,
-        );
-      });
+      unsubscribeSpy = jest.spyOn(DBSyncManager.connectionChangedListener, 'unsubscribe');
+      listenersAfterInitialMount = chatClientWithUser.listeners['connection.changed'];
     });
 
-    it('makes sure DBSyncManager listeners are cleaned up if the user changes', async () => {
-      const chatClientWithUser = await getTestClientWithUser({ id: 'testID1' });
-      jest.spyOn(DBSyncManager, 'init');
+    await act(async () => {
+      await setUser(chatClientWithUser, { id: 'testID2' });
+    });
 
-      // initial render
-      const { rerender } = render(<Chat client={chatClientWithUser} enableOfflineSupport />);
+    // rerender with different user ID
+    rerender(<Chat client={chatClientWithUser} enableOfflineSupport />);
 
-      // the unsubscribe fn changes during init(), so we keep a reference to the spy
-      const unsubscribeSpy = jest.spyOn(DBSyncManager.connectionChangedListener, 'unsubscribe');
-      await act(async () => {
-        await setUser(chatClientWithUser, { id: 'testID2' });
-      });
-      const listenersAfterInitialMount = chatClientWithUser.listeners['connection.changed'];
-
-      // rerender with different user ID
-      rerender(<Chat client={chatClientWithUser} enableOfflineSupport />);
-
-      await waitFor(() => {
-        expect(DBSyncManager.init).toHaveBeenCalledTimes(2);
-        expect(unsubscribeSpy).toHaveBeenCalledTimes(1);
-        expect(chatClientWithUser.listeners['connection.changed'].length).toBe(
-          listenersAfterInitialMount.length,
-        );
-      });
+    await waitFor(() => {
+      expect(DBSyncManager.init).toHaveBeenCalledTimes(2);
+      expect(unsubscribeSpy).toHaveBeenCalledTimes(1);
+      expect(chatClientWithUser.listeners['connection.changed'].length).toBe(
+        listenersAfterInitialMount.length,
+      );
     });
+  });
 
-    it('makes sure DBSyncManager state stays intact during normal rerenders', async () => {
-      const chatClientWithUser = await getTestClientWithUser({ id: 'testID' });
-      jest.spyOn(DBSyncManager, 'init');
+  it('makes sure DBSyncManager state stays intact during normal rerenders', async () => {
+    const chatClientWithUser = await getTestClientWithUser({ id: 'testID' });
 
-      // initial render
-      const { rerender } = render(<Chat client={chatClientWithUser} enableOfflineSupport />);
+    // initial render
+    const { rerender } = render(<Chat client={chatClientWithUser} enableOfflineSupport />);
 
+    let unsubscribeSpy;
+    await waitFor(() => {
       // the unsubscribe fn changes during init(), so we keep a reference to the spy
-      const unsubscribeSpy = jest.spyOn(DBSyncManager.connectionChangedListener, 'unsubscribe');
-      const listenersAfterInitialMount = chatClientWithUser.listeners['connection.changed'];
-
-      // rerender
-      rerender(<Chat client={chatClientWithUser} enableOfflineSupport />);
-
-      await waitFor(() => {
-        expect(DBSyncManager.init).toHaveBeenCalledTimes(1);
-        expect(unsubscribeSpy).toHaveBeenCalledTimes(0);
-        expect(chatClientWithUser.listeners['connection.changed'].length).toBe(
-          listenersAfterInitialMount.length,
-        );
-      });
+      unsubscribeSpy = jest.spyOn(DBSyncManager.connectionChangedListener, 'unsubscribe');
+    });
+
+    const listenersAfterInitialMount = chatClientWithUser.listeners['connection.changed'];
+
+    // rerender
+    rerender(<Chat client={chatClientWithUser} enableOfflineSupport />);
+
+    await waitFor(() => {
+      expect(DBSyncManager.init).toHaveBeenCalledTimes(1);
+      expect(unsubscribeSpy).toHaveBeenCalledTimes(1);
+      expect(chatClientWithUser.listeners['connection.changed'].length).toBe(
+        listenersAfterInitialMount.length,
+      );
     });
   });
 });

package/src/components/Chat/hooks/handleEventToSyncDB.ts

@@ -11,12 +11,12 @@ import { upsertChannels } from '../../../store/apis/upsertChannels';
 import { upsertMembers } from '../../../store/apis/upsertMembers';
 import { upsertMessages } from '../../../store/apis/upsertMessages';
 import { upsertReads } from '../../../store/apis/upsertReads';
-import { QuickSqliteClient } from '../../../store/QuickSqliteClient';
 import { createSelectQuery } from '../../../store/sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../../../store/SqliteClient';
 import { PreparedQueries } from '../../../store/types';
 import { DefaultStreamChatGenerics } from '../../../types/types';
 
-export const handleEventToSyncDB = <
+export const handleEventToSyncDB = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >(
   event: Event,
@@ -28,13 +28,13 @@ export const handleEventToSyncDB = <
   // This function is used to guard the queries that require channel to be present in the db first
   // If channel is not present in the db, we first fetch the channel data from the channel object
   // and then add the queries with a channel create query first
-  const queriesWithChannelGuard = (
-    createQueries: (flushOverride?: boolean) => PreparedQueries[],
+  const queriesWithChannelGuard = async (
+    createQueries: (flushOverride?: boolean) => Promise<PreparedQueries[]>,
   ) => {
     const cid = event.cid || event.channel?.cid;
 
-    if (!cid) return createQueries(flush);
-    const channels = QuickSqliteClient.executeSql.apply(
+    if (!cid) return await createQueries(flush);
+    const channels = await SqliteClient.executeSql.apply(
       null,
       createSelectQuery('channels', ['cid'], {
         cid,
@@ -48,14 +48,15 @@ export const handleEventToSyncDB = <
           ? client.channel(event.channel_type, event.channel_id)
           : undefined;
       if (channel && channel.initialized && !channel.disconnected) {
-        const channelQuery = upsertChannelDataFromChannel({
+        const channelQuery = await upsertChannelDataFromChannel({
           channel,
           flush,
         });
         if (channelQuery) {
-          const newQueries = [...channelQuery, ...createQueries(false)];
+          const createdQueries = await createQueries(false);
+          const newQueries = [...channelQuery, ...createdQueries];
           if (flush !== false) {
-            QuickSqliteClient.executeSqlBatch(newQueries);
+            await SqliteClient.executeSqlBatch(newQueries);
           }
           return newQueries;
         } else {
@@ -80,7 +81,7 @@ export const handleEventToSyncDB = <
     const cid = event.cid;
     const user = event.user;
     if (user?.id && cid) {
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         upsertReads({
           cid,
           flush: flushOverride,
@@ -98,8 +99,9 @@ export const handleEventToSyncDB = <
 
   if (type === 'message.new') {
     const message = event.message;
+
     if (message && (!message.parent_id || message.show_in_channel)) {
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         upsertMessages({
           flush: flushOverride,
           messages: [message],
@@ -113,7 +115,7 @@ export const handleEventToSyncDB = <
     if (message && !message.parent_id) {
       // Update only if it exists, otherwise event could be related
       // to a message which is not in database.
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         updateMessage({
           flush: flushOverride,
           message,
@@ -126,7 +128,7 @@ export const handleEventToSyncDB = <
     const message = event.message;
     if (message && event.reaction) {
       // We update the entire message to make sure we also update reaction_groups
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         updateMessage({
           flush: flushOverride,
           message,
@@ -141,7 +143,7 @@ export const handleEventToSyncDB = <
       // Here we are relying on the fact message.latest_reactions always includes
       // the new reaction. So we first delete all the existing reactions and populate
       // the reactions table with message.latest_reactions
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         updateMessage({
           flush: flushOverride,
           message,
@@ -200,7 +202,7 @@ export const handleEventToSyncDB = <
     const member = event.member;
     const cid = event.cid;
     if (member && cid) {
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         upsertMembers({
           cid,
           flush: flushOverride,
@@ -214,7 +216,7 @@ export const handleEventToSyncDB = <
     const member = event.member;
     const cid = event.cid;
     if (member && cid) {
-      return queriesWithChannelGuard((flushOverride) =>
+      return await queriesWithChannelGuard((flushOverride) =>
         deleteMember({
           cid,
           flush: flushOverride,

package/src/components/Chat/hooks/useAppSettings.ts

@@ -44,9 +44,10 @@ export const useAppSettings = <
      */
     const enforceAppSettingsWithOfflineSupport = async () => {
       if (!client.userID) return;
+      if (!initialisedDatabase) return;
 
       if (!isOnline) {
-        const appSettings = dbApi.getAppSettings({ currentUserId: client.userID });
+        const appSettings = await dbApi.getAppSettings({ currentUserId: client.userID });
         setAppSettings(appSettings);
         return;
       }
@@ -55,7 +56,7 @@ export const useAppSettings = <
         const appSettings = await client.getAppSettings();
         if (isMounted.current) {
           setAppSettings(appSettings);
-          dbApi.upsertAppSettings({
+          await dbApi.upsertAppSettings({
             appSettings,
             currentUserId: client.userID as string,
           });