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

package/lib/services/proxy-services/post-microservice.js

@@ -1,5 +1,24 @@
-import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {MoleculerTopics,PostServiceCommands}from'common';import {BaseProxyService}from'@common-stack/store-mongo';import'@cdm-logger/core';let PostProxyService = class PostProxyService extends BaseProxyService {
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {MoleculerTopics,PostServiceCommands}from'common/server';import {BaseProxyService}from'@common-stack/store-mongo';import'@cdm-logger/core';import {DisposableCollection}from'@adminide-stack/core';/**
+ * Post Microservice Implementation
+ *
+ * This microservice 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 through service broker delegation.
+ *
+ * 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
+ */
+let PostProxyService = class PostProxyService extends BaseProxyService {
   logger;
+  toDispose = new DisposableCollection();
   topic = MoleculerTopics.PostService;
   constructor(broker, logger) {
     super(broker, logger.child({
@@ -7,58 +26,608 @@ import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from
     }));
     this.logger = logger;
   }
-  attachUploadedFile(postId, file, createdBy) {
-    return this.callAction(PostServiceCommands.AttachUploadedFile, {
-      file,
-      createdBy,
-      postId
-    });
-  }
-  createFileUploadLink(postId, filename, userId) {
-    return this.callAction(PostServiceCommands.CreateFileUploadLink, {
-      filename,
-      userId,
-      postId
-    });
-  }
-  attachUploadedFiles(postId, files, createdBy) {
-    return this.callAction(PostServiceCommands.AttachUploadedFiles, {
-      files,
-      createdBy,
-      postId
-    });
-  }
-  createFilesUploadLink(postId, filenames, userId) {
-    return this.callAction(PostServiceCommands.CreateFilesUploadLink, {
-      filenames,
-      userId,
-      postId
-    });
-  }
-  deleteFile(url) {
-    return this.callAction(PostServiceCommands.DeleteFile, {
-      url
-    });
-  }
-  readMessage(messageId, user) {
-    return this.callAction(PostServiceCommands.ReadMessage, {
-      ...messageId,
-      user
-    });
-  }
-  deliverMessage(messageId, user) {
-    return this.callAction(PostServiceCommands.DeliverMessage, {
-      ...messageId,
-      user
-    });
-  }
-  createWithoutSubscription(data) {
-    return this.callAction(PostServiceCommands.CreateWithoutSubscription, {
-      data
-    });
-  }
-  createPostWithPostThread(data) {
-    return this.callAction(PostServiceCommands.CreatePostWithPostThread, data);
+  /**
+   * Disposes of resources used by the service
+   */
+  dispose() {
+    this.toDispose.dispose();
+  }
+  /**
+   * 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 {
+      this.logger.debug('Creating file upload link via microservice', {
+        postId,
+        filename,
+        userId
+      });
+      const result = await this.callAction(PostServiceCommands.CreateFileUploadLink, {
+        filename,
+        userId,
+        postId
+      });
+      if (!result) {
+        return new Error('Failed to create file upload link');
+      }
+      this.logger.debug('File upload link created successfully via microservice', {
+        postId,
+        filename,
+        userId
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error creating file upload link via microservice: %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) {
+    try {
+      this.logger.debug('Attaching uploaded file via microservice', {
+        postId,
+        file,
+        createdBy
+      });
+      const result = await this.callAction(PostServiceCommands.AttachUploadedFile, {
+        file,
+        createdBy,
+        postId
+      });
+      if (!result) {
+        return new Error('Failed to attach uploaded file');
+      }
+      this.logger.debug('File attached successfully via microservice', {
+        postId,
+        fileId: result.id,
+        createdBy
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error attaching uploaded file via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while attaching file');
+    }
+  }
+  /**
+   * 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 {
+      this.logger.debug('Creating multiple file upload links via microservice', {
+        postId,
+        fileCount: filenames.length,
+        userId
+      });
+      const result = await this.callAction(PostServiceCommands.CreateFilesUploadLink, {
+        filenames,
+        userId,
+        postId
+      });
+      if (!Array.isArray(result)) {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Multiple file upload links created successfully via microservice', {
+        postId,
+        fileCount: result.length
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error creating multiple file upload links via microservice: %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 {
+      this.logger.debug('Attaching multiple uploaded files via microservice', {
+        postId,
+        fileCount: files.length,
+        createdBy
+      });
+      const result = await this.callAction(PostServiceCommands.AttachUploadedFiles, {
+        files,
+        createdBy,
+        postId
+      });
+      if (!Array.isArray(result)) {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Multiple files attached successfully via microservice', {
+        postId,
+        fileCount: result.length
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error attaching multiple uploaded files via microservice: %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 - Enhanced error handling pattern with Error union type
+  async create(data) {
+    try {
+      this.logger.debug('Creating post via microservice', {
+        data
+      });
+      const result = await this.broker.call(`${this.topic}.create`, {
+        data
+      });
+      if (!result) {
+        return new Error('Failed to create post');
+      }
+      this.logger.debug('Post created successfully via microservice', {
+        postId: result.id,
+        channelId: data.channel
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error creating post via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating post');
+    }
+  }
+  /**
+   * Creates a post without real-time subscription
+   *
+   * @description Creates a post with channel updates but without real-time publishing
+   *
+   * @param {IPostServiceInput} data - Post creation data
+   * @returns {Promise<AsDomainType<IPostModel> | Error>} - Created post or error
+   */
+  // @ts-ignore - Enhanced error handling pattern with Error union type
+  async createWithoutSubscription(data) {
+    try {
+      this.logger.debug('Creating post without subscription via microservice', {
+        data
+      });
+      const result = await this.callAction(PostServiceCommands.CreateWithoutSubscription, {
+        data
+      });
+      if (!result) {
+        return new Error('Failed to create post without subscription');
+      }
+      this.logger.debug('Post created without subscription successfully via microservice', {
+        postId: result.id
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error creating post without subscription via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating post');
+    }
+  }
+  /**
+   * 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 {
+      this.logger.debug('Deleting file via microservice', {
+        url
+      });
+      const result = await this.callAction(PostServiceCommands.DeleteFile, {
+        url
+      });
+      if (typeof result !== 'boolean') {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('File deleted successfully via microservice', {
+        url,
+        success: result
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error deleting file via microservice: %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) {
+    try {
+      this.logger.debug('Marking message as read via microservice', {
+        messageId,
+        user
+      });
+      const result = await this.callAction(PostServiceCommands.ReadMessage, {
+        ...messageId,
+        user
+      });
+      if (typeof result !== 'boolean') {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Message marked as read successfully via microservice', {
+        messageId,
+        user,
+        success: result
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error marking message as read via microservice: %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) {
+    try {
+      this.logger.debug('Marking message as delivered via microservice', {
+        messageId,
+        user
+      });
+      const result = await this.callAction(PostServiceCommands.DeliverMessage, {
+        ...messageId,
+        user
+      });
+      if (typeof result !== 'boolean') {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Message marked as delivered successfully via microservice', {
+        messageId,
+        user,
+        success: result
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error marking message as delivered via microservice: %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 - Enhanced error handling pattern with Error union type
+  async createPostWithPostThread(data) {
+    try {
+      this.logger.debug('Creating post with thread via microservice', {
+        data
+      });
+      const result = await this.callAction(PostServiceCommands.CreatePostWithPostThread, data);
+      if (!result || !result.post || !result.postThread) {
+        return new Error('Failed to create post with thread');
+      }
+      this.logger.debug('Post with thread created successfully via microservice', {
+        postId: result.post.id,
+        threadId: result.postThread.id
+      });
+      return {
+        post: result.post,
+        postThread: result.postThread
+      };
+    } catch (error) {
+      this.logger.error('Error creating post with thread via microservice: %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 - Enhanced error handling pattern with Error union type
+  async getLastMessage(channelId) {
+    try {
+      this.logger.debug('Getting last message via microservice', {
+        channelId
+      });
+      const result = await this.callAction(PostServiceCommands.GetLastMessage, {
+        channelId
+      });
+      if (!result) {
+        return new Error('No messages found in channel');
+      }
+      this.logger.debug('Last message retrieved successfully via microservice', {
+        channelId,
+        postId: result.id
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting last message via microservice: %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 {
+      this.logger.debug('Getting posts by channel via microservice', {
+        channelId,
+        limit,
+        offset
+      });
+      const result = await this.broker.call(`${this.topic}.getPostsByChannel`, {
+        channelId,
+        limit,
+        offset
+      });
+      if (!Array.isArray(result)) {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Posts by channel retrieved successfully via microservice', {
+        channelId,
+        count: result.length
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting posts by channel via microservice: %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 {
+      this.logger.debug('Updating post via microservice', {
+        postId,
+        updates
+      });
+      const result = await this.broker.call(`${this.topic}.updatePost`, {
+        postId,
+        updates
+      });
+      if (!result) {
+        return new Error('Failed to update post');
+      }
+      this.logger.debug('Post updated successfully via microservice', {
+        postId
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error updating post via microservice: %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 {
+      this.logger.debug('Deleting post via microservice', {
+        postId
+      });
+      const result = await this.broker.call(`${this.topic}.deletePost`, {
+        postId
+      });
+      if (typeof result !== 'boolean') {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Post deleted successfully via microservice', {
+        postId,
+        success: result
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error deleting post via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while deleting post');
+    }
+  }
+  /**
+   * Validates post data for creation or updates
+   *
+   * @description Helper method to validate post data before processing
+   *
+   * @param {IPostServiceInput} data - Data to validate
+   * @returns {Promise<boolean | Error>} - Validation result or error
+   */
+  async validatePostData(data) {
+    try {
+      if (!data) {
+        return new Error('Post data is required');
+      }
+      if (!data.channel) {
+        return new Error('Channel is required');
+      }
+      if (!data.author) {
+        return new Error('Author is required');
+      }
+      this.logger.debug('Post data validation passed', {
+        data
+      });
+      return true;
+    } catch (error) {
+      this.logger.error('Error validating post data: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while validating post data');
+    }
+  }
+  /**
+   * Gets posts by author with pagination
+   *
+   * @description Convenience method to get posts created by a specific author
+   *
+   * @param {string} authorId - The author 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 getPostsByAuthor(authorId, limit = 50, offset = 0) {
+    try {
+      this.logger.debug('Getting posts by author via microservice', {
+        authorId,
+        limit,
+        offset
+      });
+      const result = await this.broker.call(`${this.topic}.getPostsByAuthor`, {
+        authorId,
+        limit,
+        offset
+      });
+      if (!Array.isArray(result)) {
+        return new Error('Invalid result from microservice');
+      }
+      this.logger.debug('Posts by author retrieved successfully via microservice', {
+        authorId,
+        count: result.length
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting posts by author via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while getting posts by author');
+    }
+  }
+  /**
+   * Retrieves previous messages for a specific project
+   *
+   * @description Fetches the most recent messages from a project, formatted for AI agent context.
+   *
+   * @param {string} projectId - The unique identifier of the project
+   * @param {number} limit - Maximum number of messages to retrieve (default: 5)
+   * @returns {Promise<Array<IPostModel> | Error>} - Array of formatted messages or error
+   */
+  // @ts-ignore - Enhanced error handling pattern with Error union type
+  async getPreviousMessagesByProjectId(projectId, limit) {
+    try {
+      this.logger.debug('Getting previous messages by project ID via microservice: %s', projectId);
+      const result = await this.callAction('getPreviousMessagesByProjectId', {
+        projectId,
+        limit
+      });
+      this.logger.debug('Successfully retrieved previous messages by project ID via microservice');
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting previous messages by project ID via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while getting previous messages by project ID');
+    }
+  }
+  /**
+   * Saves code agent result with comprehensive data
+   *
+   * @description Saves the result from a code agent operation including message creation,
+   * fragment generation, and project update publishing. Handles both success and error cases
+   * with proper message creation and fragment management.
+   */
+  async saveCodeAgentResult(request, sandboxUrl, fragmentTitle, responseContent, files, summary, isError, canvasLayers) {
+    try {
+      this.logger.debug('Saving code agent result via microservice', {
+        request,
+        sandboxUrl,
+        fragmentTitle,
+        responseContent,
+        files,
+        summary,
+        isError,
+        canvasLayers
+      });
+      const result = await this.callAction('saveCodeAgentResult', {
+        request,
+        sandboxUrl,
+        fragmentTitle,
+        responseContent,
+        files,
+        summary,
+        isError,
+        canvasLayers
+      });
+      this.logger.debug('Successfully saved code agent result via microservice');
+      return result;
+    } catch (error) {
+      this.logger.error('Error saving code agent result via microservice: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while saving code agent result');
+    }
+  }
+  async updateSandboxFile(projectId, messageId, filePath, content) {
+    try {
+      const result = await this.callAction('updateSandboxFile', {
+        projectId,
+        messageId,
+        filePath,
+        content
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error updating sandbox file via microservice: %o', error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : 'Unknown error occurred while updating sandbox file',
+        filePath,
+        timestamp: new Date().toISOString(),
+        syncStatus: 'error'
+      };
+    }
   }
 };
-PostProxyService = __decorate([injectable(), __param(0, inject(CommonType.MOLECULER_BROKER)), __param(1, inject('Logger')), __metadata("design:paramtypes", [ServiceBroker, Object])], PostProxyService);export{PostProxyService};//# sourceMappingURL=post-microservice.js.map
+PostProxyService = __decorate([injectable()
+// @ts-ignore - Type compatibility issue between BaseProxyService and IPostService
+, __param(0, inject(CommonType.MOLECULER_BROKER)), __param(1, inject('Logger')), __metadata("design:paramtypes", [ServiceBroker, Object])], PostProxyService);export{PostProxyService};//# sourceMappingURL=post-microservice.js.map