@messenger-box/platform-mobile 10.0.3-alpha.33 → 10.0.3-alpha.36

package/src/screens/inbox/containers/ConversationView.tsx

@@ -360,12 +360,37 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
     const safeSend = useCallback(
         (event) => {
             try {
+                console.log('🛠️ Safe send event:', event.type);
                 send(event);
+
+                // For important events like SET_CHANNEL_MESSAGES, verify they worked
+                if (event.type === ConversationActions.SET_CHANNEL_MESSAGES) {
+                    // Add a verification step to ensure state was updated
+                    setTimeout(() => {
+                        // Don't log for every check to avoid console spam
+                        if (state.context.channelMessages.length === 0 && event.data?.messages?.length > 0) {
+                            console.warn('🛠️ SET_CHANNEL_MESSAGES did not update state - messages still empty');
+                        }
+                    }, 100);
+                }
             } catch (error) {
-                console.error('Error sending event to state machine:', error, event);
+                console.error('🛠️ Error in safeSend:', error, 'Event type:', event.type);
+                // Try direct state update as fallback for critical events
+                if (event.type === ConversationActions.SET_CHANNEL_MESSAGES && event.data?.messages) {
+                    console.log('🛠️ Attempting fallback for SET_CHANNEL_MESSAGES');
+                    try {
+                        // Direct update as fallback
+                        send({
+                            type: 'DIRECT_STATE_UPDATE',
+                            data: event.data,
+                        });
+                    } catch (fallbackError) {
+                        console.error('🛠️ Even fallback failed:', fallbackError);
+                    }
+                }
             }
         },
-        [send],
+        [send, state.context.channelMessages.length],
     );
 
     // Immediately set initial context if needed
@@ -460,13 +485,27 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
                 );
                 console.log('Message count from query:', queryData.messages.data.length);
                 console.log('Total count from query:', queryData.messages.totalCount);
+
+                // DIRECT STATE UPDATE: Immediately update state to ensure messages are displayed
+                if (queryData.messages.data.length > 0) {
+                    console.log('🔄 IMMEDIATE STATE UPDATE with messages:', queryData.messages.data.length);
+                    safeSend({
+                        type: ConversationActions.SET_CHANNEL_MESSAGES,
+                        data: {
+                            messages: queryData.messages.data,
+                            totalCount: queryData.messages.totalCount,
+                        },
+                    });
+                }
             }
         },
         onError: (error) => {
             console.error('MESSAGE QUERY ERROR:', error);
+            // Report error to state machine
+            safeSend({ type: 'ERROR', data: { message: String(error) } });
         },
     });
-
+    // console.log('🔄 MESSAGE QUERY COMPLETED:', JSON.stringify(data));
     // Modify the fetchMessagesDirectly function to use safe access
     const fetchMessagesDirectly = useCallback(async () => {
         const channelId = safeGetContext().channelId;
@@ -848,14 +887,35 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
             if (messages && messages.length > 0) {
                 console.log('📩 QUERY DATA - Setting channel messages, count:', messages.length);
 
-                // First try dispatching the update through XState
-                send({
-                    type: ConversationActions.SET_CHANNEL_MESSAGES,
-                    data: {
-                        messages: uniqBy([...messages, ...state.context.channelMessages], ({ id }) => id),
-                        totalCount: messageTotalCount,
-                    },
-                });
+                // Use timeout to ensure this doesn't conflict with other state updates
+                setTimeout(() => {
+                    // Directly update the state machine with new messages
+                    safeSend({
+                        type: ConversationActions.SET_CHANNEL_MESSAGES,
+                        data: {
+                            messages: uniqBy([...messages, ...state.context.channelMessages], ({ id }) => id),
+                            totalCount: messageTotalCount,
+                        },
+                    });
+
+                    // Verify the update was processed properly
+                    setTimeout(() => {
+                        const currentMessagesCount = state.context.channelMessages?.length || 0;
+                        console.log('📩 STATE UPDATE VERIFICATION - Current message count:', currentMessagesCount);
+
+                        if (currentMessagesCount === 0) {
+                            console.warn('⚠️ STATE NOT UPDATED after message data received - triggering fallback');
+                            // Direct fallback approach
+                            safeSend({
+                                type: ConversationActions.SET_CHANNEL_MESSAGES,
+                                data: {
+                                    messages: messages,
+                                    totalCount: messageTotalCount,
+                                },
+                            });
+                        }
+                    }, 500);
+                }, 0);
 
                 // Debug: Log the first message to verify data format
                 if (messages[0]) {
@@ -873,16 +933,9 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
                         }),
                     );
                 }
-
-                // Check if the state machine actually updated (debug only)
-                setTimeout(() => {
-                    if (state.context.channelMessages?.length === 0) {
-                        console.warn('⚠️ STATE NOT UPDATED after message data received - may need fallback');
-                    }
-                }, 500);
             }
         }
-    }, [data]);
+    }, [data, safeSend]);
 
     // Optimize onFetchOld by adding debounce logic
     const onFetchOld = useCallback(() => {
@@ -1561,45 +1614,62 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
                                 channelId: state?.context?.channelId?.toString(),
                             },
                             updateQuery: (prev, { subscriptionData }: any) => {
-                                if (!subscriptionData?.data?.chatMessageAdded) return prev;
-
-                                const newMessage = subscriptionData.data.chatMessageAdded;
-                                const currentMessages = prev?.messages?.data || [];
-
-                                // Check if message already exists to prevent duplicates
-                                if (currentMessages.some((msg) => msg.id === newMessage.id)) {
-                                    return prev; // Skip update if message already exists
-                                }
-
-                                // Use a ref to track the last processed message ID to prevent duplicate processing
-                                if (lastProcessedMessageRef.current === newMessage.id) {
-                                    return prev;
-                                }
-
-                                lastProcessedMessageRef.current = newMessage.id;
-
-                                // Use a batch update strategy to avoid frequent re-renders
-                                queueMicrotask(() => {
-                                    safeSend({
-                                        type: ConversationActions.SET_CHANNEL_MESSAGES,
-                                        data: {
-                                            messages: uniqBy(
-                                                [...state.context.channelMessages, newMessage],
-                                                ({ id }) => id,
-                                            ),
+                                try {
+                                    // Log for debugging
+                                    console.log(
+                                        '🔔 Subscription data received for channel:',
+                                        state?.context?.channelId,
+                                    );
+
+                                    // Check if we have valid subscription data
+                                    if (!subscriptionData?.data?.chatMessageAdded) {
+                                        console.log('🔔 No valid message in subscription data');
+                                        return prev;
+                                    }
+
+                                    const newMessage = subscriptionData.data.chatMessageAdded;
+                                    console.log('🔔 New message received:', newMessage.id);
+
+                                    // Check if we already have this message to avoid duplicates
+                                    const currentMessages = prev?.messages?.data || [];
+                                    if (currentMessages.some((msg) => msg.id === newMessage.id)) {
+                                        console.log('🔔 Message already in cache, skipping update');
+                                        return prev;
+                                    }
+
+                                    // Capture the new message in state directly
+                                    setTimeout(() => {
+                                        try {
+                                            // Update state machine directly
+                                            console.log('🔔 Directly updating state machine with new message');
+                                            safeSend({
+                                                type: ConversationActions.SET_CHANNEL_MESSAGES,
+                                                data: {
+                                                    messages: [...state.context.channelMessages, newMessage],
+                                                    totalCount: (state.context.totalCount || 0) + 1,
+                                                },
+                                            });
+                                        } catch (error) {
+                                            console.error('🔔 Error updating state with subscription data:', error);
+                                        }
+                                    }, 0);
+
+                                    // Update Apollo cache
+                                    const updatedData = {
+                                        ...prev,
+                                        messages: {
+                                            ...prev.messages,
+                                            data: [...currentMessages, newMessage],
                                             totalCount: (prev?.messages?.totalCount || 0) + 1,
                                         },
-                                    });
-                                });
+                                    };
 
-                                return {
-                                    ...prev,
-                                    messages: {
-                                        ...prev?.messages,
-                                        data: [...currentMessages, newMessage],
-                                        totalCount: (prev?.messages?.totalCount || 0) + 1,
-                                    },
-                                };
+                                    console.log('🔔 Returning updated query data with new messages');
+                                    return updatedData;
+                                } catch (error) {
+                                    console.error('🔔 Error in subscription updateQuery:', error);
+                                    return prev;
+                                }
                             },
                         })
                     }
@@ -1615,9 +1685,6 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
         safeSend,
     ]);
 
-    // Add ref to track last processed message
-    const lastProcessedMessageRef = useRef(null);
-
     // Add optimized listViewProps to reduce re-renders and improve list performance
     const listViewProps = useMemo(
         () => ({
@@ -1759,15 +1826,31 @@ const ConversationViewComponent = ({ channelId: ChannelId, role, isShowThreadMes
 };
 
 const SubscriptionHandler = ({ subscribeToNewMessages, channelId }: ISubscriptionHandlerProps) => {
-    // Use memo for the channelId dependency to prevent unnecessary subscriptions
+    // Store the channelId in a ref to track changes
     const channelIdRef = useRef(channelId);
 
     useEffect(() => {
-        if (channelId && channelId !== channelIdRef.current) {
-            channelIdRef.current = channelId;
-            console.log('Setting up subscription for channel:', channelId);
-            return subscribeToNewMessages();
+        // Don't set up subscription if there's no channel ID
+        if (!channelId) {
+            console.log('⚠️ No channel ID for subscription');
+            return;
         }
+
+        console.log('🔄 Setting up NEW subscription for channel:', channelId);
+
+        // Call the subscribe function and store the unsubscribe function
+        const unsubscribe = subscribeToNewMessages();
+
+        // Update the ref with the current channelId
+        channelIdRef.current = channelId;
+
+        // Return cleanup function
+        return () => {
+            if (unsubscribe && typeof unsubscribe === 'function') {
+                console.log('🔄 Cleaning up subscription for channel:', channelIdRef.current);
+                unsubscribe();
+            }
+        };
     }, [channelId, subscribeToNewMessages]);
 
     return null;

package/src/screens/inbox/containers/Dialogs.tsx

@@ -6,7 +6,7 @@ import { useNavigation, useRoute, useFocusEffect } from '@react-navigation/nativ
 import { orderBy } from 'lodash-es';
 import { DialogsListItem } from '../components/DialogsListItem';
 import { ServiceDialogsListItem } from '../components/ServiceDialogsListItem';
-import { useGetChannelsByUserWithServiceChannelsQuery } from 'common/graphql';
+import { useGetChannelsByUserWithServiceChannelsQuery, OnChatMessageAddedDocument } from 'common/graphql';
 import { RoomType } from 'common';
 import { userSelector } from '@adminide-stack/user-auth0-client';
 import { config } from '../config';
@@ -25,6 +25,8 @@ const Actions = {
     STOP_LOADING: 'STOP_LOADING',
     LOAD_MORE_CHANNELS: 'LOAD_MORE_CHANNELS',
     SET_SEARCH_QUERY: 'SET_SEARCH_QUERY',
+    UPDATE_CHANNEL: 'UPDATE_CHANNEL',
+    REORDER_CHANNELS: 'REORDER_CHANNELS',
 };
 
 const BaseState = {
@@ -112,11 +114,34 @@ function useSafeMachine(machine) {
                 }));
             } else if (event.type === Actions.FETCH_CHANNELS) {
                 console.log('Setting channels:', event.data?.channels?.length || 0);
+
+                // Process channels to ensure lastMessage property is properly structured for child components
+                const processedChannels =
+                    event.data?.channels?.map((channel) => {
+                        // If channel has a lastMessage, ensure it's properly formatted
+                        if (channel.lastMessage) {
+                            return {
+                                ...channel,
+                                lastMessage: {
+                                    ...channel.lastMessage,
+                                    // Ensure these essential properties exist
+                                    id: channel.lastMessage.id,
+                                    message: channel.lastMessage.message,
+                                    createdAt: channel.lastMessage.createdAt || channel.lastMessage.updatedAt,
+                                    updatedAt: channel.lastMessage.updatedAt || channel.lastMessage.createdAt,
+                                    userId: channel.lastMessage.userId,
+                                    channelId: channel.lastMessage.channelId || channel.id,
+                                },
+                            };
+                        }
+                        return channel;
+                    }) || [];
+
                 setState((prev) => ({
                     ...prev,
                     context: {
                         ...prev.context,
-                        channels: event.data?.channels || [],
+                        channels: processedChannels,
                         hasMoreChannels: (event.data?.channels?.length || 0) > 0,
                         loading: event.data?.stopLoading ? false : prev.context.loading,
                         refreshing: event.data?.stopLoading ? false : prev.context.refreshing,
@@ -128,17 +153,74 @@ function useSafeMachine(machine) {
                 const newChannels = event.data?.channels || [];
                 console.log('Appending channels:', newChannels.length);
 
+                // Process new channels to ensure lastMessage property is properly structured
+                const processedNewChannels = newChannels.map((channel) => {
+                    // If channel has a lastMessage, ensure it's properly formatted
+                    if (channel.lastMessage) {
+                        return {
+                            ...channel,
+                            lastMessage: {
+                                ...channel.lastMessage,
+                                // Ensure these essential properties exist
+                                id: channel.lastMessage.id,
+                                message: channel.lastMessage.message,
+                                createdAt: channel.lastMessage.createdAt || channel.lastMessage.updatedAt,
+                                updatedAt: channel.lastMessage.updatedAt || channel.lastMessage.createdAt,
+                                userId: channel.lastMessage.userId,
+                                channelId: channel.lastMessage.channelId || channel.id,
+                            },
+                        };
+                    }
+                    return channel;
+                });
+
                 setState((prev) => ({
                     ...prev,
                     context: {
                         ...prev.context,
-                        channels: [...prev.context.channels, ...newChannels],
+                        channels: [...prev.context.channels, ...processedNewChannels],
                         hasMoreChannels: newChannels.length >= 10, // If we got fewer than 10 channels, assume no more are available
                         page: prev.context.page + 1,
                         loadingMore: false,
                     },
                     value: BaseState.Idle,
                 }));
+            } else if (event.type === Actions.UPDATE_CHANNEL) {
+                // Handle channel update from subscription
+                setState((prev) => {
+                    const updatedChannel = event.data?.channel;
+                    if (!updatedChannel || !updatedChannel.id) return prev;
+
+                    // Find and update specific channel
+                    const updatedChannels = prev.context.channels.map((channel) =>
+                        channel.id === updatedChannel.id ? updatedChannel : channel,
+                    );
+
+                    return {
+                        ...prev,
+                        context: {
+                            ...prev.context,
+                            channels: updatedChannels,
+                        },
+                    };
+                });
+            } else if (event.type === Actions.REORDER_CHANNELS) {
+                // Re-sort channels by updateAt timestamp to move newly updated ones to top
+                setState((prev) => {
+                    const sortedChannels = [...prev.context.channels].sort((a, b) => {
+                        const dateA = new Date(a?.updatedAt || a?.createdAt).getTime();
+                        const dateB = new Date(b?.updatedAt || b?.createdAt).getTime();
+                        return dateB - dateA; // Newest first
+                    });
+
+                    return {
+                        ...prev,
+                        context: {
+                            ...prev.context,
+                            channels: sortedChannels,
+                        },
+                    };
+                });
             } else if (event.type === Actions.REFRESH_CHANNELS) {
                 setState((prev) => ({
                     ...prev,
@@ -335,7 +417,7 @@ const DialogsComponent = (props: InboxProps) => {
     }, []);
 
     // Apollo query for fetching channels
-    const { refetch: getChannelsRefetch } = useGetChannelsByUserWithServiceChannelsQuery({
+    const { refetch: getChannelsRefetch, subscribeToMore } = useGetChannelsByUserWithServiceChannelsQuery({
         variables: {
             role: channelRole,
             criteria: channelFilters,
@@ -407,8 +489,8 @@ const DialogsComponent = (props: InboxProps) => {
                 // Use more efficient sorting
                 const sortedChannels =
                     filteredChannels.sort((a, b) => {
-                        const dateA = new Date(a.updatedAt);
-                        const dateB = new Date(b.updatedAt);
+                        const dateA = new Date(a.updatedAt || a.createdAt);
+                        const dateB = new Date(b.updatedAt || b.createdAt);
                         return dateB.getTime() - dateA.getTime();
                     }) || [];
 
@@ -421,9 +503,13 @@ const DialogsComponent = (props: InboxProps) => {
                             data: { channels: sortedChannels },
                         });
                     } else {
+                        // Use a single update to prevent UI jumping
                         safeSend({
                             type: Actions.FETCH_CHANNELS,
-                            data: { channels: sortedChannels, stopLoading: true },
+                            data: {
+                                channels: sortedChannels,
+                                stopLoading: true,
+                            },
                         });
                     }
 
@@ -495,7 +581,7 @@ const DialogsComponent = (props: InboxProps) => {
 
             console.log(`📊 Fast refresh completed: ${sortedChannels.length} channels`);
 
-            // Update the state with the new channels, but only if still mounted
+            // Use a single update to prevent UI jumping
             if (isMountedRef.current) {
                 // Use a single update to prevent UI jumping
                 safeSend({
@@ -514,6 +600,106 @@ const DialogsComponent = (props: InboxProps) => {
         }
     }, [getChannelsRefetch, channelRole, channelFilters, supportServices, auth?.id, safeSend]);
 
+    // Subscription ref to track and reuse the subscription
+    const messageSubscriptionRef = useRef(null);
+
+    // Set up message subscription for real-time updates
+    useEffect(() => {
+        if (!auth || !auth.id || messageSubscriptionRef.current) return; // Skip if already subscribed or no auth
+
+        console.log('📱 Setting up global message subscription for dialog updates');
+
+        // Set up subscription for message updates
+        const unsubscribe = subscribeToMore({
+            document: OnChatMessageAddedDocument,
+            variables: {}, // No specific channel ID - we'll filter in the updateQuery
+            updateQuery: (prev, { subscriptionData }) => {
+                try {
+                    if (!subscriptionData.data || !isMountedRef.current) return prev;
+
+                    // Access chatMessageAdded from the subscription data
+                    // Cast to any to avoid TypeScript errors with dynamic subscription data
+                    const subData = subscriptionData.data as any;
+                    const newMessage = subData.chatMessageAdded;
+
+                    console.log('📱 Dialog subscription received message update:', newMessage?.id);
+
+                    // Skip if no message or no channelId
+                    if (!newMessage || !newMessage.channelId) return prev;
+
+                    // Get the current channels from state context rather than closure
+                    const currentChannels = safeGetContext().channels || [];
+
+                    // Find the channel that needs to be updated
+                    const channelToUpdate = currentChannels.find(
+                        (c) => c.id?.toString() === newMessage.channelId?.toString(),
+                    );
+
+                    if (channelToUpdate) {
+                        console.log('📱 Found channel to update:', channelToUpdate.id);
+
+                        // Create a more complete updated channel object with the new message
+                        const updatedChannel = {
+                            ...channelToUpdate,
+                            updatedAt: newMessage.createdAt || newMessage.updatedAt,
+                            lastMessage: {
+                                ...newMessage,
+                                // Ensure these properties are present for rendering in child components
+                                id: newMessage.id,
+                                message: newMessage.message,
+                                createdAt: newMessage.createdAt || newMessage.updatedAt,
+                                updatedAt: newMessage.updatedAt || newMessage.createdAt,
+                                userId: newMessage.userId,
+                                channelId: newMessage.channelId,
+                            },
+                        };
+
+                        // Update the channel with new message immediately
+                        if (isMountedRef.current) {
+                            // Update the channel
+                            safeSend({
+                                type: Actions.UPDATE_CHANNEL,
+                                data: {
+                                    channel: updatedChannel,
+                                },
+                            });
+
+                            // Reorder channels to bring updated one to top
+                            safeSend({
+                                type: Actions.REORDER_CHANNELS,
+                            });
+                        }
+                    } else {
+                        console.log('📱 Channel not found in current list, triggering refresh');
+                        // If we received a message for a channel that's not in our current list
+                        // trigger a refresh to get the updated channel list
+                        if (isMountedRef.current && !safeGetContext().refreshing && !safeGetContext().loading) {
+                            fastRefresh();
+                        }
+                    }
+
+                    // Return unchanged prev (we're updating via state machine instead)
+                    return prev;
+                } catch (error) {
+                    console.error('Error in dialog subscription handler:', error);
+                    return prev;
+                }
+            },
+        });
+
+        // Save subscription in ref for reuse
+        messageSubscriptionRef.current = unsubscribe;
+
+        // Clean up subscription when component unmounts
+        return () => {
+            if (messageSubscriptionRef.current) {
+                console.log('📱 Cleaning up dialog message subscription');
+                messageSubscriptionRef.current();
+                messageSubscriptionRef.current = null;
+            }
+        };
+    }, [auth?.id, isMountedRef, safeGetContext, fastRefresh, safeSend, subscribeToMore]);
+
     // Process state changes and execute side effects
     useEffect(() => {
         // Only execute if not already refreshing or loading to prevent loops
@@ -584,61 +770,46 @@ const DialogsComponent = (props: InboxProps) => {
 
     // Handle refresh on focus (when navigating back to this screen)
     const focusRefreshRef = useRef<number | null>(null);
+    // Add a timestamp ref to track last refresh time
+    const lastRefreshTimeRef = useRef(Date.now());
+    // Minimum interval between refreshes (2 seconds)
+    const MIN_REFRESH_INTERVAL = 2000;
 
     useFocusEffect(
         useCallback(() => {
-            // Use a flag to ensure we only trigger refresh once per focus
-            let hasTriggeredRefresh = false;
-
-            // Reset the focus refresh tracking when component gets focus
-            const now = Date.now();
-            const lastRefresh = focusRefreshRef.current;
-
-            // Only refresh if at least 2 seconds have passed since last refresh
-            const shouldRefresh = lastRefresh === null || now - lastRefresh > 2000;
-
-            // Only refresh if component is mounted and not in initial state,
-            // and not already refreshing/loading
-            const context = safeGetContext();
-            const isAlreadyFetching = context.refreshing || context.loading;
-
-            if (
-                isMountedRef.current &&
-                !hasTriggeredRefresh &&
-                !isAlreadyFetching &&
-                shouldRefresh &&
-                (channels.length > 0 || safeMatches(BaseState.Idle))
-            ) {
-                hasTriggeredRefresh = true;
-                focusRefreshRef.current = now;
-
-                // Use fast refresh for better performance
-                console.log('🔄 Focus effect: triggering fast refresh');
-                safeSend({
-                    type: Actions.START_LOADING,
-                    data: { refreshing: true },
-                });
+            console.log('📱 Focus effect triggered for Dialogs screen');
+
+            // Always do a lightweight refresh on focus for the latest messages
+            // This ensures we always have up-to-date message status when returning to the screen
+            const performRefresh = () => {
+                // Check if enough time has passed since last refresh
+                const now = Date.now();
+                if (now - lastRefreshTimeRef.current < MIN_REFRESH_INTERVAL) {
+                    console.log('⏩ Skipping refresh: too soon after previous refresh');
+                    return;
+                }
 
-                // Execute fast refresh with a short delay to prevent UI jank
-                setTimeout(() => {
-                    if (isMountedRef.current) {
-                        fastRefresh();
-                    }
-                }, 100);
-            } else {
-                console.log('⏩ Skipping focus refresh:', {
-                    isAlreadyFetching,
-                    hasTriggeredRefresh,
-                    shouldRefresh,
-                    timeGap: lastRefresh === null ? 'first refresh' : now - lastRefresh,
-                });
-            }
+                console.log('🔄 Performing forced refresh on screen focus');
+                if (isMountedRef.current) {
+                    // Update last refresh timestamp
+                    lastRefreshTimeRef.current = now;
+
+                    safeSend({
+                        type: Actions.START_LOADING,
+                        data: { refreshing: true },
+                    });
+                    fastRefresh();
+                }
+            };
+
+            // Always refresh when returning to the screen, with a small delay
+            const focusRefreshTimeout = setTimeout(performRefresh, 100);
 
+            // Cleanup function to remove the timeout if the component unmounts or loses focus
             return () => {
-                // Reset flag when focus is lost
-                hasTriggeredRefresh = false;
+                clearTimeout(focusRefreshTimeout);
             };
-        }, [safeSend, channels.length, safeMatches, safeGetContext, fastRefresh]),
+        }, [safeSend, fastRefresh]),
     );
 
     // Navigation handlers
@@ -745,7 +916,7 @@ const DialogsComponent = (props: InboxProps) => {
                             currentUser={auth}
                             channel={channel}
                             selectedChannelId={selectedChannelId}
-                            forceRefresh={false} // Change to false to avoid unnecessary refreshes
+                            forceRefresh={true}
                         />
                     );
                 }}