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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@messenger-box/platform-mobile",
-    "version": "10.0.3-alpha.34",
+    "version": "10.0.3-alpha.36",
     "description": "Sample core for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -22,8 +22,8 @@
         "watch-ts": "tsc --watch"
     },
     "dependencies": {
-        "@messenger-box/core": "10.0.3-alpha.34",
-        "@messenger-box/platform-client": "10.0.3-alpha.34",
+        "@messenger-box/core": "10.0.3-alpha.36",
+        "@messenger-box/platform-client": "10.0.3-alpha.36",
         "base-64": "1.0.0",
         "react-native-gifted-chat": "1.0.4"
     },
@@ -43,5 +43,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "33c7bdb4f36c40b6368a5c96fe6312de009188a1"
+    "gitHead": "c19b436784fffe67a8d77d89959a9ac898ab76c4"
 }

package/src/screens/inbox/components/DialogsListItem.tsx

@@ -689,6 +689,37 @@ export const DialogsListItemComponent: React.FC<IDialogListItemProps> = function
         });
     }, [channel?.id, lastMessage, safeContextProperty]);
 
+    // Optimize update logic for messages from channel-level subscription
+    const handleChannelMessage = (channel, newMessage) => {
+        // Check if we already have this message
+        if (state.context.messages.some((msg) => msg.id === newMessage.id)) {
+            console.log('Message already in local state, skipping update:', newMessage.id);
+            return;
+        }
+
+        console.log('Handling subscription message update at channel level:', newMessage.id);
+
+        // Always update with latest message to ensure dialog list stays current
+        safeSend({
+            type: Actions.UPDATE_MESSAGES,
+            data: {
+                // Use the directLastMessage option to force immediate UI update
+                directLastMessage: newMessage,
+                // Also update the messages array
+                messages: [...state.context.messages, newMessage],
+            },
+        });
+    };
+
+    // Create listener for channel property updates
+    useEffect(() => {
+        // Check if channel has a lastMessage property (set by parent Dialogs component)
+        if (channel?.lastMessage && channel.lastMessage.id) {
+            console.log('Channel has lastMessage property:', channel.lastMessage.id);
+            handleChannelMessage(channel, channel.lastMessage);
+        }
+    }, [channel?.lastMessage?.id]);
+
     return (
         <Pressable
             onPress={() => onOpen(channel?.id, title)}

package/src/screens/inbox/components/ServiceDialogsListItem.tsx

@@ -286,74 +286,100 @@ function useSafeMachine(machine) {
     return [stateWithMatches, send] as const;
 }
 
-const ServiceChannelWithLastMessage = React.memo(({ channel, lastMessage, subscribeToNewMessages }: any) => {
-    React.useEffect(() => {
-        // Subscribe and store the unsubscribe function
-        const unsubscribe = subscribeToNewMessages();
-        return () => {
-            // Cleanup subscription on unmount
-            if (unsubscribe && typeof unsubscribe === 'function') {
-                unsubscribe();
+const ServiceChannelWithLastMessage = React.memo(
+    ({ channel, lastMessage, subscribeToNewMessages, subscribeToChatMessages }: any) => {
+        React.useEffect(() => {
+            console.log(`Setting up subscriptions for channel ${channel?.id}`);
+            // Subscribe and store the unsubscribe functions
+            let threadUnsubscribe;
+            let chatUnsubscribe;
+
+            try {
+                threadUnsubscribe = subscribeToNewMessages();
+                chatUnsubscribe = subscribeToChatMessages();
+            } catch (error) {
+                console.error(`Error setting up subscriptions for channel ${channel?.id}:`, error);
             }
-        };
-    }, [subscribeToNewMessages]);
 
-    // Debug output for component rendering
-    React.useEffect(() => {
-        console.log(`ServiceChannelWithLastMessage rendered for channel ${channel?.id}:`, {
-            hasLastMessage: !!lastMessage,
-            messageId: lastMessage?.id,
-            messageText: lastMessage?.message?.substring(0, 20) + (lastMessage?.message?.length > 20 ? '...' : ''),
-            date: lastMessage?.createdAt ? safeDate(lastMessage.createdAt)?.toISOString() : 'none',
-        });
-    }, [lastMessage, channel?.id]);
-
-    const count = 30;
-    const title = channel?.title.slice(0, count) + (channel?.title.length > count ? '...' : '');
-
-    // Define message display text
-    let displayMessage = 'No messages yet';
-
-    if (lastMessage) {
-        // Check for file attachments
-        const hasFileAttachments = lastMessage.files?.data?.length > 0;
-
-        // Check if the message appears to be an image
-        const isImageMessage =
-            lastMessage.message?.includes('<img') ||
-            lastMessage.message?.includes('[Image]') ||
-            lastMessage.message?.includes('![') ||
-            (/\.(jpeg|jpg|gif|png|bmp|webp)/i.test(lastMessage.message || '') &&
-                ((lastMessage.message || '').includes('http') || (lastMessage.message || '').includes('/images/')));
-
-        if (hasFileAttachments) {
-            displayMessage = '📎 File attachment';
-        } else if (isImageMessage) {
-            displayMessage = '[Image]';
-        } else if (lastMessage.message && lastMessage.message.trim() !== '') {
-            displayMessage = lastMessage.message;
-        } else {
-            displayMessage = '(Empty message)';
+            return () => {
+                // Cleanup subscriptions on unmount
+                if (threadUnsubscribe && typeof threadUnsubscribe === 'function') {
+                    try {
+                        console.log(`Cleaning up thread subscription for channel ${channel?.id}`);
+                        threadUnsubscribe();
+                    } catch (error) {
+                        console.error(`Error cleaning up thread subscription for channel ${channel?.id}:`, error);
+                    }
+                }
+
+                if (chatUnsubscribe && typeof chatUnsubscribe === 'function') {
+                    try {
+                        console.log(`Cleaning up chat subscription for channel ${channel?.id}`);
+                        chatUnsubscribe();
+                    } catch (error) {
+                        console.error(`Error cleaning up chat subscription for channel ${channel?.id}:`, error);
+                    }
+                }
+            };
+        }, [subscribeToNewMessages, subscribeToChatMessages, channel?.id]);
+
+        // Debug output for component rendering
+        React.useEffect(() => {
+            console.log(`ServiceChannelWithLastMessage rendered for channel ${channel?.id}:`, {
+                hasLastMessage: !!lastMessage,
+                messageId: lastMessage?.id,
+                messageText: lastMessage?.message?.substring(0, 20) + (lastMessage?.message?.length > 20 ? '...' : ''),
+                date: lastMessage?.createdAt ? safeDate(lastMessage.createdAt)?.toISOString() : 'none',
+            });
+        }, [lastMessage, channel?.id]);
+
+        const count = 30;
+        const title = channel?.title.slice(0, count) + (channel?.title.length > count ? '...' : '');
+
+        // Define message display text
+        let displayMessage = 'No messages yet';
+
+        if (lastMessage) {
+            // Check for file attachments
+            const hasFileAttachments = lastMessage.files?.data?.length > 0;
+
+            // Check if the message appears to be an image
+            const isImageMessage =
+                lastMessage.message?.includes('<img') ||
+                lastMessage.message?.includes('[Image]') ||
+                lastMessage.message?.includes('![') ||
+                (/\.(jpeg|jpg|gif|png|bmp|webp)/i.test(lastMessage.message || '') &&
+                    ((lastMessage.message || '').includes('http') || (lastMessage.message || '').includes('/images/')));
+
+            if (hasFileAttachments) {
+                displayMessage = '📎 File attachment';
+            } else if (isImageMessage) {
+                displayMessage = '[Image]';
+            } else if (lastMessage.message && lastMessage.message.trim() !== '') {
+                displayMessage = lastMessage.message;
+            } else {
+                displayMessage = '(Empty message)';
+            }
         }
-    }
 
-    return (
-        <HStack space={'sm'} className="flex-1 justify-between">
-            <Box className="flex-[0.8]">
-                <Text color={colors.gray[600]} className="text-base text-wrap flex-wrap font-semibold">
-                    {title}
-                </Text>
-                <Text color={colors.gray[600]} numberOfLines={1}>
-                    {displayMessage}
-                </Text>
-            </Box>
-
-            <Box className="flex-[0.2]">
-                <Text color={colors.gray[500]}>{lastMessage ? createdAtText(lastMessage?.createdAt) : ''}</Text>
-            </Box>
-        </HStack>
-    );
-});
+        return (
+            <HStack space={'sm'} className="flex-1 justify-between">
+                <Box className="flex-[0.8]">
+                    <Text color={colors.gray[600]} className="text-base text-wrap flex-wrap font-semibold">
+                        {title}
+                    </Text>
+                    <Text color={colors.gray[600]} numberOfLines={1}>
+                        {displayMessage}
+                    </Text>
+                </Box>
+
+                <Box className="flex-[0.2]">
+                    <Text color={colors.gray[500]}>{lastMessage ? createdAtText(lastMessage?.createdAt) : ''}</Text>
+                </Box>
+            </HStack>
+        );
+    },
+);
 
 /**
  * TODO:
@@ -472,14 +498,19 @@ export const ServiceDialogsListItemComponent: React.FC<IDialogListItemProps> = f
     React.useEffect(() => {
         if (lastMessage) {
             const sParentId = lastMessage?.parentId ? lastMessage?.parentId : lastMessage?.id;
-            safeSend({
-                type: Actions.SET_SERVICE_POST_PARENT_ID,
-                data: {
-                    servicePostParentId: sParentId,
-                },
-            });
+
+            if (sParentId !== safeContextProperty('servicePostParentId')) {
+                console.log(`Updating servicePostParentId for channel ${channel?.id} to:`, sParentId);
+
+                safeSend({
+                    type: Actions.SET_SERVICE_POST_PARENT_ID,
+                    data: {
+                        servicePostParentId: sParentId,
+                    },
+                });
+            }
         }
-    }, [lastMessage, safeSend]);
+    }, [lastMessage, safeSend, channel?.id, safeContextProperty]);
 
     const creatorAndMembersId = React.useMemo(() => {
         if (!channel?.members) return null;
@@ -536,9 +567,16 @@ export const ServiceDialogsListItemComponent: React.FC<IDialogListItemProps> = f
         }
     }, [channel?.id, refetchThreadMessages, safeSend, isMountedRef, role]);
 
-    // Refetch messages when screen is focused or refreshing
+    // Add a timestamp to track when subscriptions were last set up
+    const [subscriptionsTimestamp, setSubscriptionsTimestamp] = useState(Date.now());
+
+    // Reset subscriptions when the component gains focus
     useFocusEffect(
         React.useCallback(() => {
+            // Force subscription refresh
+            setSubscriptionsTimestamp(Date.now());
+
+            // Existing focus effect logic...
             if (!channel?.id) return;
 
             console.log('ServiceDialogsListItem focused for channel:', channel?.id);
@@ -613,6 +651,7 @@ export const ServiceDialogsListItemComponent: React.FC<IDialogListItemProps> = f
                 </Box>
                 <Box className="flex-1">
                     <ServiceChannelWithLastMessage
+                        key={`channel-${channel?.id}-${subscriptionsTimestamp}`}
                         channel={channel}
                         lastMessage={lastMessage}
                         subscribeToNewMessages={() =>
@@ -620,52 +659,200 @@ export const ServiceDialogsListItemComponent: React.FC<IDialogListItemProps> = f
                                 document: THREAD_CHAT_ADDED,
                                 variables: {
                                     channelId: channel?.id?.toString(),
-                                    postParentId: postParentId ? servicePostParentId : null,
+                                    postParentId: postParentId || servicePostParentId || null,
                                 },
                                 updateQuery: (prev, { subscriptionData }: any) => {
-                                    if (!subscriptionData.data) return prev;
-
-                                    const newPostThreadData: any = subscriptionData?.data?.threadCreatedUpdated?.data;
-                                    const newMessage: any = subscriptionData?.data?.threadCreatedUpdated?.lastMessage;
-
-                                    console.log('New thread message subscription update:', {
-                                        channelId: channel?.id,
-                                        threadId: newPostThreadData?.id,
-                                        hasMessage: !!newMessage,
-                                        message: newMessage?.message?.substring(0, 20) + '...',
-                                    });
-
-                                    const data =
-                                        prev?.threadMessages?.data?.map((t: any) =>
-                                            t.id === newPostThreadData?.id
-                                                ? {
-                                                      ...t,
-                                                      replies: [...t?.replies, newMessage],
-                                                      replyCount: newPostThreadData?.replyCount,
-                                                      lastReplyAt: newPostThreadData?.lastReplyAt,
-                                                      updatedAt: newPostThreadData?.updatedAt,
-                                                  }
-                                                : t,
-                                        ) ?? [];
-
-                                    // Use the safe state update function
-                                    if (isMountedRef.current) {
-                                        safeSend({
-                                            type: Actions.UPDATE_THREAD_MESSAGES,
-                                            data: {
-                                                threadMessages: data?.length > 0 ? data : [newPostThreadData],
-                                                directLastMessage: newMessage, // Directly set the new message
-                                            },
+                                    if (!subscriptionData?.data) {
+                                        console.log(`No subscription data for channel ${channel?.id}`);
+                                        return prev;
+                                    }
+
+                                    try {
+                                        const newPostThreadData: any =
+                                            subscriptionData?.data?.threadCreatedUpdated?.data;
+                                        const newMessage: any =
+                                            subscriptionData?.data?.threadCreatedUpdated?.lastMessage;
+
+                                        if (!newPostThreadData || !newMessage) {
+                                            console.log(`Missing data in subscription for channel ${channel?.id}`);
+                                            return prev;
+                                        }
+
+                                        console.log('New thread message subscription update:', {
+                                            channelId: channel?.id,
+                                            threadId: newPostThreadData?.id,
+                                            hasMessage: !!newMessage,
+                                            message: newMessage?.message?.substring(0, 20) + '...',
                                         });
+
+                                        // Create a safe copy of the previous data
+                                        const prevThreads = prev?.threadMessages?.data || [];
+
+                                        // Check if this thread already exists
+                                        const threadExists = prevThreads.some(
+                                            (t: any) => t.id === newPostThreadData?.id,
+                                        );
+
+                                        let updatedThreads;
+                                        if (threadExists) {
+                                            // Update existing thread
+                                            updatedThreads = prevThreads.map((t: any) =>
+                                                t.id === newPostThreadData?.id
+                                                    ? {
+                                                          ...t,
+                                                          replies: [...(t?.replies || []), newMessage],
+                                                          replyCount: newPostThreadData?.replyCount,
+                                                          lastReplyAt: newPostThreadData?.lastReplyAt,
+                                                          updatedAt: newPostThreadData?.updatedAt,
+                                                      }
+                                                    : t,
+                                            );
+                                        } else {
+                                            // Add new thread
+                                            updatedThreads = [...prevThreads, newPostThreadData];
+                                        }
+
+                                        // Use the safe state update function
+                                        if (isMountedRef.current) {
+                                            safeSend({
+                                                type: Actions.UPDATE_THREAD_MESSAGES,
+                                                data: {
+                                                    threadMessages: updatedThreads,
+                                                    directLastMessage: newMessage, // Directly set the new message
+                                                },
+                                            });
+                                        }
+
+                                        return {
+                                            ...prev,
+                                            threadMessages: {
+                                                ...prev?.threadMessages,
+                                                totalCount:
+                                                    newPostThreadData?.totalCount ??
+                                                    prev?.threadMessages?.totalCount ??
+                                                    0,
+                                                data: updatedThreads,
+                                            },
+                                        };
+                                    } catch (error) {
+                                        console.error(
+                                            `Error processing subscription data for channel ${channel?.id}:`,
+                                            error,
+                                        );
+                                        return prev;
+                                    }
+                                },
+                                onError: (error) => {
+                                    console.error(`Thread subscription error for channel ${channel?.id}:`, error);
+                                },
+                            })
+                        }
+                        subscribeToChatMessages={() =>
+                            subscribeToMore({
+                                document: CHAT_MESSAGE_ADDED,
+                                variables: {
+                                    channelId: channel?.id?.toString(),
+                                    postParentId: postParentId || servicePostParentId || null,
+                                },
+                                updateQuery: (prev, { subscriptionData }: any) => {
+                                    if (!subscriptionData?.data) {
+                                        console.log(`No chat message subscription data for channel ${channel?.id}`);
+                                        return prev;
                                     }
 
-                                    return Object.assign({}, prev, {
-                                        threadMessages: {
-                                            ...prev?.threadMessages,
-                                            totalCount: newPostThreadData?.totalCount ?? 0,
-                                            data: data?.length > 0 ? data : [newPostThreadData],
-                                        },
-                                    });
+                                    try {
+                                        const newMessage = subscriptionData?.data?.chatMessageAdded;
+
+                                        if (!newMessage) {
+                                            console.log(
+                                                `Missing chat message data in subscription for channel ${channel?.id}`,
+                                            );
+                                            return prev;
+                                        }
+
+                                        console.log('New chat message subscription update:', {
+                                            channelId: channel?.id,
+                                            messageId: newMessage?.id,
+                                            message: newMessage?.message?.substring(0, 20) + '...',
+                                        });
+
+                                        // Find the thread this message belongs to
+                                        const prevThreads = prev?.threadMessages?.data || [];
+                                        const threadIndex = prevThreads.findIndex((t: any) => {
+                                            // Check if this message belongs to this thread
+                                            if (newMessage.parentId && t.post?.id === newMessage.parentId) {
+                                                return true;
+                                            }
+                                            // Check replies
+                                            if (t.replies && t.replies.some((r: any) => r.id === newMessage.parentId)) {
+                                                return true;
+                                            }
+                                            return false;
+                                        });
+
+                                        if (threadIndex === -1) {
+                                            console.log(
+                                                `Cannot find thread for chat message in channel ${channel?.id}`,
+                                            );
+
+                                            // Even if we can't find the thread, update the UI with the new message
+                                            if (isMountedRef.current) {
+                                                safeSend({
+                                                    type: Actions.UPDATE_THREAD_MESSAGES,
+                                                    data: {
+                                                        directLastMessage: newMessage,
+                                                    },
+                                                });
+                                            }
+
+                                            return prev;
+                                        }
+
+                                        // Update the thread with the new message
+                                        const updatedThreads = [...prevThreads];
+                                        const thread = { ...updatedThreads[threadIndex] };
+
+                                        // Add message to replies
+                                        thread.replies = [...(thread.replies || []), newMessage];
+
+                                        // Fix for arithmetic operation type error
+                                        const currentReplyCount =
+                                            typeof thread.replyCount === 'number' ? thread.replyCount : 0;
+                                        thread.replyCount = currentReplyCount + 1;
+
+                                        thread.lastReplyAt = newMessage.createdAt;
+                                        thread.updatedAt = newMessage.createdAt;
+
+                                        updatedThreads[threadIndex] = thread;
+
+                                        // Use the safe state update function
+                                        if (isMountedRef.current) {
+                                            safeSend({
+                                                type: Actions.UPDATE_THREAD_MESSAGES,
+                                                data: {
+                                                    threadMessages: updatedThreads,
+                                                    directLastMessage: newMessage,
+                                                },
+                                            });
+                                        }
+
+                                        return {
+                                            ...prev,
+                                            threadMessages: {
+                                                ...prev?.threadMessages,
+                                                data: updatedThreads,
+                                            },
+                                        };
+                                    } catch (error) {
+                                        console.error(
+                                            `Error processing chat message subscription for channel ${channel?.id}:`,
+                                            error,
+                                        );
+                                        return prev;
+                                    }
+                                },
+                                onError: (error) => {
+                                    console.error(`Chat message subscription error for channel ${channel?.id}:`, error);
                                 },
                             })
                         }