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

package/lib/services/post-service.js

@@ -1,55 +1,230 @@
-import {__decorate,__param,__metadata}from'tslib';import'@cdm-logger/core';import {inject}from'inversify';import {set}from'lodash-es';import {SERVER_TYPES,FileRefType}from'common';import {BaseService}from'@common-stack/store-mongo';import {PubSubEngine}from'graphql-subscriptions';import {CommonType}from'@common-stack/core';import {ServiceBroker}from'moleculer';import {ChannelRepository}from'../store/repositories/channel-repository.js';import {PostRepository}from'../store/repositories/post-repository.js';import'../store/repositories/post-thread-repository.js';import'../store/repositories/reaction-repository.js';import {PostTypes}from'../preferences/settings/post-settings.js';import'../preferences/permissions/inbox-permission-contribution.js';import'../preferences/permissions/inbox-roles-permission-overwrite.js';import {config}from'../config/env-config.js';var PostService_1;
-let PostService = PostService_1 = class PostService extends BaseService {
+import {__decorate,__param,__metadata}from'tslib';import'@cdm-logger/core';import {inject}from'inversify';import {set}from'lodash-es';import {SERVER_TYPES,FileRefType,AiAgentMessageRole,AiAgentMessageType}from'common/server';import {BaseService2}from'@common-stack/store-mongo';import {PubSubEngine}from'graphql-subscriptions';import {CommonType}from'@common-stack/core';import {ServiceBroker}from'moleculer';import {DisposableCollection}from'@adminide-stack/core';import {ChannelRepository}from'../store/repositories/channel-repository.js';import {PostRepository}from'../store/repositories/post-repository.js';import'../store/repositories/post-thread-repository.js';import'../store/repositories/reaction-repository.js';import'../store/repositories/ai-fragment-repository.js';import {PostTypes}from'../preferences/settings/post-settings.js';import'../preferences/permissions/inbox-permission-contribution.js';import'../preferences/permissions/inbox-roles-permission-overwrite.js';import {config}from'../config/env-config.js';import {getSandbox}from'../inngest/utils.js';var PostService_1;
+/**
+ * Post Service Implementation
+ *
+ * This service handles comprehensive post management within the messenger platform,
+ * providing operations for creating, updating, managing posts and their associated
+ * content including file attachments, notifications, threading, and real-time
+ * message delivery across channels and organizations.
+ *
+ * Key capabilities:
+ * - Post lifecycle management (creation, updates, deletion)
+ * - File attachment handling and upload management
+ * - Real-time message delivery and notifications
+ * - Post threading and conversation management
+ * - Message status tracking (read, delivered)
+ * - Channel integration and message counting
+ * - Expo push notification integration
+ * - File upload link generation and management
+ */
+// @ts-ignore - Type compatibility issue between BaseService2 and IPostService
+let PostService = class PostService extends BaseService2 {
+  static {
+    PostService_1 = this;
+  }
   channelRepo;
   fileInfoService;
   messengerNotificationService;
+  aiFragmentService;
   broker;
   pubsub;
+  redisCacheManager;
+  redisClient;
+  toDispose = new DisposableCollection();
   logger;
-  constructor(repository, channelRepo, fileInfoService, messengerNotificationService, broker, pubsub, logger) {
+  // Redis cache configuration for posts
+  static CACHE_TTL = {
+    maxAge: 5 * 60,
+    scope: 'PUBLIC'
+  };
+  constructor(repository, channelRepo, fileInfoService, messengerNotificationService, aiFragmentService, broker, pubsub, redisCacheManager, redisClient, logger) {
     super(repository);
     this.channelRepo = channelRepo;
     this.fileInfoService = fileInfoService;
     this.messengerNotificationService = messengerNotificationService;
+    this.aiFragmentService = aiFragmentService;
     this.broker = broker;
     this.pubsub = pubsub;
+    this.redisCacheManager = redisCacheManager;
+    this.redisClient = redisClient;
     this.logger = logger?.child({
       className: PostService_1.name
     });
   }
-  createFileUploadLink(postId, filename, userId) {
-    return this.fileInfoService.uploadByUrl({
-      filename,
-      refType: FileRefType.Post,
-      ref: postId,
-      userId
-    });
+  /**
+   * Disposes of resources used by the service
+   */
+  dispose() {
+    this.toDispose.dispose();
+  }
+  // Override base service methods to handle errors internally
+  async create(data) {
+    try {
+      this.logger.debug('Creating post', {
+        data
+      });
+      // Validate required fields
+      if (!data) {
+        throw new Error('Post data is required');
+      }
+      if (!data.channel) {
+        throw new Error('Channel is required for post creation');
+      }
+      if (!data.author) {
+        throw new Error('Author is required for post creation');
+      }
+      // Add timestamps and default type
+      const postData = {
+        ...data,
+        type: data.type || 'Simple',
+        // Default to Simple type for regular messages
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+      // Create the post using repository
+      // const result = await this.repository.create(postData);
+      const result = await super.create(postData);
+      if (!result) {
+        throw new Error('Failed to create post');
+      }
+      // Update channel statistics
+      try {
+        await this.channelRepo.model.updateOne({
+          _id: data.channel
+        }, {
+          lastPostAt: result.createdAt,
+          $inc: {
+            totalMsgCount: 1,
+            totalMsgCountRoot: 1,
+            'members.$[elem].msgCountRoot': 1,
+            'members.$[elem].msgCount': 1
+          }
+        }, {
+          arrayFilters: [{
+            'elem.user': data.author
+          }]
+        });
+      } catch (channelError) {
+        this.logger.error('Error updating channel stats:', channelError);
+        // Don't fail the post creation if stats update fails
+      }
+      console.log('result...', JSON.stringify(result, null, 2));
+      if (result.props.sendNotificationWithProjectId) {
+        await this.pubsub.publish(`POST_CREATED.${result.props.projectId}`, result);
+      }
+      await this.pubsub.publish(`POST_CREATED.${data.channel}`, result);
+      await this.sendExpoNotification(result);
+      // Invalidate caches related to this channel
+      await this.invalidatePostCachesByChannel(String(data.channel));
+      return result;
+    } catch (error) {
+      this.logger.error('Error creating post:', error);
+      throw error;
+    }
+  }
+  async update(id, data) {
+    try {
+      const result = await super.update(id, data);
+      if (!result || typeof result === 'object' && 'message' in result) {
+        this.logger.error('Failed to update post', {
+          error: result
+        });
+        throw new Error('Failed to update post');
+      }
+      try {
+        // Invalidate caches related to this post's channel
+        const channelId = result?.channel?.toString?.() || data?.channel;
+        if (channelId && !result?.props?.projectId) {
+          await this.invalidatePostCachesByChannel(String(channelId));
+        }
+      } catch (cacheError) {
+        this.logger.warn('Cache invalidation error after post update: %o', cacheError);
+      }
+      return result;
+    } catch (error) {
+      this.logger.error('Error updating post', {
+        error
+      });
+      throw error;
+    }
   }
+  async delete(criteria) {
+    try {
+      const result = await super.delete(criteria);
+      if (typeof result !== 'boolean') {
+        this.logger.error('Failed to delete post', {
+          error: result
+        });
+        throw new Error('Failed to delete post');
+      }
+      try {
+        // Attempt to invalidate caches if criteria is id
+        const id = typeof criteria === 'string' ? criteria : criteria?.id;
+        if (id) {
+          const existing = await this.get(id).catch(() => null);
+          const channelId = existing?.channel?.toString?.();
+          if (channelId) {
+            await this.invalidatePostCachesByChannel(String(channelId));
+          }
+        }
+      } catch (cacheError) {
+        this.logger.warn('Cache invalidation error after post delete: %o', cacheError);
+      }
+      return result;
+    } catch (error) {
+      this.logger.error('Error deleting post', {
+        error
+      });
+      throw error;
+    }
+  }
+  /**
+   * Creates a file upload link for a post
+   *
+   * @description Generates a secure upload URL for attaching files to posts
+   *
+   * @param {string} postId - The post identifier
+   * @param {string} filename - The name of the file to upload
+   * @param {string} userId - The user performing the upload
+   * @returns {Promise<string | Error>} - Upload URL or error
+   */
+  async createFileUploadLink(postId, filename, userId) {
+    try {
+      if (!postId || !filename || !userId) {
+        return new Error('Post ID, filename, and user ID are required');
+      }
+      const uploadUrl = await this.fileInfoService.uploadByUrl({
+        filename,
+        refType: FileRefType.Post,
+        ref: postId,
+        userId
+      });
+      this.logger.debug('File upload link created', {
+        postId,
+        filename,
+        userId
+      });
+      return uploadUrl;
+    } catch (error) {
+      this.logger.error('Error creating file upload link: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating upload link');
+    }
+  }
+  /**
+   * Attaches an uploaded file to a post
+   *
+   * @description Processes and attaches a completed file upload to a post
+   *
+   * @param {string} postId - The post identifier
+   * @param {IUploadedFileInput} file - The uploaded file information
+   * @param {string} createdBy - The user who uploaded the file
+   * @returns {Promise<IFileInfo | Error>} - File information or error
+   */
   async attachUploadedFile(postId, file, createdBy) {
-    const {
-      id
-    } = await this.fileInfoService.createUploadedFile({
-      ...file,
-      refType: FileRefType.Post,
-      ref: postId,
-      createdBy
-    });
-    const fileResponse = await this.fileInfoService.get(id);
-    return {
-      ...fileResponse,
-      url: this.fileInfoService.getDefaultImage(fileResponse.url)
-    };
-  }
-  createFilesUploadLink(postId, filenames, userId) {
-    return Promise.all(filenames.map(filename => this.fileInfoService.uploadByUrl({
-      filename,
-      refType: FileRefType.Post,
-      ref: postId,
-      userId
-    })));
-  }
-  attachUploadedFiles(postId, files, createdBy) {
-    return Promise.all(files.map(async file => {
+    try {
+      if (!postId || !file || !createdBy) {
+        return new Error('Post ID, file data, and creator ID are required');
+      }
       const {
         id
       } = await this.fileInfoService.createUploadedFile({
@@ -59,103 +234,764 @@ let PostService = PostService_1 = class PostService extends BaseService {
         createdBy
       });
       const fileResponse = await this.fileInfoService.get(id);
-      return {
+      const result = {
         ...fileResponse,
         url: this.fileInfoService.getDefaultImage(fileResponse.url)
       };
-    }));
+      this.logger.debug('File attached to post', {
+        postId,
+        fileId: id,
+        createdBy
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error attaching uploaded file: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while attaching file');
+    }
   }
-  async create(data) {
-    const post = await super.create(data);
-    const {
-      channel
-    } = data;
-    // Accessing private property
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    await this.channelRepo.model.updateOne({
-      _id: channel
-    }, {
-      lastPostAt: post.createdAt,
-      $inc: {
-        totalMsgCount: 1,
-        totalMsgCountRoot: 1,
-        'members.$[elem].msgCountRoot': 1,
-        'members.$[elem].msgCount': 1
-      }
-    }, {
-      arrayFilters: [{
-        'elem.user': data.author
-      }]
-    });
-    await this.pubsub.publish(`POST_CREATED.${channel}`, post);
-    await this.sendExpoNotification(post);
-    // if (post?.props?.notificationParams) await this.messengerNotificationService.sendExpoNotificationOnPost(post);
-    this.logger.trace('Post created');
-    return post;
+  /**
+   * Creates upload links for multiple files
+   *
+   * @description Generates secure upload URLs for multiple files to be attached to a post
+   *
+   * @param {string} postId - The post identifier
+   * @param {string[]} filenames - Array of file names
+   * @param {string} userId - The user performing the uploads
+   * @returns {Promise<string[] | Error>} - Array of upload URLs or error
+   */
+  async createFilesUploadLink(postId, filenames, userId) {
+    try {
+      if (!postId || !filenames || !Array.isArray(filenames) || !userId) {
+        return new Error('Post ID, filenames array, and user ID are required');
+      }
+      if (filenames.length === 0) {
+        return new Error('At least one filename is required');
+      }
+      const uploadUrls = await Promise.all(filenames.map(filename => this.fileInfoService.uploadByUrl({
+        filename,
+        refType: FileRefType.Post,
+        ref: postId,
+        userId
+      })));
+      this.logger.debug('Multiple file upload links created', {
+        postId,
+        fileCount: filenames.length,
+        userId
+      });
+      return uploadUrls;
+    } catch (error) {
+      this.logger.error('Error creating multiple file upload links: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating upload links');
+    }
   }
+  /**
+   * Attaches multiple uploaded files to a post
+   *
+   * @description Processes and attaches multiple completed file uploads to a post
+   *
+   * @param {string} postId - The post identifier
+   * @param {IUploadedFileInput[]} files - Array of uploaded file information
+   * @param {string} createdBy - The user who uploaded the files
+   * @returns {Promise<IFileInfo[] | Error>} - Array of file information or error
+   */
+  async attachUploadedFiles(postId, files, createdBy) {
+    try {
+      if (!postId || !files || !Array.isArray(files) || !createdBy) {
+        return new Error('Post ID, files array, and creator ID are required');
+      }
+      if (files.length === 0) {
+        return new Error('At least one file is required');
+      }
+      const fileResults = await Promise.all(files.map(async file => {
+        const {
+          id
+        } = await this.fileInfoService.createUploadedFile({
+          ...file,
+          refType: FileRefType.Post,
+          ref: postId,
+          createdBy
+        });
+        const fileResponse = await this.fileInfoService.get(id);
+        return {
+          ...fileResponse,
+          url: this.fileInfoService.getDefaultImage(fileResponse.url)
+        };
+      }));
+      this.logger.debug('Multiple files attached to post', {
+        postId,
+        fileCount: files.length,
+        createdBy
+      });
+      return fileResults;
+    } catch (error) {
+      this.logger.error('Error attaching multiple uploaded files: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while attaching files');
+    }
+  }
+  /**
+   * Creates a new post with full integration
+   *
+   * @description Creates a post with channel updates, notifications, and real-time publishing
+   *
+   * @param {IPostServiceInput} data - Post creation data
+   * @returns {Promise<AsDomainType<IPostModel> | Error>} - Created post or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
   async createWithoutSubscription(data) {
-    const post = await super.create(data);
-    const {
-      channel
-    } = data;
-    await this.channelRepo.model.updateOne({
-      _id: channel
-    }, {
-      lastPostAt: post.createdAt,
-      $inc: {
-        totalMsgCount: 1,
-        totalMsgCountRoot: 1,
-        'members.$[elem].msgCountRoot': 1,
-        'members.$[elem].msgCount': 1
-      }
-    }, {
-      arrayFilters: [{
-        'elem.user': data.author
-      }]
-    });
-    return post;
+    try {
+      if (!data) {
+        return new Error('Post data is required');
+      }
+      if (!data.channel) {
+        return new Error('Channel is required for post creation');
+      }
+      if (!data.author) {
+        return new Error('Author is required for post creation');
+      }
+      // Create the post
+      const postData = {
+        ...data,
+        createdAt: new Date(),
+        updatedAt: new Date()
+      }; // Type assertion for compatibility
+      const post = await this.repository.create(postData);
+      if (!post) {
+        return new Error('Failed to create post');
+      }
+      const {
+        channel
+      } = data;
+      // Update channel statistics without real-time publishing
+      // @ts-ignore - Accessing private property for channel updates
+      await this.channelRepo.model.updateOne({
+        _id: channel
+      }, {
+        lastPostAt: post.createdAt,
+        $inc: {
+          totalMsgCount: 1,
+          totalMsgCountRoot: 1,
+          'members.$[elem].msgCountRoot': 1,
+          'members.$[elem].msgCount': 1
+        }
+      }, {
+        arrayFilters: [{
+          'elem.user': data.author
+        }]
+      });
+      this.logger.debug('Post created without subscription', {
+        postId: post.id,
+        channelId: channel,
+        authorId: data.author
+      });
+      // Invalidate caches related to this channel
+      await this.invalidatePostCachesByChannel(String(channel));
+      return post;
+    } catch (error) {
+      this.logger.error('Error creating post without subscription: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating post');
+    }
   }
-  deleteFile(url) {
-    return this.fileInfoService.deleteByUrl(url);
+  /**
+   * Deletes a file by URL
+   *
+   * @description Removes a file from storage using its URL
+   *
+   * @param {string} url - The file URL to delete
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  async deleteFile(url) {
+    try {
+      if (!url) {
+        return new Error('File URL is required');
+      }
+      const success = await this.fileInfoService.deleteByUrl(url);
+      this.logger.debug('File deleted', {
+        url,
+        success
+      });
+      return success;
+    } catch (error) {
+      this.logger.error('Error deleting file: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while deleting file');
+    }
   }
+  /**
+   * Marks a message as read by a user
+   *
+   * @description Updates message status to indicate it has been read by a specific user
+   *
+   * @param {IMessageIdentifier} messageId - Message identifier
+   * @param {string} user - User ID who read the message
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
   async readMessage(messageId, user) {
-    await this.update(messageId.messageId, {
-      props: {
-        [`[${user}]`]: set({}, PostTypes.isRead, true)
+    try {
+      if (!messageId?.messageId || !user) {
+        return new Error('Message ID and user ID are required');
       }
-    });
-    return true;
+      await this.update(messageId.messageId, {
+        props: {
+          [`[${user}]`]: set({}, PostTypes.isRead, true)
+        }
+      });
+      this.logger.debug('Message marked as read', {
+        messageId: messageId.messageId,
+        userId: user
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error marking message as read: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while marking message as read');
+    }
   }
+  /**
+   * Marks a message as delivered to a user
+   *
+   * @description Updates message status to indicate it has been delivered to a specific user
+   *
+   * @param {IMessageIdentifier} messageId - Message identifier
+   * @param {string} user - User ID who received the message
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
   async deliverMessage(messageId, user) {
-    await this.update(messageId.messageId, {
-      props: {
-        [`[${user}]`]: set({}, PostTypes.isDelivered, true)
+    try {
+      if (!messageId?.messageId || !user) {
+        return new Error('Message ID and user ID are required');
       }
-    });
-    return true;
+      await this.update(messageId.messageId, {
+        props: {
+          [`[${user}]`]: set({}, PostTypes.isDelivered, true)
+        }
+      });
+      this.logger.debug('Message marked as delivered', {
+        messageId: messageId.messageId,
+        userId: user
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error marking message as delivered: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while marking message as delivered');
+    }
+  }
+  /**
+   * Creates a post with associated post thread
+   *
+   * @description Creates both a post and its associated thread for threaded conversations
+   *
+   * @param {CreatePostThreadOptions} data - Post and thread creation options
+   * @returns {Promise<{post: AsDomainType<IPostModel>; postThread: IPostThread} | Error>} - Created post and thread or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async createPostWithPostThread(data) {
+    try {
+      if (!data) {
+        return new Error('Post thread creation data is required');
+      }
+      // This would require integration with PostThreadService
+      // For now, return an error indicating it needs implementation
+      return new Error('Post thread creation is not yet implemented');
+    } catch (error) {
+      this.logger.error('Error creating post with thread: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating post with thread');
+    }
+  }
+  /**
+   * Retrieves the last message in a channel
+   *
+   * @description Gets the most recent post/message from a specific channel
+   *
+   * @param {string} channelId - The channel identifier
+   * @returns {Promise<AsDomainType<IPostModel> | Error>} - Last message or error
+   */
+  // @ts-ignore - Type compatibility issue between interface and implementation
+  async getLastMessage(channelId) {
+    try {
+      if (!channelId) {
+        return new Error('Channel ID is required');
+      }
+      // Try Redis cache first
+      if (this.redisCacheManager) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getLastPostByChannel`;
+          const variables = {
+            channelId
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          const cached = await this.redisCacheManager.get(cacheKey, variables, cacheCtx);
+          if (cached) {
+            this.logger.debug(`Cache hit for last post by channel ${channelId}`);
+            return cached;
+          }
+        } catch (cacheError) {
+          this.logger.warn(`Redis cache error for getLastMessage(${channelId}): ${cacheError?.message}`);
+        }
+      }
+      // @ts-ignore - Accessing private property for direct query
+      const post = await this.repository.model.findOne({
+        channel: channelId
+      }).sort({
+        createdAt: -1
+      });
+      if (!post) {
+        return new Error('No messages found in channel');
+      }
+      this.logger.debug('Last message retrieved', {
+        channelId,
+        postId: post._id
+      });
+      const result = post;
+      // Cache the result
+      if (this.redisCacheManager) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getLastPostByChannel`;
+          const variables = {
+            channelId
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          await this.redisCacheManager.set(cacheKey, variables, result, cacheCtx, PostService_1.CACHE_TTL);
+        } catch (cacheError) {
+          this.logger.warn(`Failed to cache last post by channel: ${cacheError?.message}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting last message: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while getting last message');
+    }
+  }
+  /**
+   * Gets posts by channel with pagination
+   *
+   * @description Retrieves posts from a channel with pagination support
+   *
+   * @param {string} channelId - The channel identifier
+   * @param {number} limit - Maximum number of posts to return
+   * @param {number} offset - Number of posts to skip
+   * @returns {Promise<Array<AsDomainType<IPostModel>> | Error>} - Array of posts or error
+   */
+  async getPostsByChannel(channelId, limit = 50, offset = 0) {
+    try {
+      if (!channelId) {
+        return new Error('Channel ID is required');
+      }
+      // Try Redis cache first
+      if (this.redisCacheManager) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getPostsByChannel`;
+          const variables = {
+            channelId,
+            limit,
+            offset
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          const cached = await this.redisCacheManager.get(cacheKey, variables, cacheCtx);
+          if (cached) {
+            this.logger.debug(`Cache hit for posts by channel ${channelId}`);
+            return cached;
+          }
+        } catch (cacheError) {
+          this.logger.warn(`Redis cache error for getPostsByChannel(${channelId}): ${cacheError?.message}`);
+        }
+      }
+      const posts = await this.getAll({
+        criteria: {
+          channel: channelId
+        }
+      });
+      // Apply manual pagination
+      const paginatedPosts = posts.slice(offset, offset + limit);
+      this.logger.debug('Posts retrieved by channel', {
+        channelId,
+        count: paginatedPosts.length,
+        limit,
+        offset
+      });
+      const result = paginatedPosts;
+      // Cache the result
+      if (this.redisCacheManager) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getPostsByChannel`;
+          const variables = {
+            channelId,
+            limit,
+            offset
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          await this.redisCacheManager.set(cacheKey, variables, result, cacheCtx, PostService_1.CACHE_TTL);
+        } catch (cacheError) {
+          this.logger.warn(`Failed to cache posts by channel: ${cacheError?.message}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting posts by channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while getting posts by channel');
+    }
+  }
+  /**
+   * Updates a post
+   *
+   * @description Updates post content and metadata
+   *
+   * @param {string} postId - The post identifier
+   * @param {Partial<IPostServiceInput>} updates - Update data
+   * @returns {Promise<AsDomainType<IPostModel> | Error>} - Updated post or error
+   */
+  async updatePost(postId, updates) {
+    try {
+      if (!postId) {
+        return new Error('Post ID is required');
+      }
+      if (!updates || Object.keys(updates).length === 0) {
+        return new Error('Updates are required');
+      }
+      // Get existing post
+      const existingPost = await this.get(postId);
+      if (!existingPost) {
+        return new Error('Post not found');
+      }
+      // Prepare update data
+      const updateData = {
+        ...updates,
+        updatedAt: new Date()
+      }; // Type assertion for compatibility
+      // Update the post
+      const updatedPost = await this.update(postId, updateData);
+      if (!updatedPost) {
+        return new Error('Failed to update post');
+      }
+      this.logger.debug('Post updated successfully', {
+        postId,
+        updates: Object.keys(updates)
+      });
+      return updatedPost;
+    } catch (error) {
+      this.logger.error('Error updating post: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while updating post');
+    }
+  }
+  /**
+   * Deletes a post
+   *
+   * @description Soft deletes a post and its associated data
+   *
+   * @param {string} postId - The post identifier
+   * @returns {Promise<boolean | Error>} - Success status or error
+   */
+  async deletePost(postId) {
+    try {
+      if (!postId) {
+        return new Error('Post ID is required');
+      }
+      // Get post to verify it exists
+      const post = await this.get(postId);
+      if (!post) {
+        return new Error('Post not found');
+      }
+      // Soft delete the post
+      const success = await this.repository.delete({
+        id: postId
+      });
+      if (success) {
+        this.logger.debug('Post deleted successfully', {
+          postId
+        });
+        try {
+          const channelId = post?.channel?.toString?.();
+          if (channelId) {
+            await this.invalidatePostCachesByChannel(String(channelId));
+          }
+        } catch (cacheError) {
+          this.logger.warn('Cache invalidation error after deletePost: %o', cacheError);
+        }
+      }
+      return success;
+    } catch (error) {
+      this.logger.error('Error deleting post: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while deleting post');
+    }
   }
+  /**
+   * Sends Expo push notification for a post
+   *
+   * @description Handles push notification logic for new posts
+   *
+   * @param {any} post - The post data
+   * @private
+   */
   async sendExpoNotification(post) {
-    if (post?.props?.notificationParams && (!post?.type || post?.type !== 'ALERT')) {
-      await this.messengerNotificationService.sendExpoNotificationOnPost(post);
-    } else if (!post?.type || post?.type !== 'ALERT') {
-      const notificationData = {
-        url: config.INBOX_MESSEGE_PATH,
-        params: {
-          channelId: post?.channel,
-          hideTabBar: true
-        },
-        screen: 'DialogMessages',
-        other: {
-          sound: 'default'
+    try {
+      if (post?.props?.notificationParams && Object.keys(post?.props?.notificationParams).length > 0 && (!post?.type || post?.type !== 'ALERT')) {
+        await this.messengerNotificationService.sendExpoNotificationOnPost(post);
+      } else if (!post?.type || post?.type !== 'ALERT') {
+        const notificationData = {
+          url: config.INBOX_MESSEGE_PATH,
+          params: {
+            channelId: post?.channel,
+            hideTabBar: true
+          },
+          screen: 'DialogMessages',
+          other: {
+            sound: 'default'
+          }
+        };
+        await this.messengerNotificationService.sendExpoNotificationOnPost(post, notificationData);
+      }
+      this.logger.debug('Expo notification sent', {
+        postId: post?.id
+      });
+    } catch (error) {
+      this.logger.error('Error sending Expo notification: %o', error);
+      // Don't throw error as notification failure shouldn't break post creation
+    }
+  }
+  /**
+   * Invalidates cache entries related to a channel's posts
+   * @param channelId - Channel ID
+   */
+  async invalidatePostCachesByChannel(channelId) {
+    if (!this.redisCacheManager || !channelId) {
+      return;
+    }
+    try {
+      // Invalidate last post by channel
+      await this.redisCacheManager.del(`${config.APP_NAME}:getLastPostByChannel`, {
+        channelId
+      }, {
+        userId: 'system'
+      }, true);
+      // Invalidate posts by channel with any pagination (wildcard delete)
+      await this.redisCacheManager.del(`${config.APP_NAME}:getPostsByChannel`, {
+        channelId
+      }, {
+        userId: 'system'
+      }, true);
+      this.logger.debug(`Invalidated post caches for channel ${channelId}`);
+    } catch (error) {
+      this.logger.warn(`Error invalidating post caches: ${error?.message}`);
+    }
+  }
+  async getPreviousMessagesByProjectId(projectId, limit) {
+    // Get total count first, then calculate skip to get the latest messages
+    const totalCount = await this.repository.count({
+      props: {
+        projectId: projectId?.toString?.()
+      }
+    });
+    const skip = Math.max(0, totalCount - limit);
+    const messages = await this.repository.getAll({
+      criteria: {
+        props: {
+          projectId: projectId?.toString?.()
         }
+      },
+      limit,
+      skip
+    });
+    const formattedMessages = [];
+    for (const message of messages) {
+      const messageData = {
+        type: 'text',
+        role: message.props.role === AiAgentMessageRole.ASSISTANT ? 'assistant' : 'user',
+        content: message.message
       };
-      await this.messengerNotificationService.sendExpoNotificationOnPost(post, notificationData);
+      formattedMessages.push(messageData);
+    }
+    // Return in reverse chronological order (newest to oldest)
+    return formattedMessages;
+  }
+  async saveCodeAgentResult(request, sandboxUrl, fragmentTitle, responseContent, files, summary, isError, canvasLayers) {
+    const {
+      projectId,
+      owner,
+      orgName,
+      modelConfig
+    } = request;
+    // Validate required fields for fragment creation
+    // if (!owner || !orgName) {
+    //     this.logger.error('Missing required fields for fragment creation', {
+    //         owner: owner || 'undefined',
+    //         orgName: orgName || 'undefined',
+    //         projectId,
+    //     });
+    //     throw new Error('Owner and orgName are required for fragment creation');
+    // }
+    if (isError) {
+      try {
+        console.log('Creating error message');
+        const errorMessage = await this.repository.create({
+          message: 'Something went wrong. Please try again.',
+          type: AiAgentMessageType.ERROR,
+          editedBy: owner,
+          author: owner,
+          props: {
+            role: AiAgentMessageRole.ASSISTANT,
+            projectId: projectId?.toString?.(),
+            template: modelConfig?.template || 'nextjs',
+            fragment: {
+              sandboxUrl,
+              title: fragmentTitle || 'Something went wrong. Please try again.',
+              files,
+              owner,
+              orgName,
+              canvasLayers,
+              summary
+            }
+          }
+        });
+        console.log('Error message created successfully:', errorMessage.id);
+        // this.pubsub.publish(`POST_CREATED.${projectId}`, errorMessage);
+        return errorMessage;
+      } catch (errorCreationFailed) {
+        console.error('Error message creation failed:', errorCreationFailed);
+        throw errorCreationFailed;
+      }
+    }
+    // Create assistant message with fragment
+    let messageDoc;
+    try {
+      console.log('Creating assistant message');
+      messageDoc = await this.repository.create({
+        message: responseContent || 'Code generated successfully',
+        type: AiAgentMessageType.RESULT,
+        editedBy: owner,
+        author: owner,
+        props: {
+          role: AiAgentMessageRole.ASSISTANT,
+          projectId: projectId?.toString?.(),
+          template: modelConfig?.template || 'nextjs',
+          fragment: {
+            sandboxUrl,
+            title: fragmentTitle || 'Generated Page',
+            files,
+            owner,
+            orgName,
+            canvasLayers,
+            summary
+          }
+        }
+      });
+    } catch (messageError) {
+      console.error('Assistant message creation failed:', messageError);
+      throw messageError;
     }
+    return messageDoc;
   }
-  // eslint-disable-next-line class-methods-use-this
-  createPostWithPostThread(data) {
-    throw new Error('Not implemented');
+  extractSandboxId(sandboxUrl) {
+    try {
+      // Handle format: https://3000-{sandboxId}.yarntra.ai
+      const url = new URL(sandboxUrl);
+      const hostname = url.hostname;
+      // Extract sandbox ID from hostname format: 3000-{sandboxId}.yarntra.ai
+      if (hostname.includes('yarntra.ai')) {
+        const match = hostname.match(/^3000-(.+)\.yarntra\.ai$/);
+        return match ? match[1] : null;
+      }
+      // Fallback: try extracting from path (for other URL formats)
+      const pathParts = url.pathname.split('/');
+      return pathParts[pathParts.length - 1] || null;
+    } catch (error) {
+      console.error('Error extracting sandbox ID from URL:', sandboxUrl, error);
+      return null;
+    }
+  }
+  async updateSandboxFile(projectId, messageId, filePath, content) {
+    try {
+      const post = await this.get(messageId);
+      if (!post) {
+        throw new Error('Message not found');
+      }
+      if (!post) {
+        return {
+          success: false,
+          message: `Post not found with ID: ${messageId}`,
+          filePath,
+          timestamp: new Date().toISOString(),
+          syncStatus: 'error'
+        };
+      }
+      // Extract sandbox ID from URL (assuming format like e2b.dev/sandbox/{sandboxId})
+      const sandboxId = this.extractSandboxId(post?.props?.fragment?.sandboxUrl);
+      if (!sandboxId) {
+        return {
+          success: false,
+          message: 'Invalid sandbox URL',
+          filePath,
+          timestamp: new Date().toISOString(),
+          syncStatus: 'error'
+        };
+      }
+      // Connect to E2B sandbox and update file
+      const sandbox = await getSandbox(sandboxId);
+      await sandbox.files.write(filePath, content);
+      // Update fragment with new file content and version
+      const updatedFiles = {
+        ...post?.props?.fragment?.files,
+        [filePath]: content
+      };
+      const fileVersions = {
+        ...(post?.props?.fragment?.fileVersions ?? {}),
+        [filePath]: Date.now()
+      };
+      await this.update(messageId, {
+        props: {
+          fragment: {
+            files: updatedFiles,
+            fileVersions,
+            syncStatus: 'synced'
+          }
+        }
+      });
+      const timestamp = new Date().toISOString();
+      // Publish file update event via GraphQL subscription
+      await this.pubsub.publish('FILE_UPDATED', {
+        fileUpdated: {
+          projectId,
+          messageId,
+          // Use the original fragmentId (messageId from frontend)
+          filePath,
+          content,
+          operation: 'update',
+          timestamp,
+          syncStatus: 'synced'
+        }
+      });
+      return {
+        success: true,
+        message: 'File updated successfully',
+        filePath,
+        timestamp,
+        syncStatus: 'synced'
+      };
+    } catch (error) {
+      console.error('Error updating sandbox file:', error);
+      // Update sync status to error
+      const post = await this.get(messageId);
+      if (post) {
+        await this.update(messageId, {
+          props: {
+            fragment: {
+              syncStatus: 'error'
+            }
+          }
+        });
+      }
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : 'Unknown error occurred',
+        filePath,
+        timestamp: new Date().toISOString(),
+        syncStatus: 'error'
+      };
+    }
   }
 };
-PostService = PostService_1 = __decorate([__param(0, inject(SERVER_TYPES.PostRepository)), __param(1, inject(SERVER_TYPES.ChannelRepository)), __param(2, inject(SERVER_TYPES.FileInfoService)), __param(3, inject(SERVER_TYPES.MessengerNotificationService)), __param(4, inject(CommonType.MOLECULER_BROKER)), __param(5, inject('PubSub')), __param(6, inject('Logger')), __metadata("design:paramtypes", [PostRepository, ChannelRepository, Object, Object, ServiceBroker, PubSubEngine, Object])], PostService);export{PostService};//# sourceMappingURL=post-service.js.map
+PostService = PostService_1 = __decorate([__param(0, inject(SERVER_TYPES.PostRepository)), __param(1, inject(SERVER_TYPES.ChannelRepository)), __param(2, inject(SERVER_TYPES.FileInfoService)), __param(3, inject(SERVER_TYPES.MessengerNotificationService)), __param(4, inject(SERVER_TYPES.AiFragmentService)), __param(5, inject(CommonType.MOLECULER_BROKER)), __param(6, inject('PubSub')), __param(7, inject(SERVER_TYPES.IRedisCacheManager)), __param(8, inject(CommonType.REDIS_CLIENT)), __param(9, inject('Logger')), __metadata("design:paramtypes", [PostRepository, ChannelRepository, Object, Object, Object, ServiceBroker, PubSubEngine, Object, Function, Object])], PostService);export{PostService};//# sourceMappingURL=post-service.js.map