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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@messenger-box/platform-client",
-    "version": "10.0.3-alpha.7",
+    "version": "10.0.3-alpha.72",
     "description": "Sample core for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -20,8 +20,8 @@
         "watch": "yarn build:lib:watch"
     },
     "dependencies": {
-        "@container-stack/file-info-client": "^5.4.1-alpha.6",
-        "@messenger-box/core": "10.0.3-alpha.7",
+        "@container-stack/file-info-client": "^5.4.1-alpha.9",
+        "@messenger-box/core": "10.0.3-alpha.72",
         "key-mirror": "1.0.1",
         "moment-timezone": "0.5.33"
     },
@@ -35,5 +35,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "6c95ed48d37a8f95b0c3db71c1922c0e9e76bcfe"
+    "gitHead": "b4e54a34578a1a63afbe7ab48644b86e5cc8858f"
 }

package/src/graphql/fragments/post-message.gql

@@ -19,6 +19,18 @@ fragment Post on Post {
     # propsConfiguration {
     #     ...Configuration
     # }
+    propsConfiguration {
+        contents
+        id
+        keys
+        resource
+        target
+        overrides {
+          contents
+          identifiers
+          keys
+        }
+    }
     props
     files {
         totalCount
@@ -58,6 +70,18 @@ fragment PostReplies on Messages {
         # propsConfiguration {
         #     ...Configuration
         # }
+         propsConfiguration {
+            contents
+            id
+            keys
+            resource
+            target
+            overrides {
+            contents
+            identifiers
+            keys
+            }
+        }
         props
         files {
             totalCount
@@ -98,6 +122,18 @@ fragment PostWithoutReplies on Post {
     # propsConfiguration {
     #     ...Configuration
     # }
+     propsConfiguration {
+        contents
+        id
+        keys
+        resource
+        target
+        overrides {
+          contents
+          identifiers
+          keys
+        }
+    }
     props
     files {
         totalCount

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

@@ -1,7 +1,153 @@
-import { TypePolicies } from '@apollo/client';
+import { TypePolicies, gql } from '@apollo/client';
 
 export const channelPolicies: TypePolicies = {
     Query: {
-        fields: {},
+        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/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;
-                // },
             },
         },
     },