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

package/lib/graphql/resolvers/post.js

@@ -1,4 +1,6 @@
-import {generateUri}from'@adminide-stack/core';import {RoomType,PostTypeEnum,SortEnum,ClientCacheTypeNames}from'common';import {get}from'lodash-es';import {GraphQLError}from'graphql';// export const postResolvers = ({ pubsub }): IResolvers<IContext> => ({
+import {withFilter}from'graphql-subscriptions';import {RoomType,PostTypeEnum,SortEnum,ConfigCollectionName,Scheme,ClientCacheTypeNames}from'common/server';import {get}from'lodash-es';import {GraphQLError}from'graphql';import {generateResourceUri,DEFAULT_TENANT_ID,buildNodeContext}from'@adminide-stack/core/lib/index.js';// import { IContext } from '../../interfaces';
+// export const postResolvers = ({ pubsub }): IResolvers<IContext> => ({
+// export const postResolvers: (options: IResolverOptions) => IResolvers<IContext> = (options) => ({
 const postResolvers = options => ({
   // Temporary fix, until we have extension support in base module
   FileInfo: {
@@ -7,125 +9,292 @@ const postResolvers = options => ({
     }, args, {
       fileInfoService
     }) => {
-      const basePath = fileInfoService.awsS3Service.basePath || 'aws';
-      if (!url.includes(basePath)) {
-        return url;
-      }
-      return fileInfoService.getResizedImage(url, {
-        width: undefined,
-        height: undefined
-      });
+      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
+      }
     },
     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
+      accountService,
+      accountUserDataLoader
     }) {
-      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 accountUserDataLoader.load(src.editedBy.toString());
+      } catch (error) {
+        options.logger.error('Error getting Post editedBy: %o', error);
+        return null;
+      }
     },
     deletedBy(src, args, {
-      accountService
+      accountService,
+      accountUserDataLoader
     }) {
-      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 accountUserDataLoader.load(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;
+      }
     },
-    propsConfiguration(src, args, {
-      configurationService
+    async propsConfiguration(src, args, {
+      configurationService,
+      userContext
     }) {
-      const resource = generateUri('messenger', {
-        _id: src.id
-      }, 'props');
-      let data = '{}';
+      options.logger.trace('(Post.propsConfiguration) postId [%s], orgName [%s]', src?.id);
       try {
-        data = JSON.stringify(src.props);
-      } catch (err) {
-        console.log('---Errr---', err);
-      }
-      const machineModel = configurationService.parser(resource.toString(), data);
-      return {
-        resource,
-        contents: machineModel.contents,
-        overrides: machineModel.overrides,
-        keys: machineModel.keys,
-        __typename: ClientCacheTypeNames.MachineConfiguration
-      };
+        // if (!src?.id || !userContext?.orgName) {
+        if (!src?.id) {
+          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(ConfigCollectionName.Post, {
+          _id: src.id
+        }, '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;
+      }
     },
     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
+          };
+        }
+        if (!postService) {
+          options.logger.warn('PostService not available');
+          return {
+            data: [],
+            totalCount: 0
+          };
         }
-      })) ?? [];
-      return {
-        totalCount,
-        data
-      };
+        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);
+        // Set default type to Simple if not specified
+        const processedData = data.map(post => ({
+          ...post,
+          type: (post.type === 'message' ? PostTypeEnum.Message : post.type) || PostTypeEnum.Simple
+        }));
+        return {
+          totalCount,
+          data: processedData
+        };
+      } catch (error) {
+        options.logger.error('Error getting Post replies: %o', error);
+        return {
+          data: [],
+          totalCount: 0
+        };
+      }
     }
   },
   Query: {
@@ -134,31 +303,76 @@ const postResolvers = options => ({
       parentId,
       limit,
       skip,
-      sort
+      sort,
+      props
     }, {
       postService,
+      channelService,
       userContext
     }) {
-      const sortBy = sort || {
-        key: 'createdAt',
-        value: SortEnum.Desc
-      };
-      const {
-        data,
-        totalCount
-      } = await postService.getAllWithCount({
-        criteria: {
-          channel: channelId,
+      options.logger.trace('(Query.messages) channelId [%s], parentId [%s], limit [%d], skip [%d]', channelId, parentId, limit, skip);
+      try {
+        // if (projectId && !channelId) {
+        //     const { data: channels } = (await channelService.getAllWithCount({
+        //         criteria: {
+        //             projectId: projectId?.toString?.(),
+        //             type: RoomType.Aiassistant,
+        //         },
+        //         limit: 1,
+        //     })) as unknown as { data: IChannel[]; totalCount: number };
+        //     const channel = channels?.[0];
+        //     channelId = channel?.id as string;
+        // }
+        if (!channelId && !props) {
+          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 channel = channelId || undefined;
+        // const projectId = props?.projectId ? `"props.projectId":"${props?.projectId}"` : undefined;
+        // console.log("server projectId",projectId)
+        const criteria = props ? {
+          channel,
+          parentId,
+          'props.projectId': props?.projectId || undefined
+        } : {
+          channel,
           parentId
-        },
-        limit,
-        skip,
-        sort: sortBy
-      });
-      return {
-        totalCount,
-        data
-      };
+        };
+        const {
+          data,
+          totalCount
+        } = await postService.getAllWithCount({
+          criteria,
+          limit,
+          skip,
+          sort: sortBy
+        });
+        options.logger.debug('Retrieved %d messages for channel %s', totalCount, channelId);
+        // Set default type to Simple if not specified
+        const processedData = data.map(post => ({
+          ...post,
+          type: (post.type === 'message' ? PostTypeEnum.Message : post.type) || PostTypeEnum.Simple
+        }));
+        return {
+          totalCount,
+          data: processedData
+        };
+      } catch (error) {
+        options.logger.error('Error in messages query: %o', error);
+        throw error;
+      }
     },
     async publicMessages(src, {
       channelId
@@ -166,23 +380,43 @@ 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);
+        // Set default type to Simple if not specified
+        const processedData = data.map(post => ({
+          ...post,
+          type: post.type || PostTypeEnum.Simple
+        }));
+        return {
+          totalCount,
+          data: processedData
+        };
+      } catch (error) {
+        options.logger.error('Error in publicMessages query: %o', error);
+        throw error;
+      }
     }
   },
   Mutation: {
@@ -191,14 +425,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,
@@ -207,12 +456,45 @@ 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);
+        const {
+          content,
+          files,
+          extraProps
+        } = messageInput;
+        return postService.update(messageId.messageId, {
+          message: content,
+          editedBy: userContext.accountId,
+          channel: messageId.channelId,
+          files,
+          ...(extraProps && {
+            props: {
+              extraProps
+            }
+          })
+        });
+      } catch (error) {
+        options.logger.error('Error editing message: %o', error);
+        throw error;
+      }
     },
     async sendMessage(src, {
       channelId,
@@ -222,49 +504,69 @@ 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,
+          type,
+          extraProps
+        } = messageInput;
+        const {
+          accountId
+        } = userContext;
+        const postData = {
           channel: channelId,
           message: content,
           editedBy: createdBy || accountId,
           author: createdBy || accountId,
           files,
-          props: notificationParams ? {
-            notificationParams
-          } : undefined
-        });
+          props: notificationParams || extraProps ? {
+            ...(notificationParams && {
+              notificationParams
+            }),
+            ...(extraProps && {
+              ...extraProps
+            })
+          } : undefined,
+          type: type || PostTypeEnum.Simple
+        };
+        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);
+        //options.pubsub.publish(`POST_CREATED.${channelId}`, post);
+        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,
@@ -275,46 +577,77 @@ 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,
+          extraProps
+        } = 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
-        });
+          type: PostTypeEnum.Public,
+          ...(extraProps && {
+            props: {
+              extraProps
+            }
+          })
+        };
+        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,
@@ -324,9 +657,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,
@@ -335,7 +688,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,
@@ -344,7 +715,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,
@@ -353,7 +742,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,
@@ -362,14 +769,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
@@ -378,11 +817,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
@@ -391,70 +849,247 @@ 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;
+      }
+    },
+    async generateAiCode(src, {
+      messageId,
+      modelConfig
+    }, {
+      postService,
+      userContext,
+      inngestClient
+    }) {
+      options.logger.trace('(Mutation.generateAiCode) messageId [%s], modelConfig [%j]', messageId, modelConfig);
+      try {
+        if (!messageId || !modelConfig) {
+          options.logger.warn('Missing messageId or modelConfig');
+          throw new Error('Message ID and model configuration are required');
+        }
+        const post = await postService.get(messageId);
+        if (!post) {
+          options.logger.warn('Post not found: %s', messageId);
+          throw new Error('Post not found');
+        }
+        const result = await inngestClient.send({
+          name: 'ai-code-agent/run-code-generation',
+          data: {
+            messageId: post.id,
+            modelConfig: modelConfig
+          }
+        });
+        return {
+          success: true,
+          message: 'Code generation initiated successfully',
+          eventId: result.ids[0]
+        };
+      } catch (error) {
+        options.logger.error('Error generating AI code: %o', error);
+        throw error;
+      }
+    },
+    async recreateSandbox(src, {
+      messageId,
+      projectId
+    }, {
+      postService,
+      userContext,
+      inngestClient
+    }) {
+      options.logger.trace('(Mutation.recreateSandbox) messageId [%s], projectId [%s]', messageId, projectId);
+      try {
+        const result = await inngestClient.send({
+          name: 'recreate-sandbox-url',
+          data: {
+            messageId,
+            projectId
+          }
+        });
+        return {
+          success: true,
+          message: 'Sandbox recreation initiated successfully',
+          eventId: result.ids[0]
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Failed to recreate sandbox: ${error.message}`,
+          eventId: null
+        };
+      }
+    },
+    async regenerateAiCode(src, {
+      messageId,
+      modelConfig
+    }, {
+      postService,
+      userContext,
+      inngestClient
+    }) {
+      options.logger.trace('(Mutation.regenerateAiCode) messageId [%s], modelConfig [%j]', messageId, modelConfig);
+      try {
+        const result = await inngestClient.send({
+          name: 'regenerate-ai-code',
+          data: {
+            messageId,
+            modelConfig
+          }
+        });
+        return {
+          success: true,
+          message: 'Code regeneration initiated successfully',
+          eventId: result.ids[0]
+        };
+      } catch (error) {
+        options.logger.error('Error regenerating AI code: %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 updateSandboxFile(src, {
+      projectId,
+      messageId,
+      filePath,
+      content
+    }, {
+      postService
+    }) {
+      options.logger.trace('(Mutation.updateSandboxFile) projectId [%s], messageId [%s], filePath [%s], content [%s]', projectId, messageId, filePath, content);
+      return postService.updateSandboxFile(projectId, messageId, filePath, content);
+    },
     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;
+      }
+    },
+    sandboxError: {
+      subscribe: withFilter((_, __, context) => context.pubsub.asyncIterator(['SANDBOX_ERROR']), (payload, variables) => payload.sandboxError.projectId === variables.projectId),
+      resolve: (payload, _args, context) => {
+        try {
+          if (!context.userContext) context.userContext = {};
+          if (!context.req) context.req = {};
+          return payload.sandboxError;
+        } catch (error) {
+          options.logger.error('Sandbox error subscription resolve error: %o', error);
+          return payload.sandboxError;
+        }
+      }
+    },
+    fileUpdated: {
+      subscribe: withFilter((_, __, context) => context.pubsub.asyncIterator(['FILE_UPDATED']), (payload, variables) => payload.fileUpdated.projectId === variables.projectId),
+      resolve: (payload, _args, context) => {
+        try {
+          if (!context.userContext) context.userContext = {};
+          if (!context.req) context.req = {};
+          return payload.fileUpdated;
+        } catch (error) {
+          options.logger.error('File update subscription resolve error: %o', error);
+          return payload.fileUpdated;
+        }
+      }
     }
   }
 });export{postResolvers};//# sourceMappingURL=post.js.map