@messenger-box/platform-client 10.0.3-alpha.165 → 10.0.3-alpha.171

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

@@ -1,153 +0,0 @@
-import { TypePolicies, gql } from '@apollo/client';
-
-export const channelPolicies: TypePolicies = {
-    Query: {
-        fields: {
-            channelsByUser: {
-                keyArgs: ['role', 'criteria', 'limit', 'skip', 'sort'],
-                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 channelMap = new Map();
-
-                    // Add existing channels to map
-                    for (let i = 0; i < existing.length; i++) {
-                        const channel = existing[i];
-                        if (channel) {
-                            const id = readField('id', channel);
-                            if (id) {
-                                channelMap.set(id, channel);
-                            }
-                        }
-                    }
-
-                    // Merge in incoming channels, overwriting existing ones
-                    for (let i = 0; i < incoming.length; i++) {
-                        const channel = incoming[i];
-                        if (channel) {
-                            const id = readField('id', channel);
-                            if (id) {
-                                channelMap.set(id, channel);
-                            }
-                        }
-                    }
-
-                    // Convert map values back to array
-                    return Array.from(channelMap.values());
-                },
-                // Add a read function for more control over cache reads
-                read(existing, { args }) {
-                    // Return undefined to force a network request if data doesn't exist
-                    if (!existing) return undefined;
-                    return existing;
-                },
-            },
-        },
-    },
-    Channel: {
-        keyFields: ['id'],
-        fields: {
-            members: {
-                merge(existing = [], incoming) {
-                    return incoming;
-                },
-            },
-            // Add field policies for other Channel fields if needed
-            title: {
-                read(title) {
-                    return title || '';
-                },
-            },
-            displayName: {
-                read(displayName) {
-                    return displayName || '';
-                },
-            },
-            // Add computed fields if needed
-            memberCount: {
-                read(_, { readField }) {
-                    const members = readField('members') as any[];
-                    return members && Array.isArray(members) ? members.length : 0;
-                },
-            },
-            lastMessage: {
-                merge(existing, incoming, { readField }) {
-                    // If no incoming message, keep existing
-                    if (!incoming) return existing;
-
-                    // If no existing message, use incoming
-                    if (!existing) return incoming;
-
-                    // Compare timestamps to determine which is newer
-                    const existingCreatedAt = readField('createdAt', existing) as string | number | Date;
-                    const incomingCreatedAt = readField('createdAt', incoming) as string | number | Date;
-
-                    if (existingCreatedAt && incomingCreatedAt) {
-                        // Use the more recent message
-                        return new Date(incomingCreatedAt) > new Date(existingCreatedAt) ? incoming : existing;
-                    }
-
-                    // If timestamps are not available, prefer incoming
-                    return incoming;
-                },
-                read(lastMessage, { readField, cache, args }) {
-                    // If lastMessage is already available, return it
-                    if (lastMessage) return lastMessage;
-
-                    // Try to get the channel ID to reference messages cache
-                    const channelId = readField('id');
-                    if (!channelId) return null;
-
-                    try {
-                        // Read messages from cache for this channel
-                        const messagesQuery = cache.readQuery({
-                            query: gql`
-                                query GetChannelMessages($channelId: String!) {
-                                    messages(channelId: $channelId, skip: 0, limit: 1) {
-                                        data {
-                                            id
-                                            content
-                                            createdAt
-                                            updatedAt
-                                            user {
-                                                id
-                                                username
-                                                displayName
-                                            }
-                                        }
-                                    }
-                                }
-                            `,
-                            variables: { channelId },
-                        }) as any;
-
-                        // Return the first (latest) message if available
-                        return messagesQuery?.messages?.data?.[0] || null;
-                    } catch (error) {
-                        // If messages query fails, return null
-                        return null;
-                    }
-                },
-            },
-        },
-    },
-    // Add policies for ChannelMember type
-    ChannelMember: {
-        keyFields: ['id'],
-        fields: {
-            user: {
-                // Ensure user references are properly merged
-                merge: true,
-            },
-        },
-    },
-};

package/src/graphql/policies/index.ts

@@ -1,7 +0,0 @@
-export * from './posts-policies';
-export * from './user-policies';
-export * from './channel-policies';
-export * from './user-account-policies';
-export * from './messages-policies';
-export * from './post-thread-policies';
-export * from './teams-policies';

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

@@ -1,321 +0,0 @@
-import { TypePolicies } from '@apollo/client';
-
-export const messagesPolicies: TypePolicies = {
-    Messages: {
-        // keyFields: ['messagesRefId'],
-        //keyFields: [],
-        // keyFields: ['data', ['channel', ['id']]],
-        fields: {
-            id: {
-                read(existing, { variables }) {
-                    const { channelId, parentId }: any = variables;
-                    return parentId ? `${channelId}-${parentId}` : `${channelId}`;
-                },
-            },
-            messagesRefId: {
-                read(existing, { variables }) {
-                    const { channelId, parentId }: any = variables;
-                    return parentId ? `${channelId}-${parentId}` : `${channelId}`;
-                },
-            },
-            data: {
-                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);
-                        }
-                    }
-
-                    // 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: ['channelId', 'parentId'],
-                merge(existing, incoming) {
-                    return incoming !== undefined ? incoming : existing;
-                },
-            },
-            // data: {
-            //     merge(existing: any[], incoming: any[], { args }) {
-            //         console.log('existing', JSON.stringify(existing), 'incoming', JSON.stringify(incoming));
-            //         const merged = existing ? existing.slice(0) : [];
-            //         // Insert the incoming elements in the right places, according to args.
-            //         const end = args?.skip + Math.min(args?.limit, incoming.length);
-            //         for (let i = args?.skip; i < end; ++i) {
-            //             merged[i] = incoming[i - args?.skip];
-            //         }
-            //         return merged;
-            //     },
-            // },
-        },
-    },
-    PostThreadMessages: {
-        //  keyFields: ['threadmessagesRefId'],
-        fields: {
-            threadmessagesRefId: {
-                read(existing, { variables }) {
-                    const { channelId, parentId }: any = variables;
-                    return parentId ? `${channelId}-${parentId}` : `${channelId}`;
-                },
-            },
-            id: {
-                read(existing, { variables }) {
-                    const { channelId, parentId }: any = variables;
-                    return parentId ? `${channelId}-${parentId}` : `${channelId}`;
-                },
-            },
-        },
-    },
-    Query: {
-        fields: {
-            messages: {
-                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: 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()),
-                    };
-                },
-            },
-        },
-    },
-};

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

@@ -1,179 +0,0 @@
-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: ['data', ['channel', ['id']]],
-        fields: {
-            data: {
-                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: {
-                merge(existing, incoming) {
-                    // Take the higher of the two counts
-                    return incoming !== undefined ? Math.max(existing || 0, incoming) : existing;
-                },
-            },
-        },
-    },
-    Query: {
-        fields: {
-            threadMessages: {
-                keyArgs: ['channelId'],
-                merge(existing, incoming, { readField }) {
-                    if (!existing) return incoming;
-                    if (!incoming) return existing;
-
-                    return {
-                        ...incoming,
-                        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', 'postParentId', 'role'],
-                merge(existing, incoming, { mergeObjects }) {
-                    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());
-                },
-            },
-        },
-    },
-};