@messenger-box/platform-server 10.0.3-alpha.50 → 10.0.3-alpha.54

package/lib/graphql/resolvers/post.js

@@ -9,140 +9,287 @@ const postResolvers = options => ({
     }, args, {
       fileInfoService
     }) => {
-      const basePath = fileInfoService.awsS3Service.basePath || 'aws';
-      if (!url.includes(basePath)) {
-        return url;
+      options.logger.trace('(FileInfo.url) url [%s]', url);
+      try {
+        if (!url) {
+          options.logger.warn('Missing URL in FileInfo');
+          return null;
+        }
+        const basePath = fileInfoService.awsS3Service.basePath || 'aws';
+        if (!url.includes(basePath)) {
+          return url;
+        }
+        return fileInfoService.getResizedImage(url, {
+          width: undefined,
+          height: undefined
+        });
+      } catch (error) {
+        options.logger.error('Error getting FileInfo URL: %o', error);
+        return url; // Fallback to original URL
       }
-      return fileInfoService.getResizedImage(url, {
-        width: undefined,
-        height: undefined
-      });
     },
     extension(src) {
-      return src.mimeType.split('/')[1];
+      options.logger.trace('(FileInfo.extension) mimeType [%s]', src?.mimeType);
+      try {
+        if (!src?.mimeType || typeof src.mimeType !== 'string') {
+          options.logger.warn('Missing or invalid mimeType in FileInfo');
+          return null;
+        }
+        const parts = src.mimeType.split('/');
+        return parts.length > 1 ? parts[1] : null;
+      } catch (error) {
+        options.logger.error('Error getting FileInfo extension: %o', error);
+        return null;
+      }
     }
   },
   Post: {
     editedBy(src, args, {
       accountService
     }) {
-      return src?.editedBy ? accountService.findAccountById(src.editedBy.toString()) : null;
+      options.logger.trace('(Post.editedBy) editedBy [%s]', src?.editedBy);
+      try {
+        if (!src?.editedBy) {
+          return null;
+        }
+        return accountService.findAccountById(src.editedBy.toString());
+      } catch (error) {
+        options.logger.error('Error getting Post editedBy: %o', error);
+        return null;
+      }
     },
     deletedBy(src, args, {
       accountService
     }) {
-      return src?.deletedBy ? accountService.findAccountById(src?.deletedBy.toString()) : null;
+      options.logger.trace('(Post.deletedBy) deletedBy [%s]', src?.deletedBy);
+      try {
+        if (!src?.deletedBy) {
+          return null;
+        }
+        return accountService.findAccountById(src.deletedBy.toString());
+      } catch (error) {
+        options.logger.error('Error getting Post deletedBy: %o', error);
+        return null;
+      }
     },
     author(src, args, {
       accountService
     }) {
-      const author = src.author?.toString();
-      if (author) {
-        return accountService.findAccountById(author);
+      options.logger.trace('(Post.author) author [%s], editedBy [%s]', src?.author, src?.editedBy);
+      try {
+        const author = src?.author?.toString();
+        if (author) {
+          return accountService.findAccountById(author);
+        }
+        // Fallback to editedBy if author is not available
+        if (src?.editedBy) {
+          return accountService.findAccountById(src.editedBy.toString());
+        }
+        return null;
+      } catch (error) {
+        options.logger.error('Error getting Post author: %o', error);
+        return null;
       }
-      return src?.editedBy ? accountService.findAccountById(src.editedBy.toString()) : null;
     },
     channel(src, args, {
       channelService
     }) {
-      return channelService.get(src.channel.toString());
+      options.logger.trace('(Post.channel) channel [%s]', src?.channel);
+      try {
+        if (!src?.channel) {
+          options.logger.warn('Missing channel in Post');
+          return null;
+        }
+        return channelService.get(src.channel.toString());
+      } catch (error) {
+        options.logger.error('Error getting Post channel: %o', error);
+        return null;
+      }
     },
     props(src, _, {
       userContext
     }) {
-      return src?.props?.[`[${userContext.accountId}]`];
+      options.logger.trace('(Post.props) accountId [%s]', userContext?.accountId);
+      try {
+        if (!userContext?.accountId || !src?.props) {
+          return null;
+        }
+        return src.props[`[${userContext.accountId}]`] || null;
+      } catch (error) {
+        options.logger.error('Error getting Post props: %o', error);
+        return null;
+      }
     },
     isRead(src, _, {
       userContext
     }) {
-      return get(src?.props?.[`[${userContext.accountId}]`], `messenger.posts.isRead`);
+      options.logger.trace('(Post.isRead) accountId [%s]', userContext?.accountId);
+      try {
+        if (!userContext?.accountId || !src?.props) {
+          return false;
+        }
+        return get(src.props[`[${userContext.accountId}]`], 'messenger.posts.isRead', false);
+      } catch (error) {
+        options.logger.error('Error getting Post isRead: %o', error);
+        return false;
+      }
     },
     isDelivered(src, _, {
       userContext
     }) {
-      return get(src?.props?.[`[${userContext.accountId}]`], `messenger.posts.isDelivered`);
+      options.logger.trace('(Post.isDelivered) accountId [%s]', userContext?.accountId);
+      try {
+        if (!userContext?.accountId || !src?.props) {
+          return false;
+        }
+        return get(src.props[`[${userContext.accountId}]`], 'messenger.posts.isDelivered', false);
+      } catch (error) {
+        options.logger.error('Error getting Post isDelivered: %o', error);
+        return false;
+      }
     },
     async propsConfiguration(src, args, {
       configurationService,
       userContext
     }) {
-      //const resource = generateUri('messenger' as any, { _id: src.id }, 'props');
-      const {
-        orgName
-      } = userContext;
-      console.log('---orgName---', orgName);
-      const resource = generateResourceUri('messenger', {
-        _id: src.id,
-        orgName: orgName
-      }, 'props', DEFAULT_TENANT_ID, {
-        scheme: Scheme.CDECODE_RESOURCE
-      });
-      let data = '{}';
+      options.logger.trace('(Post.propsConfiguration) postId [%s], orgName [%s]', src?.id, userContext?.orgName);
       try {
-        data = JSON.stringify(src.props);
-      } catch (err) {
-        console.log('---Errr---', err);
-      }
-      // console.log('---data---', data);
-      const nodeContext = buildNodeContext(userContext);
-      const machineModel = await configurationService.parser(resource.toString(), data, nodeContext, null, false);
-      // console.log('--Resourfe MODEL', machineModel);
-      if (machineModel instanceof Error) {
-        throw machineModel;
+        if (!src?.id || !userContext?.orgName) {
+          options.logger.warn('Missing required data for propsConfiguration');
+          throw new Error('Missing post ID or organization name');
+        }
+        const {
+          orgName
+        } = userContext;
+        options.logger.debug('Processing propsConfiguration for orgName: %s', orgName);
+        const resource = generateResourceUri('messenger', {
+          _id: src.id,
+          orgName: orgName
+        }, 'props', DEFAULT_TENANT_ID, {
+          scheme: Scheme.CDECODE_RESOURCE
+        });
+        let data = '{}';
+        try {
+          data = JSON.stringify(src.props || {});
+        } catch (err) {
+          options.logger.warn('Error serializing props data: %o', err);
+          data = '{}';
+        }
+        const nodeContext = buildNodeContext(userContext);
+        const machineModel = await configurationService.parser(resource.toString(), data, nodeContext, null, false);
+        if (machineModel instanceof Error) {
+          options.logger.error('Error parsing configuration: %o', machineModel);
+          throw machineModel;
+        }
+        return {
+          resource,
+          contents: machineModel.contents,
+          overrides: machineModel.overrides,
+          keys: machineModel.keys,
+          __typename: ClientCacheTypeNames.MachineConfiguration
+        };
+      } catch (error) {
+        options.logger.error('Error getting Post propsConfiguration: %o', error);
+        throw error;
       }
-      return {
-        resource,
-        contents: machineModel.contents,
-        overrides: machineModel.overrides,
-        keys: machineModel.keys,
-        __typename: ClientCacheTypeNames.MachineConfiguration
-      };
     },
     async files(src, args, {
       fileInfoService
     }) {
-      const {
-        data,
-        totalCount
-      } = await fileInfoService.getAllWithCount({
-        ...args,
-        criteria: {
-          ...args.criteria,
-          refType: 'Post',
-          ref: src.id
-        }
-      });
-      return {
-        data: data.map(({
+      options.logger.trace('(Post.files) postId [%s], args [%j]', src?.id, args);
+      try {
+        if (!src?.id) {
+          options.logger.warn('Missing post ID for files');
+          return {
+            data: [],
+            totalCount: 0
+          };
+        }
+        if (!fileInfoService) {
+          options.logger.warn('FileInfoService not available');
+          return {
+            data: [],
+            totalCount: 0
+          };
+        }
+        const {
+          data,
+          totalCount
+        } = await fileInfoService.getAllWithCount({
+          ...args,
+          criteria: {
+            ...args.criteria,
+            refType: 'Post',
+            ref: src.id
+          }
+        });
+        const processedData = data.map(({
           url,
           ...rest
         }) => ({
           ...rest,
           url: fileInfoService.getThumbnailImage(url)
-        })),
-        totalCount
-      };
+        }));
+        options.logger.debug('Retrieved %d files for post %s', processedData.length, src.id);
+        return {
+          data: processedData,
+          totalCount
+        };
+      } catch (error) {
+        options.logger.error('Error getting Post files: %o', error);
+        return {
+          data: [],
+          totalCount: 0
+        };
+      }
     },
     async replies(src, args, {
       postService
     }) {
-      const {
-        data,
-        totalCount
-      } = (await postService?.getAllWithCount({
-        criteria: {
-          channel: src.channel.toString(),
-          parentId: src?.id.toString()
-        },
-        sort: {
-          key: 'createdAt',
-          value: SortEnum.Desc
+      options.logger.trace('(Post.replies) postId [%s], channelId [%s]', src?.id, src?.channel);
+      try {
+        if (!src?.id || !src?.channel) {
+          options.logger.warn('Missing post ID or channel for replies');
+          return {
+            data: [],
+            totalCount: 0
+          };
         }
-      })) ?? [];
-      return {
-        totalCount,
-        data
-      };
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          return {
+            data: [],
+            totalCount: 0
+          };
+        }
+        const {
+          data,
+          totalCount
+        } = (await postService?.getAllWithCount({
+          criteria: {
+            channel: src.channel.toString(),
+            parentId: src.id.toString()
+          },
+          sort: {
+            key: 'createdAt',
+            value: SortEnum.Desc
+          }
+        })) ?? {
+          data: [],
+          totalCount: 0
+        };
+        options.logger.debug('Retrieved %d replies for post %s', totalCount, src.id);
+        return {
+          totalCount,
+          data
+        };
+      } catch (error) {
+        options.logger.error('Error getting Post replies: %o', error);
+        return {
+          data: [],
+          totalCount: 0
+        };
+      }
     }
   },
   Query: {
@@ -156,26 +303,45 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      const sortBy = sort || {
-        key: 'createdAt',
-        value: SortEnum.Desc
-      };
-      const {
-        data,
-        totalCount
-      } = await postService.getAllWithCount({
-        criteria: {
-          channel: channelId,
-          parentId
-        },
-        limit,
-        skip,
-        sort: sortBy
-      });
-      return {
-        totalCount,
-        data
-      };
+      options.logger.trace('(Query.messages) channelId [%s], parentId [%s], limit [%d], skip [%d]', channelId, parentId, limit, skip);
+      try {
+        if (!channelId) {
+          options.logger.warn('Missing channelId in messages query');
+          throw new Error('Channel ID is required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context in messages query');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        const sortBy = sort || {
+          key: 'createdAt',
+          value: SortEnum.Desc
+        };
+        const {
+          data,
+          totalCount
+        } = await postService.getAllWithCount({
+          criteria: {
+            channel: channelId,
+            parentId
+          },
+          limit,
+          skip,
+          sort: sortBy
+        });
+        options.logger.debug('Retrieved %d messages for channel %s', totalCount, channelId);
+        return {
+          totalCount,
+          data
+        };
+      } catch (error) {
+        options.logger.error('Error in messages query: %o', error);
+        throw error;
+      }
     },
     async publicMessages(src, {
       channelId
@@ -183,23 +349,38 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      const {
-        data,
-        totalCount
-      } = await postService.getAllWithCount({
-        criteria: {
-          channel: channelId,
-          type: PostTypeEnum.Public
-        },
-        sort: {
-          key: 'createdAt',
-          value: SortEnum.Desc
+      options.logger.trace('(Query.publicMessages) channelId [%s]', channelId);
+      try {
+        if (!channelId) {
+          options.logger.warn('Missing channelId in publicMessages query');
+          throw new Error('Channel ID is required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
         }
-      });
-      return {
-        totalCount,
-        data
-      };
+        const {
+          data,
+          totalCount
+        } = await postService.getAllWithCount({
+          criteria: {
+            channel: channelId,
+            type: PostTypeEnum.Public
+          },
+          sort: {
+            key: 'createdAt',
+            value: SortEnum.Desc
+          }
+        });
+        options.logger.debug('Retrieved %d public messages for channel %s', totalCount, channelId);
+        return {
+          totalCount,
+          data
+        };
+      } catch (error) {
+        options.logger.error('Error in publicMessages query: %o', error);
+        throw error;
+      }
     }
   },
   Mutation: {
@@ -208,14 +389,29 @@ const postResolvers = options => ({
     }, {
       postService
     }) {
-      const {
-        channelId,
-        messageId: id
-      } = messageId;
-      return postService.delete({
-        channel: channelId,
-        id
-      });
+      options.logger.trace('(Mutation.deleteMessage) messageId [%j]', messageId);
+      try {
+        if (!messageId?.channelId || !messageId?.messageId) {
+          options.logger.warn('Missing required messageId parameters');
+          throw new Error('Channel ID and Message ID are required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        const {
+          channelId,
+          messageId: id
+        } = messageId;
+        options.logger.debug('Deleting message %s from channel %s', id, channelId);
+        return postService.delete({
+          channel: channelId,
+          id
+        });
+      } catch (error) {
+        options.logger.error('Error deleting message: %o', error);
+        throw error;
+      }
     },
     editMessage(src, {
       messageId,
@@ -224,12 +420,35 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      return postService.update(messageId.messageId, {
-        message: messageInput.content,
-        editedBy: userContext.accountId,
-        channel: messageId.channelId,
-        files: messageInput.files
-      });
+      options.logger.trace('(Mutation.editMessage) messageId [%j], content length [%d]', messageId, messageInput?.content?.length || 0);
+      try {
+        if (!messageId?.messageId || !messageId?.channelId) {
+          options.logger.warn('Missing required messageId parameters');
+          throw new Error('Message ID and Channel ID are required');
+        }
+        if (!messageInput?.content) {
+          options.logger.warn('Missing message content');
+          throw new Error('Message content is required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        options.logger.debug('Editing message %s in channel %s', messageId.messageId, messageId.channelId);
+        return postService.update(messageId.messageId, {
+          message: messageInput.content,
+          editedBy: userContext.accountId,
+          channel: messageId.channelId,
+          files: messageInput.files
+        });
+      } catch (error) {
+        options.logger.error('Error editing message: %o', error);
+        throw error;
+      }
     },
     async sendMessage(src, {
       channelId,
@@ -239,30 +458,34 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      const {
-        content,
-        files,
-        createdBy,
-        notificationParams
-      } = messageInput;
-      const {
-        accountId
-      } = userContext;
-      let post;
-      if (postId) {
-        post = await postService.create({
-          _id: postId,
-          channel: channelId,
-          message: content,
-          editedBy: createdBy || accountId,
-          author: createdBy || accountId,
+      options.logger.trace('(Mutation.sendMessage) channelId [%s], postId [%s], content length [%d]', channelId, postId, messageInput?.content?.length || 0);
+      try {
+        if (!channelId) {
+          options.logger.warn('Missing channelId');
+          throw new Error('Channel ID is required');
+        }
+        if (!messageInput?.content) {
+          options.logger.warn('Missing message content');
+          throw new Error('Message content is required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        const {
+          content,
           files,
-          props: notificationParams ? {
-            notificationParams
-          } : undefined
-        });
-      } else {
-        post = await postService.create({
+          createdBy,
+          notificationParams
+        } = messageInput;
+        const {
+          accountId
+        } = userContext;
+        const postData = {
           channel: channelId,
           message: content,
           editedBy: createdBy || accountId,
@@ -271,17 +494,24 @@ const postResolvers = options => ({
           props: notificationParams ? {
             notificationParams
           } : undefined
-        });
+        };
+        let post;
+        if (postId) {
+          options.logger.debug('Creating message with specific ID %s', postId);
+          post = await postService.create({
+            _id: postId,
+            ...postData
+          });
+        } else {
+          options.logger.debug('Creating new message in channel %s', channelId);
+          post = await postService.create(postData);
+        }
+        options.logger.debug('Message created successfully with ID %s', post?.id || post?._id);
+        return post;
+      } catch (error) {
+        options.logger.error('Error sending message: %o', error);
+        throw error;
       }
-      // const post = await postService.create({
-      //     channel: channelId as any,
-      //     message: content,
-      //     editedBy: accountId as any,
-      //     author: accountId as any,
-      //     files,
-      // });
-      // options.pubsub.publish(`POST_CREATED.${channelId}`, post);
-      return post;
     },
     async sendPublicMessage(src, {
       channelId,
@@ -292,46 +522,71 @@ const postResolvers = options => ({
       channelService,
       userContext
     }) {
-      const {
-        content,
-        files,
-        createdBy
-      } = messageInput;
-      const {
-        accountId
-      } = userContext;
-      let post = null;
-      const channelExits = await channelService.get(channelId);
-      if (!channelExits) {
-        const channel = await channelService.savePublicChannel({
-          _id: channelId,
-          type: RoomType.Public,
-          title: `public-channel-${channelId}`
-        });
-        if (channel) {
-          post = await postService.createWithoutSubscription({
-            _id: postId || undefined,
-            channel: channelId,
-            message: content,
-            editedBy: createdBy || accountId,
-            author: createdBy || accountId,
-            files,
-            type: PostTypeEnum.Public
+      options.logger.trace('(Mutation.sendPublicMessage) channelId [%s], postId [%s]', channelId, postId);
+      try {
+        if (!channelId) {
+          options.logger.warn('Missing channelId');
+          throw new Error('Channel ID is required');
+        }
+        if (!messageInput?.content) {
+          options.logger.warn('Missing message content');
+          throw new Error('Message content is required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService || !channelService) {
+          options.logger.warn('Required services not available');
+          throw new Error('Required services unavailable');
+        }
+        const {
+          content,
+          files,
+          createdBy
+        } = messageInput;
+        const {
+          accountId
+        } = userContext;
+        let post = null;
+        const channelExists = await channelService.get(channelId);
+        if (!channelExists) {
+          options.logger.debug('Creating public channel %s', channelId);
+          const channel = await channelService.savePublicChannel({
+            _id: channelId,
+            type: RoomType.Public,
+            title: `public-channel-${channelId}`
           });
+          if (!channel) {
+            options.logger.error('Failed to create public channel %s', channelId);
+            throw new Error('Failed to create public channel');
+          }
         }
-      } else {
-        post = await postService.createWithoutSubscription({
-          _id: postId || undefined,
+        const postData = {
           channel: channelId,
           message: content,
           editedBy: createdBy || accountId,
           author: createdBy || accountId,
           files,
           type: PostTypeEnum.Public
-        });
+        };
+        if (postId) {
+          post = await postService.createWithoutSubscription({
+            _id: postId,
+            ...postData
+          });
+        } else {
+          post = await postService.createWithoutSubscription(postData);
+        }
+        if (post) {
+          options.logger.debug('Publishing public post created event for channel %s', channelId);
+          options.pubsub.publish(`PUBLIC_POST_CREATED.${channelId}`, post);
+        }
+        return post;
+      } catch (error) {
+        options.logger.error('Error sending public message: %o', error);
+        throw error;
       }
-      if (post) options.pubsub.publish(`PUBLIC_POST_CREATED.${channelId}`, post);
-      return post;
     },
     async sendExpoNotificationOnPost(_, {
       postId,
@@ -341,9 +596,29 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      const post = await postService.get(postId.toString());
-      const res = await messengerNotificationService.sendExpoNotificationOnPost(post, notificationData);
-      return res;
+      options.logger.trace('(Mutation.sendExpoNotificationOnPost) postId [%s]', postId);
+      try {
+        if (!postId) {
+          options.logger.warn('Missing postId');
+          throw new Error('Post ID is required');
+        }
+        if (!messengerNotificationService || !postService) {
+          options.logger.warn('Required services not available');
+          throw new Error('Required services unavailable');
+        }
+        const post = await postService.get(postId.toString());
+        if (!post) {
+          options.logger.warn('Post not found: %s', postId);
+          throw new Error('Post not found');
+        }
+        options.logger.debug('Sending expo notification for post %s', postId);
+        const result = await messengerNotificationService.sendExpoNotificationOnPost(post, notificationData);
+        options.logger.debug('Expo notification sent successfully for post %s', postId);
+        return result;
+      } catch (error) {
+        options.logger.error('Error sending expo notification: %o', error);
+        throw error;
+      }
     },
     createMessageFileUploadLink(_, {
       postId,
@@ -352,7 +627,25 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      return postService.createFileUploadLink(postId, filename, userContext.accountId);
+      options.logger.trace('(Mutation.createMessageFileUploadLink) postId [%s], filename [%s]', postId, filename);
+      try {
+        if (!postId || !filename) {
+          options.logger.warn('Missing postId or filename');
+          throw new Error('Post ID and filename are required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        return postService.createFileUploadLink(postId, filename, userContext.accountId);
+      } catch (error) {
+        options.logger.error('Error creating file upload link: %o', error);
+        throw error;
+      }
     },
     attachUploadedFileToMessage(_, {
       postId,
@@ -361,7 +654,25 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      return postService.attachUploadedFile(postId, file, userContext.accountId);
+      options.logger.trace('(Mutation.attachUploadedFileToMessage) postId [%s], filename [%s]', postId, file?.name);
+      try {
+        if (!postId || !file) {
+          options.logger.warn('Missing postId or file');
+          throw new Error('Post ID and file are required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        return postService.attachUploadedFile(postId, file, userContext.accountId);
+      } catch (error) {
+        options.logger.error('Error attaching uploaded file: %o', error);
+        throw error;
+      }
     },
     async createMessageFilesUploadLink(_, {
       postId,
@@ -370,7 +681,25 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      return postService.createFilesUploadLink(postId, filenames, userContext.accountId);
+      options.logger.trace('(Mutation.createMessageFilesUploadLink) postId [%s], fileCount [%d]', postId, filenames?.length || 0);
+      try {
+        if (!postId || !filenames || !Array.isArray(filenames) || filenames.length === 0) {
+          options.logger.warn('Missing postId or filenames');
+          throw new Error('Post ID and filenames array are required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        return postService.createFilesUploadLink(postId, filenames, userContext.accountId);
+      } catch (error) {
+        options.logger.error('Error creating files upload links: %o', error);
+        throw error;
+      }
     },
     async attachUploadedFilesToMessage(_, {
       postId,
@@ -379,14 +708,46 @@ const postResolvers = options => ({
       postService,
       userContext
     }) {
-      return postService.attachUploadedFiles(postId, files, userContext.accountId);
+      options.logger.trace('(Mutation.attachUploadedFilesToMessage) postId [%s], fileCount [%d]', postId, files?.length || 0);
+      try {
+        if (!postId || !files || !Array.isArray(files) || files.length === 0) {
+          options.logger.warn('Missing postId or files');
+          throw new Error('Post ID and files array are required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new Error('User authentication required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        return postService.attachUploadedFiles(postId, files, userContext.accountId);
+      } catch (error) {
+        options.logger.error('Error attaching uploaded files: %o', error);
+        throw error;
+      }
     },
     deleteMessageFile(_, {
       url
     }, {
       postService
     }) {
-      return postService.deleteFile(url);
+      options.logger.trace('(Mutation.deleteMessageFile) url [%s]', url);
+      try {
+        if (!url) {
+          options.logger.warn('Missing URL');
+          throw new Error('File URL is required');
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          throw new Error('Post service unavailable');
+        }
+        return postService.deleteFile(url);
+      } catch (error) {
+        options.logger.error('Error deleting message file: %o', error);
+        throw error;
+      }
     },
     async readMessage(src, {
       messageId
@@ -395,11 +756,30 @@ const postResolvers = options => ({
       userContext,
       channelService
     }) {
-      const member = await channelService.isMember(messageId.channelId, userContext.accountId);
-      if (!member) {
-        throw new GraphQLError('Message does not belong to user');
+      options.logger.trace('(Mutation.readMessage) messageId [%j], accountId [%s]', messageId, userContext?.accountId);
+      try {
+        if (!messageId?.channelId || !messageId?.messageId) {
+          options.logger.warn('Missing messageId parameters');
+          throw new GraphQLError('Message ID and Channel ID are required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new GraphQLError('User authentication required');
+        }
+        if (!postService || !channelService) {
+          options.logger.warn('Required services not available');
+          throw new GraphQLError('Required services unavailable');
+        }
+        const member = await channelService.isMember(messageId.channelId, userContext.accountId);
+        if (!member) {
+          options.logger.warn('User %s is not a member of channel %s', userContext.accountId, messageId.channelId);
+          throw new GraphQLError('Message does not belong to user');
+        }
+        return postService.readMessage(messageId, userContext.accountId);
+      } catch (error) {
+        options.logger.error('Error reading message: %o', error);
+        throw error;
       }
-      return postService.readMessage(messageId, userContext.accountId);
     },
     async deliverMessage(src, {
       messageId
@@ -408,70 +788,117 @@ const postResolvers = options => ({
       userContext,
       channelService
     }) {
-      const member = await channelService.isMember(messageId.channelId, userContext.accountId);
-      if (!member) {
-        throw new GraphQLError('Message does not belong to user');
+      options.logger.trace('(Mutation.deliverMessage) messageId [%j], accountId [%s]', messageId, userContext?.accountId);
+      try {
+        if (!messageId?.channelId || !messageId?.messageId) {
+          options.logger.warn('Missing messageId parameters');
+          throw new GraphQLError('Message ID and Channel ID are required');
+        }
+        if (!userContext?.accountId) {
+          options.logger.warn('Missing user context');
+          throw new GraphQLError('User authentication required');
+        }
+        if (!postService || !channelService) {
+          options.logger.warn('Required services not available');
+          throw new GraphQLError('Required services unavailable');
+        }
+        const member = await channelService.isMember(messageId.channelId, userContext.accountId);
+        if (!member) {
+          options.logger.warn('User %s is not a member of channel %s', userContext.accountId, messageId.channelId);
+          throw new GraphQLError('Message does not belong to user');
+        }
+        return postService.deliverMessage(messageId, userContext.accountId);
+      } catch (error) {
+        options.logger.error('Error delivering message: %o', error);
+        throw error;
       }
-      return postService.deliverMessage(messageId, userContext.accountId);
     },
-    // uploadFile(src, { files, postId }, { fileInfoService, userContext }) {
-    //     const res = [];
-    //     files.map((file) =>
-    //         res.push(
-    //             fileInfoService.create({
-    //                 refType: FileRefType.Post as never,
-    //                 file,
-    //                 createdBy: userContext.accountId,
-    //                 ref: postId,
-    //             }),
-    //         ),
-    //     );
-    //     return res;
-    // },
     async TestchatMessage(src, {
       channelId
     }, context) {
-      // if (!context.logger) {
-      //     throw new Error('Logger is not defined in context');
-      //   }
-      options.pubsub.publish(`CHAT_CREATED.${channelId}`, {
-        chatMessageTest: {
+      options.logger.trace('(Mutation.TestchatMessage) channelId [%s]', channelId);
+      try {
+        if (!channelId) {
+          options.logger.warn('Missing channelId');
+          throw new Error('Channel ID is required');
+        }
+        const testData = {
           channelId,
           orgName: 'upadhyaytarun'
-        }
-      });
-      return {
-        channelId,
-        orgName: 'upadhyaytarun'
-      };
+        };
+        options.logger.debug('Publishing test chat message for channel %s', channelId);
+        options.pubsub.publish(`CHAT_CREATED.${channelId}`, {
+          chatMessageTest: testData
+        });
+        return testData;
+      } catch (error) {
+        options.logger.error('Error in TestchatMessage: %o', error);
+        throw error;
+      }
     }
   },
   Subscription: {
     chatMessageAdded: {
-      // More on pubsub below
       subscribe: (_, {
         channelId,
         directTo
       }) => {
-        return options.pubsub.asyncIterator([`POST_CREATED.${channelId}`]);
+        options.logger.trace('(Subscription.chatMessageAdded) channelId [%s], directTo [%s]', channelId, directTo);
+        try {
+          if (!channelId) {
+            throw new Error('Channel ID is required for subscription');
+          }
+          return options.pubsub.asyncIterator([`POST_CREATED.${channelId}`]);
+        } catch (error) {
+          options.logger.error('Error subscribing to chatMessageAdded: %o', error);
+          throw error;
+        }
       },
-      resolve: payload => payload
+      resolve: payload => {
+        options.logger.trace('(Subscription.chatMessageAdded.resolve) payload received');
+        return payload;
+      }
     },
     chatMessageTest: {
-      // More on pubsub below
       subscribe: (_, {
         channelId,
         directTo
       }) => {
-        return options.pubsub.asyncIterator([`CHAT_CREATED.${channelId}`]);
+        options.logger.trace('(Subscription.chatMessageTest) channelId [%s], directTo [%s]', channelId, directTo);
+        try {
+          if (!channelId) {
+            throw new Error('Channel ID is required for subscription');
+          }
+          return options.pubsub.asyncIterator([`CHAT_CREATED.${channelId}`]);
+        } catch (error) {
+          options.logger.error('Error subscribing to chatMessageTest: %o', error);
+          throw error;
+        }
       },
-      resolve: payload => payload
+      resolve: payload => {
+        options.logger.trace('(Subscription.chatMessageTest.resolve) payload received');
+        return payload;
+      }
     },
     publicPostAdded: {
       subscribe: (_, {
         channelId
-      }) => options.pubsub.asyncIterator([`PUBLIC_POST_CREATED.${channelId}`]),
-      resolve: payload => payload
+      }) => {
+        options.logger.trace('(Subscription.publicPostAdded) channelId [%s]', channelId);
+        try {
+          if (!channelId) {
+            throw new Error('Channel ID is required for subscription');
+          }
+          return options.pubsub.asyncIterator([`PUBLIC_POST_CREATED.${channelId}`]);
+        } catch (error) {
+          options.logger.error('Error subscribing to publicPostAdded: %o', error);
+          throw error;
+        }
+      },
+      resolve: payload => {
+        options.logger.trace('(Subscription.publicPostAdded.resolve) payload received');
+        return payload;
+      }
     }
   }
 });export{postResolvers};//# sourceMappingURL=post.js.map