@messenger-box/platform-client 10.0.3-alpha.7 → 10.0.3-alpha.74

package/src/graphql/policies/messages-policies.ts

@@ -19,27 +19,53 @@ export const messagesPolicies: TypePolicies = {
                 },
             },
             data: {
-                keyArgs: false,
-                merge: (existing = [], incoming = [], { readField, mergeObjects }) => {
-                    // console.log('existing', existing);
-                    // console.log('incoming', incoming);
-                    const merged = [...incoming];
-                    const existingIds = existing.map((item) => readField<String>('id', item));
-
-                    merged.forEach((item, index) => {
-                        const itemId = readField<String>('id', item);
-                        const existingIndex = existingIds.findIndex((id) => id === itemId);
-                        if (existingIndex !== -1) {
-                            merged[index] = mergeObjects(existing[existingIndex], merged[index]);
+                keyArgs: ['channelId', 'parentId'],
+                merge: (existing = [], incoming = [], { readField }) => {
+                    // Use a Map for O(1) lookups instead of array iterations
+                    const existingMap = new Map();
+
+                    // Populate map with existing messages
+                    if (existing && existing.length > 0) {
+                        for (let i = 0; i < existing.length; i++) {
+                            const id = readField('id', existing[i]);
+                            if (id) {
+                                existingMap.set(id, existing[i]);
+                            }
+                        }
+                    }
+
+                    // Create result array with same capacity as total items
+                    const result = [];
+
+                    // Add incoming items, overwriting existing ones
+                    if (incoming && incoming.length > 0) {
+                        for (let i = 0; i < incoming.length; i++) {
+                            const item = incoming[i];
+                            const id = readField('id', item);
+                            if (id) {
+                                existingMap.set(id, item);
+                            }
+                            result.push(item);
                         }
-                    });
-                    return merged;
+                    }
+
+                    // Add remaining existing items not in incoming
+                    if (existing && existing.length > 0) {
+                        for (let i = 0; i < existing.length; i++) {
+                            const id = readField('id', existing[i]);
+                            if (id && !result.some((item) => readField('id', item) === id)) {
+                                result.push(existing[i]);
+                            }
+                        }
+                    }
+
+                    return result;
                 },
             },
             totalCount: {
-                keyArgs: false,
+                keyArgs: ['channelId', 'parentId'],
                 merge(existing, incoming) {
-                    return existing && existing > incoming ? existing : incoming;
+                    return incoming !== undefined ? incoming : existing;
                 },
             },
             // data: {
@@ -57,7 +83,7 @@ export const messagesPolicies: TypePolicies = {
         },
     },
     PostThreadMessages: {
-      //  keyFields: ['threadmessagesRefId'],
+        //  keyFields: ['threadmessagesRefId'],
         fields: {
             threadmessagesRefId: {
                 read(existing, { variables }) {
@@ -76,33 +102,219 @@ export const messagesPolicies: TypePolicies = {
     Query: {
         fields: {
             messages: {
-                // keyArgs: ['channelId', 'parentId', 'limit', 'skip'],
-                // keyArgs: ['channelId', 'parentId'],
+                keyArgs: ['channelId', 'parentId'],
+                merge(existing, incoming, { args, readField }) {
+                    if (!incoming) return existing;
+                    if (!existing) return incoming;
+
+                    // Fast return if incoming has no data
+                    if (!incoming.data || incoming.data.length === 0) {
+                        return {
+                            ...existing,
+                            totalCount: incoming.totalCount ?? existing.totalCount,
+                        };
+                    }
+
+                    // Fast return if existing has no data
+                    if (!existing.data || existing.data.length === 0) {
+                        return incoming;
+                    }
+
+                    // Determine if this is likely a new message or pagination
+                    const isNewMessage = args && args.skip === 0;
+
+                    // Create a map for existing messages for fast lookups
+                    const idSet = new Set();
+                    const mergedData = [...existing.data];
+
+                    // Mark all existing IDs
+                    for (let i = 0; i < mergedData.length; i++) {
+                        const id = readField('id', mergedData[i]);
+                        if (id) idSet.add(id);
+                    }
+
+                    // Process incoming messages
+                    for (let i = 0; i < incoming.data.length; i++) {
+                        const incomingMsg = incoming.data[i];
+                        const id = readField('id', incomingMsg);
+
+                        if (!id) continue;
+
+                        if (idSet.has(id)) {
+                            // Replace existing message with same ID
+                            const existingIndex = mergedData.findIndex((msg) => readField('id', msg) === id);
+                            if (existingIndex >= 0) {
+                                mergedData[existingIndex] = incomingMsg;
+                            }
+                        } else {
+                            // Add new message
+                            if (isNewMessage) {
+                                // Add to beginning for new messages
+                                mergedData.unshift(incomingMsg);
+                            } else {
+                                // Add to end for pagination
+                                mergedData.push(incomingMsg);
+                            }
+                            idSet.add(id);
+                        }
+                    }
+
+                    return {
+                        ...existing,
+                        totalCount: incoming.totalCount ?? existing.totalCount,
+                        data: mergedData,
+                    };
+                },
+            },
+        },
+    },
+    FilesInfo: {
+        merge: true, // Use default merging behavior for FilesInfo
+        fields: {
+            data: {
+                merge(existing = [], incoming = [], { readField }) {
+                    // If no existing data, just return incoming
+                    if (!existing || existing.length === 0) {
+                        return incoming;
+                    }
+
+                    // If no incoming data, keep existing
+                    if (!incoming || incoming.length === 0) {
+                        return existing;
+                    }
+
+                    // Create a map for efficient lookup
+                    const fileMap = new Map();
+
+                    // Add existing files to map
+                    for (let i = 0; i < existing.length; i++) {
+                        const file = existing[i];
+                        if (file) {
+                            const id = readField('id', file);
+                            if (id) {
+                                fileMap.set(id, file);
+                            }
+                        }
+                    }
+
+                    // Merge in incoming files, overwriting existing ones
+                    for (let i = 0; i < incoming.length; i++) {
+                        const file = incoming[i];
+                        if (file) {
+                            const id = readField('id', file);
+                            if (id) {
+                                fileMap.set(id, file);
+                            }
+                        }
+                    }
+
+                    // Convert map values back to array
+                    return Array.from(fileMap.values());
+                },
+            },
+        },
+    },
+    FileInfo: {
+        // Use ID as key field
+        keyFields: ['id'],
+        fields: {
+            url: {
+                // Ensure URL is always preserved and not normalized
                 merge(existing, incoming) {
+                    return incoming ?? existing;
+                },
+            },
+        },
+    },
+    Post: {
+        fields: {
+            replies: {
+                merge(existing, incoming) {
+                    if (!incoming) return existing;
+                    if (!existing) return incoming;
+
+                    // Use a Set for fast duplicate checking
+                    const uniqueIds = new Set();
+                    const mergedData = [];
+
+                    // Add all existing items to the result and track IDs
+                    if (existing.data && existing.data.length > 0) {
+                        for (let i = 0; i < existing.data.length; i++) {
+                            const item = existing.data[i];
+                            if (item && item.id && !uniqueIds.has(item.id)) {
+                                uniqueIds.add(item.id);
+                                mergedData.push(item);
+                            }
+                        }
+                    }
+
+                    // Add incoming items that don't exist yet
+                    if (incoming.data && incoming.data.length > 0) {
+                        for (let i = 0; i < incoming.data.length; i++) {
+                            const item = incoming.data[i];
+                            if (item && item.id && !uniqueIds.has(item.id)) {
+                                uniqueIds.add(item.id);
+                                mergedData.push(item);
+                            }
+                        }
+                    }
+
                     return {
                         ...incoming,
-                        data: [...(existing?.data ?? []), ...(incoming.data ?? [])],
+                        data: mergedData,
+                    };
+                },
+            },
+            files: {
+                merge(existing, incoming, { readField }) {
+                    if (!incoming) return existing;
+                    if (!existing) return incoming;
+
+                    // If either has no data or totalCount is 0, prefer the one with data
+                    if (!existing.data || existing.data.length === 0) {
+                        return incoming;
+                    }
+
+                    if (!incoming.data || incoming.data.length === 0) {
+                        return existing;
+                    }
+
+                    // Create a map for efficient lookup
+                    const fileMap = new Map();
+
+                    // Add existing files to map
+                    if (existing.data) {
+                        for (let i = 0; i < existing.data.length; i++) {
+                            const file = existing.data[i];
+                            if (file) {
+                                const id = readField('id', file);
+                                if (id) {
+                                    fileMap.set(id, file);
+                                }
+                            }
+                        }
+                    }
+
+                    // Merge in incoming files, overwriting existing ones
+                    if (incoming.data) {
+                        for (let i = 0; i < incoming.data.length; i++) {
+                            const file = incoming.data[i];
+                            if (file) {
+                                const id = readField('id', file);
+                                if (id) {
+                                    fileMap.set(id, file);
+                                }
+                            }
+                        }
+                    }
+
+                    // Create merged result
+                    return {
+                        __typename: 'FilesInfo',
+                        totalCount: Math.max(existing.totalCount || 0, incoming.totalCount || 0, fileMap.size),
+                        data: Array.from(fileMap.values()),
                     };
                 },
-                // merge(existing, incoming, { args, mergeObjects }) {
-                //     console.log('existing length', existing?.data?.length);
-                //     console.log('incoming length', incoming?.data?.length);
-                //     // console.log('existing', JSON.stringify(existing), 'incoming', JSON.stringify(incoming));
-                //     if (!incoming || incoming?.data?.length) return existing;
-                //     if (!existing || existing?.data?.length) return incoming;
-                //     //console.log('existing', JSON.stringify(existing), 'incoming', JSON.stringify(incoming));
-                //     const mergedData = existing ? existing?.data?.slice(0) : [];
-                //     // Insert the incoming elements in the right places, according to args.
-                //     const end = args?.skip + Math.min(args?.limit, incoming?.data?.length);
-                //     for (let i = args?.skip; i < end; ++i) {
-                //         mergedData[i] = incoming?.data[i - args?.skip];
-                //     }
-
-                //     const merged = { ...incoming, data: mergedData };
-                //     return merged;
-                //     // return mergeObjects(existing, incoming);
-                //     //return existing ? { ...existing, ...incoming } : incoming;
-                // },
             },
         },
     },

package/src/graphql/policies/post-thread-policies.ts

@@ -1,57 +1,177 @@
 import { TypePolicies } from '@apollo/client';
+import { gql } from '@apollo/client';
+
+// Define the fragment we'll use for cache operations
+const POST_THREAD_FRAGMENT = gql`
+    fragment PostThreadInfo on PostThread {
+        replies
+        replyCount
+        lastReplyAt
+        updatedAt
+    }
+`;
 
 export const postThreadPolicies: TypePolicies = {
     ThreadMessages: {
-        // keyFields: ['messagesRefId'],
-        //keyFields: [],
         keyFields: ['data', ['channel', ['id']]],
         fields: {
             data: {
-                // keyArgs: false,
-                // merge: (existing = [], incoming = [], { readField, mergeObjects }) => {
-                //     return existing ? [...existing, ...incoming] : incoming;
-                //     // console.log('existing', existing);
-                //     // console.log('incoming', incoming);
-                //     // const merged = [...incoming];
-                //     // const existingIds = existing.map((item) => readField<String>('id', item));
-                //     // merged.forEach((item, index) => {
-                //     //     const itemId = readField<String>('id', item);
-                //     //     const existingIndex = existingIds.findIndex((id) => id === itemId);
-                //     //     if (existingIndex !== -1) {
-                //     //         merged[index] = mergeObjects(existing[existingIndex], merged[index]);
-                //     //     }
-                //     // });
-                //     // return merged;
-                // },
+                merge: (existing = [], incoming = [], { readField }) => {
+                    // Create a map for efficient lookups
+                    const threadMap = new Map();
+
+                    // Store existing threads
+                    if (existing && existing.length > 0) {
+                        for (const item of existing) {
+                            const id = readField('id', item);
+                            if (id) threadMap.set(id, item);
+                        }
+                    }
+
+                    // Add or update with incoming threads
+                    if (incoming && incoming.length > 0) {
+                        for (const item of incoming) {
+                            const id = readField('id', item);
+                            if (id) threadMap.set(id, item);
+                        }
+                    }
+
+                    // Convert back to array
+                    return Array.from(threadMap.values());
+                },
             },
             totalCount: {
-                // keyArgs: false,
-                // merge(existing, incoming) {
-                //     return existing && existing > incoming ? existing : incoming;
-                // },
+                merge(existing, incoming) {
+                    // Take the higher of the two counts
+                    return incoming !== undefined ? Math.max(existing || 0, incoming) : existing;
+                },
             },
         },
     },
     Query: {
         fields: {
             threadMessages: {
-                // keyArgs: ['channelId', 'parentId', 'limit', 'skip'],
                 keyArgs: ['channelId'],
-                //keyArgs: false,
-                merge(existing, incoming) {
-                    //  debugger;
+                merge(existing, incoming, { readField }) {
+                    if (!existing) return incoming;
+                    if (!incoming) return existing;
+
                     return {
                         ...incoming,
-                        data: [...(existing?.data ?? []), ...(incoming.data ?? [])],
+                        data: [...(existing?.data || []), ...(incoming.data || [])].filter(
+                            (item, index, self) =>
+                                // Filter out duplicates
+                                index === self.findIndex((t) => readField('id', t) === readField('id', item)),
+                        ),
                     };
                 },
             },
             getPostThread: {
-                // keyArgs: ['channelId', 'parentId', 'limit', 'skip'],
-                keyArgs: ['channelId', 'postParentId', 'limit', 'skip', 'role'],
+                keyArgs: ['channelId', 'postParentId', 'role'],
                 merge(existing, incoming, { mergeObjects }) {
-                    //  debugger;
-                    return mergeObjects(existing, incoming);
+                    if (!existing) return incoming;
+                    if (!incoming) return existing;
+
+                    // Carefully merge the two objects
+                    const result = mergeObjects(existing, incoming);
+
+                    // Special handling for replies to avoid duplicates
+                    if (existing.replies && incoming.replies) {
+                        const uniqueReplies = new Map();
+
+                        // Add existing replies
+                        for (const reply of existing.replies) {
+                            uniqueReplies.set(reply.id, reply);
+                        }
+
+                        // Add incoming replies, overwriting existing ones
+                        for (const reply of incoming.replies) {
+                            uniqueReplies.set(reply.id, reply);
+                        }
+
+                        // Replace replies with deduplicated list
+                        result.replies = Array.from(uniqueReplies.values());
+                    }
+
+                    return result;
+                },
+            },
+        },
+    },
+    // Mutation: {
+    //     fields: {
+    //         createPostThread: {
+    //             merge(existing, incoming, { cache, args, readField }) {
+    //                 // Early return if not enough data
+    //                 if (!incoming?.lastMessage || !incoming?.data || !args?.channelId || !args?.postParentId) {
+    //                     return incoming;
+    //                 }
+
+    //                 try {
+    //                     // Use type policies to handle the cache update instead of direct manipulation
+    //                     const queryRef = cache.identify({
+    //                         __typename: 'Query',
+    //                         getPostThread: {
+    //                             channelId: args.channelId,
+    //                             postParentId: args.postParentId,
+    //                             role: args.threadMessageInput?.role
+    //                         }
+    //                     });
+
+    //                     // Use cache.modify which doesn't require fragments
+    //                     if (queryRef) {
+    //                         cache.modify({
+    //                             id: queryRef,
+    //                             fields: {
+    //                                 getPostThread(existingThread = {}) {
+    //                                     if (!existingThread) return existingThread;
+
+    //                                     // Create a new object with the updated properties
+    //                                     return {
+    //                                         ...existingThread,
+    //                                         replies: [incoming.lastMessage, ...(existingThread.replies || [])],
+    //                                         replyCount: (existingThread.replyCount || 0) + 1,
+    //                                         lastReplyAt: incoming.lastMessage.createdAt,
+    //                                         updatedAt: incoming.lastMessage.createdAt
+    //                                     };
+    //                                 }
+    //                             }
+    //                         });
+    //                     }
+    //                 } catch (error) {
+    //                     console.error('Error updating cache in createPostThread policy:', error);
+    //                 }
+
+    //                 return incoming;
+    //             },
+    //         },
+    //     },
+    // },
+    PostThread: {
+        fields: {
+            replies: {
+                merge(existing = [], incoming = [], { readField }) {
+                    // Use a map for fast deduplication
+                    const replyMap = new Map();
+
+                    // Add existing replies
+                    if (existing && existing.length > 0) {
+                        for (const reply of existing) {
+                            const id = readField('id', reply);
+                            if (id) replyMap.set(id, reply);
+                        }
+                    }
+
+                    // Add or update with incoming replies
+                    if (incoming && incoming.length > 0) {
+                        for (const reply of incoming) {
+                            const id = readField('id', reply);
+                            if (id) replyMap.set(id, reply);
+                        }
+                    }
+
+                    // Convert back to array
+                    return Array.from(replyMap.values());
                 },
             },
         },

package/src/graphql/policies/teams-policies.ts

@@ -2,6 +2,18 @@ import { TypePolicies } from '@apollo/client';
 
 export const teamPolicies: TypePolicies = {
     Query: {
-        fields: {},
+        fields: {
+            getOrganizationTeams: {
+                merge(existing = [], incoming) {
+                    return incoming;
+                },
+                read(existing) {
+                    return existing;
+                },
+            },
+        },
+    },
+    AccountTeam: {
+        keyFields: ['_id'],
     },
 };

package/src/graphql/queries/channels-by-user.gql

@@ -14,6 +14,32 @@ query GetChannelsByUser($role: String, $criteria: AnyObject, $limit: Int, $skip:
         creator {
             ...MessengerUser
         }
+        lastPostAt
+        createdAt
+        updatedAt
+    }
+}
+
+
+query GetChannelsByUserWithLastMessage($role: String, $criteria: AnyObject, $limit: Int, $skip: Int, $sort: Sort) {
+    channelsByUser(role: $role, criteria: $criteria, limit: $limit, skip: $skip, sort: $sort) {
+        id
+        title
+        description
+        type
+        displayName
+        members {
+            id
+            user {
+                ...MessengerUser
+            }
+        }
+        creator {
+            ...MessengerUser
+        }
+        lastMessage {
+            ...Post
+        }
         createdAt
         updatedAt
     }

package/src/graphql/queries/messages.gql

@@ -1,5 +1,5 @@
-query Messages($channelId: ID,$parentId: String, $limit: Int! = 10, $skip: Int! = 0, $sort: Sort) {
-    messages(channelId: $channelId,parentId:$parentId, limit: $limit, skip: $skip, sort: $sort) @connection(key: "messages", filter: ["channelId","skip"]){
+query Messages($channelId: ID,$parentId: String, $limit: Int! = 10, $skip: Int! = 0, $sort: Sort, $props: AnyObject) {
+    messages(channelId: $channelId,parentId:$parentId, limit: $limit, skip: $skip, sort: $sort, props: $props) @connection(key: "messages", filter: ["channelId","skip"]){
         messagesRefId @client
         data{
             ...Post