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

package/lib/plugins/post-moleculer-service.js

@@ -1,129 +1,338 @@
-import {Service}from'moleculer';import {MoleculerTopics,SERVER_TYPES}from'common/server';import {ApolloClientMixin}from'@adminide-stack/platform-server';import {BaseServiceMixin}from'@common-stack/store-mongo';import uniqBy from'lodash/uniqBy';import {config}from'../config/env-config.js';// import { TYPES } from '../constants';
-// import { IPostService, IPostServiceInput } from '../interfaces';
+import {Service}from'moleculer';import {MoleculerTopics,SERVER_TYPES}from'common/server';import {ApolloClientMixin}from'@adminide-stack/platform-server';import uniqBy from'lodash/uniqBy';import {logger}from'@common-stack/server-core';import {config}from'../config/env-config.js';/**
+ * Post Moleculer Service
+ * ----------------------
+ *
+ * This Moleculer service provides comprehensive post management capabilities within
+ * the messenger platform ecosystem. It acts as a distributed service layer for
+ * handling post creation, file attachments, message threading, real-time notifications,
+ * and cross-service communication.
+ *
+ * Key capabilities:
+ * - Post lifecycle management with threading support
+ * - File attachment and upload link generation
+ * - Real-time message delivery and read receipts
+ * - Post thread creation and management
+ * - Channel integration and message counting
+ * - Event-driven architecture for real-time updates
+ * - Distributed service communication via Moleculer
+ * - Comprehensive error handling and logging
+ *
+ * The service integrates with multiple platform components including channels,
+ * notifications, file management, and real-time publishing systems to provide
+ * a cohesive messaging experience across the platform.
+ */
+/**
+ * PostMoleculerService Class
+ *
+ * Comprehensive Moleculer service for distributed post management operations.
+ * Provides event-driven architecture, real-time communication, and seamless
+ * integration with other platform services.
+ */
 class PostMoleculerService extends Service {
   postService;
+  container;
   constructor(broker, {
-    container
+    container,
+    settings
   }) {
     super(broker);
+    this.container = container;
     const topic = MoleculerTopics.PostService;
     this.postService = container.get(SERVER_TYPES.PostService);
     this.pubsub = container.get('PubSub');
+    logger.info(`Initializing PostMoleculerService with topic: ${topic}`);
     this.parseServiceSchema({
       name: topic,
-      mixins: [ApolloClientMixin, BaseServiceMixin(this.postService)],
+      mixins: [ApolloClientMixin],
       settings: {
         apolloClient: {
           serverUri: config.GRAPHQL_URL
-        }
+        },
+        ...settings
       },
       events: {
+        /**
+         * Handles post thread creation events
+         * Publishes real-time updates for thread creation
+         */
         onCreatePostThread: {
           handler: async ctx => {
-            const {
-              post,
-              postThread
-            } = ctx.params;
-            const {
-              channel: channelId,
-              parentId: postParentId
-            } = post;
-            const triggerName = `THREAD_CREATED_UPDATED${channelId ? `_${channelId}` : ''}`;
-            const triggerPostThreadName = postParentId ? `THREAD_POST_CREATED_${channelId}_${postParentId}` : `POST_CREATED.${channelId}`;
-            await Promise.all([this.pubsub.publish(triggerName, {
-              isCreated: true,
-              isUpdated: false,
-              lastMessage: post,
-              data: postThread
-            }), this.pubsub.publish(triggerPostThreadName, post), this.pubsub.publish(`THREAD_CREATED_UPDATED${channelId ? `_${channelId}` : ''}${postParentId ? `_${postParentId}` : ''}`, {
-              isCreated: true,
-              isUpdated: false,
-              lastMessage: post,
-              data: postThread
-            })]);
+            try {
+              logger.debug('Processing post thread creation event', {
+                postId: ctx.params.post?.id,
+                threadId: ctx.params.postThread?.id,
+                channelId: ctx.params.post?.channel
+              });
+              const {
+                post,
+                postThread
+              } = ctx.params;
+              const {
+                channel: channelId,
+                parentId: postParentId
+              } = post;
+              const triggerName = `THREAD_CREATED_UPDATED${channelId ? `_${channelId}` : ''}`;
+              const triggerPostThreadName = postParentId ? `THREAD_POST_CREATED_${channelId}_${postParentId}` : `POST_CREATED.${channelId}`;
+              const publishPromises = [this.pubsub.publish(triggerName, {
+                isCreated: true,
+                isUpdated: false,
+                lastMessage: post,
+                data: postThread
+              }), this.pubsub.publish(triggerPostThreadName, post), this.pubsub.publish(`THREAD_CREATED_UPDATED${channelId ? `_${channelId}` : ''}${postParentId ? `_${postParentId}` : ''}`, {
+                isCreated: true,
+                isUpdated: false,
+                lastMessage: post,
+                data: postThread
+              })];
+              await Promise.all(publishPromises);
+              logger.debug('Post thread creation event processed successfully', {
+                postId: post?.id,
+                threadId: postThread?.id,
+                publishedEvents: publishPromises.length
+              });
+            } catch (error) {
+              logger.error('Error processing post thread creation event: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Handles post thread update events
+         * Updates thread participants and publishes real-time updates
+         */
         onUpdatePostThread: {
           handler: async ctx => {
-            const {
-              post,
-              postThread,
-              accountId,
-              role,
-              orgId
-            } = ctx.params;
-            const defaultResponder = [{
-              user: accountId,
-              roles: role,
-              orgName: orgId
-            }];
-            const normalizedParticipants = [...postThread?.participants, ...defaultResponder].map(i => ({
-              ...i,
-              user: i.user.toString()
-            }));
-            const participants = uniqBy(normalizedParticipants, 'user');
-            await this.broker.call(`${MoleculerTopics.PostThreadService}.update`, {
-              id: postThread.id,
-              data: {
-                replyCount: postThread.replyCount + 1,
-                lastReplyAt: post.createdAt,
-                updatedAt: post.createdAt,
-                participants
+            try {
+              logger.debug('Processing post thread update event', {
+                postId: ctx.params.post?.id,
+                threadId: ctx.params.postThread?.id,
+                accountId: ctx.params.accountId,
+                orgId: ctx.params.orgId
+              });
+              const {
+                post,
+                postThread,
+                accountId,
+                role,
+                orgId
+              } = ctx.params;
+              // Build participant list
+              const defaultResponder = [{
+                user: accountId,
+                roles: role,
+                orgName: orgId
+              }];
+              const normalizedParticipants = [...(postThread?.participants || []), ...defaultResponder].map(i => ({
+                ...i,
+                user: i.user.toString()
+              }));
+              const participants = uniqBy(normalizedParticipants, 'user');
+              // Update post thread
+              await this.broker.call(`${MoleculerTopics.PostThreadService}.update`, {
+                id: postThread.id,
+                data: {
+                  replyCount: postThread.replyCount + 1,
+                  lastReplyAt: post.createdAt,
+                  updatedAt: post.createdAt,
+                  participants
+                }
+              });
+              // Prepare trigger payload
+              const triggerPayload = {
+                isCreated: false,
+                isUpdated: true,
+                lastMessage: post,
+                data: postThread ? {
+                  ...postThread,
+                  replyCount: postThread.replyCount + 1,
+                  lastReplyAt: post.createdAt,
+                  updatedAt: post.createdAt,
+                  participants
+                } : {}
+              };
+              const {
+                channel: channelId,
+                parentId: postParentId
+              } = post;
+              const triggerName = `THREAD_CREATED_UPDATED${channelId ? `_${channelId}` : ''}`;
+              const triggerPostThreadName = `THREAD_POST_CREATED_${channelId}_${postParentId}`;
+              // Publish updates
+              await Promise.all([this.pubsub.publish(triggerName, triggerPayload), this.pubsub.publish(triggerPostThreadName, post), this.pubsub.publish(`${triggerName}${postParentId ? `_${postParentId}` : ''}`, triggerPayload)]);
+              logger.debug('Post thread update event processed successfully', {
+                postId: post?.id,
+                threadId: postThread?.id,
+                participantCount: participants.length
+              });
+            } catch (error) {
+              logger.error('Error processing post thread update event: %o', error);
+              throw error;
+            }
+          }
+        },
+        /**
+         * Handles post creation events
+         * Triggers real-time notifications and channel updates
+         */
+        onPostCreated: {
+          handler: async ctx => {
+            try {
+              logger.debug('Processing post creation event', {
+                postId: ctx.params.post?.id,
+                channelId: ctx.params.post?.channel,
+                authorId: ctx.params.post?.author
+              });
+              const {
+                post,
+                userContext
+              } = ctx.params;
+              // Emit channel update event
+              await this.broker.emit('onChannelUpdated', {
+                channelId: post.channel,
+                lastPostId: post.id,
+                lastPostAt: post.createdAt,
+                userContext
+              });
+              logger.debug('Post creation event processed successfully', {
+                postId: post?.id,
+                channelId: post?.channel
+              });
+            } catch (error) {
+              logger.error('Error processing post creation event: %o', error);
+              // Don't throw to prevent breaking post creation
+            }
+          }
+        },
+        /**
+         * Handles bulk post processing events
+         * Processes multiple posts in batch operations
+         */
+        onBulkPostProcess: {
+          handler: async ctx => {
+            try {
+              logger.debug('Processing bulk post operation', {
+                postCount: ctx.params.posts?.length,
+                operation: ctx.params.operation
+              });
+              const {
+                posts,
+                operation,
+                userContext
+              } = ctx.params;
+              for (const post of posts) {
+                switch (operation) {
+                  case 'delete':
+                    // Use the base service delete method
+                    await this.postService.delete({
+                      id: post.id
+                    });
+                    break;
+                  case 'archive':
+                    // Implementation for archiving posts
+                    break;
+                  default:
+                    logger.warn('Unknown bulk operation', {
+                      operation
+                    });
+                }
               }
-            });
-            const triggerPayload = {
-              isCreated: false,
-              isUpdated: true,
-              lastMessage: post,
-              data: postThread ? {
-                ...postThread,
-                replyCount: postThread.replyCount + 1,
-                lastReplyAt: post.createdAt,
-                updatedAt: post.createdAt,
-                participants
-              } : {}
-            };
-            const {
-              channel: channelId,
-              parentId: postParentId
-            } = post;
-            const triggerName = `THREAD_CREATED_UPDATED${channelId ? `_${channelId}` : ''}`;
-            const triggerPostThreadName = `THREAD_POST_CREATED_${channelId}_${postParentId}`;
-            await Promise.all([this.pubsub.publish(triggerName, triggerPayload), this.pubsub.publish(triggerPostThreadName, post), this.pubsub.publish(`${triggerName}${postParentId ? `_${postParentId}` : ''}`, triggerPayload)]);
+              logger.debug('Bulk post operation completed', {
+                postCount: posts.length,
+                operation
+              });
+            } catch (error) {
+              logger.error('Error processing bulk post operation: %o', error);
+              throw error;
+            }
           }
         }
       },
       actions: {
+        /**
+         * Attaches an uploaded file to a post
+         */
         attachUploadedFile: {
           params: {
             postId: 'string',
             createdBy: 'string',
             file: 'object'
           },
-          handler(ctx) {
-            const {
-              postId,
-              createdBy,
-              file
-            } = ctx.params;
-            return this.postService.attachUploadedFile(postId, file, createdBy);
+          async handler(ctx) {
+            try {
+              logger.debug('Attaching uploaded file to post', {
+                postId: ctx.params.postId,
+                createdBy: ctx.params.createdBy,
+                fileName: ctx.params.file?.name
+              });
+              const {
+                postId,
+                createdBy,
+                file
+              } = ctx.params;
+              const result = await this.postService.attachUploadedFile(postId, file, createdBy);
+              if (result instanceof Error) {
+                logger.error('Failed to attach uploaded file', {
+                  postId,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('File attached successfully', {
+                postId,
+                fileId: result?.id,
+                createdBy
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in attachUploadedFile action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Creates a file upload link for a post
+         */
         createFileUploadLink: {
           params: {
             postId: 'string',
             filename: 'string',
             userId: 'string'
           },
-          handler(ctx) {
-            const {
-              postId,
-              filename,
-              userId
-            } = ctx.params;
-            return this.postService.createFileUploadLink(postId, filename, userId);
+          async handler(ctx) {
+            try {
+              logger.debug('Creating file upload link', {
+                postId: ctx.params.postId,
+                filename: ctx.params.filename,
+                userId: ctx.params.userId
+              });
+              const {
+                postId,
+                filename,
+                userId
+              } = ctx.params;
+              const result = await this.postService.createFileUploadLink(postId, filename, userId);
+              if (result instanceof Error) {
+                logger.error('Failed to create file upload link', {
+                  postId,
+                  filename,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('File upload link created successfully', {
+                postId,
+                filename,
+                userId
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in createFileUploadLink action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Attaches multiple uploaded files to a post
+         */
         attachUploadedFiles: {
           params: {
             postId: 'string',
@@ -133,15 +342,41 @@ class PostMoleculerService extends Service {
               items: 'object'
             }
           },
-          handler(ctx) {
-            const {
-              postId,
-              createdBy,
-              files
-            } = ctx.params;
-            return this.postService.attachUploadedFiles(postId, files, createdBy);
+          async handler(ctx) {
+            try {
+              logger.debug('Attaching multiple uploaded files to post', {
+                postId: ctx.params.postId,
+                createdBy: ctx.params.createdBy,
+                fileCount: ctx.params.files?.length
+              });
+              const {
+                postId,
+                createdBy,
+                files
+              } = ctx.params;
+              const result = await this.postService.attachUploadedFiles(postId, files, createdBy);
+              if (result instanceof Error) {
+                logger.error('Failed to attach uploaded files', {
+                  postId,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('Files attached successfully', {
+                postId,
+                fileCount: result?.length,
+                createdBy
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in attachUploadedFiles action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Creates upload links for multiple files
+         */
         createFilesUploadLink: {
           params: {
             postId: 'string',
@@ -151,121 +386,423 @@ class PostMoleculerService extends Service {
             },
             userId: 'string'
           },
-          handler(ctx) {
-            const {
-              postId,
-              filenames,
-              userId
-            } = ctx.params;
-            return this.postService.createFilesUploadLink(postId, filenames, userId);
+          async handler(ctx) {
+            try {
+              logger.debug('Creating multiple file upload links', {
+                postId: ctx.params.postId,
+                fileCount: ctx.params.filenames?.length,
+                userId: ctx.params.userId
+              });
+              const {
+                postId,
+                filenames,
+                userId
+              } = ctx.params;
+              const result = await this.postService.createFilesUploadLink(postId, filenames, userId);
+              if (result instanceof Error) {
+                logger.error('Failed to create file upload links', {
+                  postId,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('File upload links created successfully', {
+                postId,
+                linkCount: result?.length,
+                userId
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in createFilesUploadLink action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Deletes a file by URL
+         */
         deleteFile: {
           params: {
             url: 'string'
           },
-          handler(ctx) {
-            const {
-              url
-            } = ctx.params;
-            return this.postService.deleteFile(url);
+          async handler(ctx) {
+            try {
+              logger.debug('Deleting file', {
+                url: ctx.params.url
+              });
+              const {
+                url
+              } = ctx.params;
+              const result = await this.postService.deleteFile(url);
+              if (result instanceof Error) {
+                logger.error('Failed to delete file', {
+                  url,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('File deleted successfully', {
+                url,
+                success: result
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in deleteFile action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Marks a message as read
+         */
         readMessage: {
           params: {
             channelId: 'string',
             messageId: 'string',
             user: 'string'
           },
-          handler(ctx) {
-            const {
-              user,
-              ...rest
-            } = ctx.params;
-            return this.postService.readMessage(rest, user);
+          async handler(ctx) {
+            try {
+              logger.debug('Marking message as read', {
+                channelId: ctx.params.channelId,
+                messageId: ctx.params.messageId,
+                userId: ctx.params.user
+              });
+              const {
+                user,
+                ...rest
+              } = ctx.params;
+              const result = await this.postService.readMessage(rest, user);
+              if (result instanceof Error) {
+                logger.error('Failed to mark message as read', {
+                  messageId: rest.messageId,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('Message marked as read successfully', {
+                messageId: rest.messageId,
+                userId: user
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in readMessage action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Marks a message as delivered
+         */
         deliverMessage: {
           params: {
             channelId: 'string',
             messageId: 'string',
             user: 'string'
           },
-          handler(ctx) {
-            const {
-              user,
-              ...rest
-            } = ctx.params;
-            return this.postService.deliverMessage(rest, user);
+          async handler(ctx) {
+            try {
+              logger.debug('Marking message as delivered', {
+                channelId: ctx.params.channelId,
+                messageId: ctx.params.messageId,
+                userId: ctx.params.user
+              });
+              const {
+                user,
+                ...rest
+              } = ctx.params;
+              const result = await this.postService.deliverMessage(rest, user);
+              if (result instanceof Error) {
+                logger.error('Failed to mark message as delivered', {
+                  messageId: rest.messageId,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('Message marked as delivered successfully', {
+                messageId: rest.messageId,
+                userId: user
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in deliverMessage action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Creates a post without subscription/real-time publishing
+         */
         createWithoutSubscription: {
           params: {
             data: 'object'
           },
           async handler(ctx) {
-            const {
-              data
-            } = ctx.params;
-            return this.postService.createWithoutSubscription(data);
+            try {
+              logger.debug('Creating post without subscription', {
+                channelId: ctx.params.data?.channel,
+                authorId: ctx.params.data?.author
+              });
+              const {
+                data
+              } = ctx.params;
+              const result = await this.postService.createWithoutSubscription(data);
+              if (result instanceof Error) {
+                logger.error('Failed to create post without subscription', {
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('Post created successfully without subscription', {
+                postId: result?.id,
+                channelId: data?.channel
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in createWithoutSubscription action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Creates a post with associated post thread
+         */
         createPostWithPostThread: {
           async handler(ctx) {
-            const {
-              threadMessageInput,
-              channelId,
-              responderId,
-              accountId,
-              postParentId,
-              postId
-            } = ctx.params;
-            const {
-              content,
-              files,
-              notificationParams
-            } = threadMessageInput;
-            const postPayload = {
-              channel: channelId,
-              message: content,
-              editedBy: responderId || accountId,
-              author: responderId || accountId,
-              files,
-              parentId: postParentId,
-              props: notificationParams ? {
+            try {
+              logger.debug('Creating post with post thread', {
+                channelId: ctx.params.channelId,
+                accountId: ctx.params.accountId,
+                postParentId: ctx.params.postParentId
+              });
+              const {
+                threadMessageInput,
+                channelId,
+                responderId,
+                accountId,
+                postParentId,
+                postId
+              } = ctx.params;
+              const {
+                content,
+                files,
                 notificationParams
-              } : undefined
-            };
-            const post = await this.postService.createWithoutSubscription({
-              ...(postId ? {
-                _id: postId
-              } : {}),
-              ...postPayload
-            });
-            const postThread = await this.handlePostThreadCreate({
-              ...ctx.params,
-              post
-            });
-            return {
-              post,
-              postThread
-            };
+              } = threadMessageInput;
+              const postPayload = {
+                channel: channelId,
+                message: content,
+                editedBy: responderId || accountId,
+                author: responderId || accountId,
+                files,
+                parentId: postParentId,
+                props: notificationParams ? {
+                  notificationParams
+                } : undefined
+              };
+              const post = await this.postService.createWithoutSubscription({
+                ...(postId ? {
+                  _id: postId
+                } : {}),
+                ...postPayload
+              });
+              if (post instanceof Error) {
+                logger.error('Failed to create post for post thread', {
+                  error: post.message
+                });
+                throw post;
+              }
+              const postThread = await this.handlePostThreadCreate({
+                ...ctx.params,
+                post: post
+              });
+              logger.debug('Post with post thread created successfully', {
+                postId: post?.id,
+                threadId: postThread?.id
+              });
+              return {
+                post,
+                postThread
+              };
+            } catch (error) {
+              logger.error('Error in createPostWithPostThread action: %o', error);
+              throw error;
+            }
           }
         },
+        /**
+         * Gets the last message in a channel
+         */
         getLastMessage: {
           params: {
             channelId: 'string'
           },
-          handler(ctx) {
-            const {
-              channelId
-            } = ctx.params;
-            return this.postService.getLastMessage(channelId);
+          async handler(ctx) {
+            try {
+              logger.debug('Getting last message', {
+                channelId: ctx.params.channelId
+              });
+              const {
+                channelId
+              } = ctx.params;
+              const result = await this.postService.getLastMessage(channelId);
+              if (result instanceof Error) {
+                logger.error('Failed to get last message', {
+                  channelId,
+                  error: result.message
+                });
+                throw result;
+              }
+              logger.debug('Last message retrieved successfully', {
+                channelId,
+                postId: result?.id
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in getLastMessage action: %o', error);
+              throw error;
+            }
+          }
+        },
+        /**
+         * Updates a post using base service method
+         */
+        updatePost: {
+          params: {
+            postId: 'string',
+            updates: 'object'
+          },
+          async handler(ctx) {
+            try {
+              logger.debug('Updating post', {
+                postId: ctx.params.postId,
+                updateKeys: Object.keys(ctx.params.updates || {})
+              });
+              const {
+                postId,
+                updates
+              } = ctx.params;
+              const result = await this.postService.update(postId, updates);
+              logger.debug('Post updated successfully', {
+                postId,
+                updatedPostId: result?.id
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in updatePost action: %o', error);
+              throw error;
+            }
+          }
+        },
+        /**
+         * Deletes a post using base service method
+         */
+        deletePost: {
+          params: {
+            postId: 'string'
+          },
+          async handler(ctx) {
+            try {
+              logger.debug('Deleting post', {
+                postId: ctx.params.postId
+              });
+              const {
+                postId
+              } = ctx.params;
+              const result = await this.postService.delete({
+                id: postId
+              });
+              logger.debug('Post deleted successfully', {
+                postId,
+                success: result
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in deletePost action: %o', error);
+              throw error;
+            }
+          }
+        },
+        /**
+         * Gets posts by channel using base service methods
+         */
+        getPostsByChannel: {
+          params: {
+            channelId: 'string',
+            limit: {
+              type: 'number',
+              optional: true,
+              default: 50
+            },
+            offset: {
+              type: 'number',
+              optional: true,
+              default: 0
+            }
+          },
+          async handler(ctx) {
+            try {
+              logger.debug('Getting posts by channel', {
+                channelId: ctx.params.channelId,
+                limit: ctx.params.limit,
+                offset: ctx.params.offset
+              });
+              const {
+                channelId,
+                limit,
+                offset
+              } = ctx.params;
+              // Use base service getAll with criteria
+              const result = await this.postService.getAll({
+                criteria: {
+                  channel: channelId
+                },
+                pagination: {
+                  limit,
+                  offset
+                }
+              });
+              logger.debug('Posts retrieved successfully', {
+                channelId,
+                postCount: result?.length
+              });
+              return result;
+            } catch (error) {
+              logger.error('Error in getPostsByChannel action: %o', error);
+              throw error;
+            }
+          }
+        },
+        /**
+         * Health check endpoint
+         */
+        healthCheck: {
+          async handler(ctx) {
+            try {
+              logger.debug('Performing post service health check');
+              return {
+                status: 'healthy',
+                timestamp: new Date().toISOString(),
+                service: 'PostMoleculerService',
+                version: '1.0.0'
+              };
+            } catch (error) {
+              logger.error('Health check failed: %o', error);
+              throw error;
+            }
           }
         }
       }
     });
+    logger.info('PostMoleculerService initialized successfully');
   }
+  /**
+   * Handles post thread creation logic
+   *
+   * @description Creates or updates post threads with proper participant management
+   *
+   * @param {Object} params - Post thread creation parameters
+   * @returns {Promise<IPostThread>} - Created or updated post thread
+   */
   async handlePostThreadCreate({
     post,
     responderId,
@@ -274,58 +811,88 @@ class PostMoleculerService extends Service {
     orgId,
     postThreadId
   }) {
-    const {
-      role
-    } = threadMessageInput;
-    const channelId = post.channel?.toString();
-    const postParentId = post.parentId?.toString();
-    const postThread = await this.getPostThread({
-      accountId,
-      postThreadId,
-      postParentId,
-      channelId,
-      role,
-      orgId
-    });
-    const channel = await this.broker.call(`${MoleculerTopics.ChannelService}.get`, {
-      id: channelId
-    });
-    const members = channel?.members?.map(m => ({
-      user: m?.user,
-      orgName: orgId,
-      roles: role
-    }));
-    const defaultResponder = [{
-      user: accountId,
-      roles: role,
-      orgName: orgId
-    }];
-    const responder = responderId ? [{
-      user: responderId,
-      roles: role,
-      orgName: orgId
-    }, ...defaultResponder] : defaultResponder;
-    const normalizedParticipants = [...members, ...(postThread?.participants || []), ...responder].map(i => ({
-      ...i,
-      user: i.user.toString()
-    }));
-    const participants = uniqBy(normalizedParticipants, 'user');
-    if (!postParentId && !postThread || postParentId && !postThread) {
-      return this.createPostThread({
-        post,
+    try {
+      logger.debug('Handling post thread creation', {
+        postId: post?.id,
+        accountId,
+        orgId,
+        hasExistingThread: !!postThreadId
+      });
+      const {
+        role
+      } = threadMessageInput;
+      const channelId = post.channel?.toString();
+      const postParentId = post.parentId?.toString();
+      const postThread = await this.getPostThread({
+        accountId,
+        postThreadId,
+        postParentId,
         channelId,
-        participants,
-        postParentId: postParentId ? postParentId : post.id
+        role,
+        orgId
       });
+      const channel = await this.broker.call(`${MoleculerTopics.ChannelService}.get`, {
+        id: channelId
+      });
+      const members = channel?.members?.map(m => ({
+        user: m?.user,
+        orgName: orgId,
+        roles: role
+      }));
+      const defaultResponder = [{
+        user: accountId,
+        roles: role,
+        orgName: orgId
+      }];
+      const responder = responderId ? [{
+        user: responderId,
+        roles: role,
+        orgName: orgId
+      }, ...defaultResponder] : defaultResponder;
+      const normalizedParticipants = [...(members || []), ...(postThread?.participants || []), ...responder].map(i => ({
+        ...i,
+        user: i.user.toString()
+      }));
+      const participants = uniqBy(normalizedParticipants, 'user');
+      if (!postParentId && !postThread || postParentId && !postThread) {
+        const result = await this.createPostThread({
+          post,
+          channelId,
+          participants,
+          postParentId: postParentId ? postParentId : post.id
+        });
+        logger.debug('New post thread created', {
+          postId: post?.id,
+          threadId: result?.id,
+          participantCount: participants.length
+        });
+        return result;
+      }
+      const result = await this.dispatchPostEventsWithParentId({
+        post,
+        postThread,
+        accountId,
+        orgId,
+        role
+      });
+      logger.debug('Existing post thread updated', {
+        postId: post?.id,
+        threadId: result?.id
+      });
+      return result;
+    } catch (error) {
+      logger.error('Error handling post thread creation: %o', error);
+      throw error;
     }
-    return this.dispatchPostEventsWithParentId({
-      post,
-      postThread,
-      accountId,
-      orgId,
-      role
-    });
   }
+  /**
+   * Retrieves a post thread by criteria
+   *
+   * @description Finds existing post threads based on various criteria
+   *
+   * @param {Object} params - Search criteria
+   * @returns {Promise<IPostThread>} - Found post thread
+   */
   async getPostThread({
     postThreadId,
     channelId,
@@ -334,31 +901,55 @@ class PostMoleculerService extends Service {
     role,
     orgId
   }) {
-    const criteria = {
-      ...(postThreadId ? {
-        _id: postThreadId
-      } : {
-        channel: channelId,
-        post: postParentId,
-        participants: {
-          $elemMatch: {
-            user: accountId,
-            ...(role ? {
-              roles: role
-            } : {}),
-            ...(orgId ? {
-              orgName: orgId
-            } : {})
+    try {
+      logger.debug('Getting post thread', {
+        postThreadId: postThreadId?.id,
+        channelId,
+        postParentId,
+        accountId,
+        orgId
+      });
+      const criteria = {
+        ...(postThreadId ? {
+          _id: postThreadId
+        } : {
+          channel: channelId,
+          post: postParentId,
+          participants: {
+            $elemMatch: {
+              user: accountId,
+              ...(role ? {
+                roles: role
+              } : {}),
+              ...(orgId ? {
+                orgName: orgId
+              } : {})
+            }
           }
-        }
-      })
-    };
-    const postThreads = await this.broker.call(`${MoleculerTopics.PostThreadService}.getAll`, {
-      criteria
-    });
-    const [postThread] = postThreads ?? [];
-    return postThread;
+        })
+      };
+      const postThreads = await this.broker.call(`${MoleculerTopics.PostThreadService}.getAll`, {
+        criteria
+      });
+      const [postThread] = postThreads ?? [];
+      logger.debug('Post thread retrieved', {
+        found: !!postThread,
+        threadId: postThread?.id
+      });
+      return postThread;
+    } catch (error) {
+      logger.error('Error getting post thread: %o', error);
+      throw error;
+    }
   }
+  /**
+   * Dispatches post events with parent ID for thread updates
+   *
+   * @description Handles event dispatching for post thread updates
+   *
+   * @param {Object} params - Event parameters
+   * @returns {Promise<IPostThread>} - Updated post thread
+   */
   async dispatchPostEventsWithParentId({
     post,
     postThread,
@@ -366,39 +957,80 @@ class PostMoleculerService extends Service {
     orgId,
     role
   }) {
-    await this.broker.emit('onUpdatePostThread', {
-      post,
-      postThread,
-      accountId,
-      orgId,
-      role
-    });
-    return {
-      ...postThread,
-      replyCount: postThread.replyCount + 1,
-      lastReplyAt: post.createdAt
-    };
+    try {
+      logger.debug('Dispatching post events with parent ID', {
+        postId: post?.id,
+        threadId: postThread?.id,
+        accountId,
+        orgId
+      });
+      await this.broker.emit('onUpdatePostThread', {
+        post,
+        postThread,
+        accountId,
+        orgId,
+        role
+      });
+      const updatedThread = {
+        ...postThread,
+        replyCount: postThread.replyCount + 1,
+        lastReplyAt: post.createdAt
+      };
+      logger.debug('Post events dispatched successfully', {
+        postId: post?.id,
+        threadId: updatedThread?.id,
+        newReplyCount: updatedThread.replyCount
+      });
+      return updatedThread;
+    } catch (error) {
+      logger.error('Error dispatching post events: %o', error);
+      throw error;
+    }
   }
+  /**
+   * Creates a new post thread
+   *
+   * @description Creates a new thread for organizing related posts
+   *
+   * @param {Object} params - Thread creation parameters
+   * @returns {Promise<IPostThread>} - Created post thread
+   */
   async createPostThread({
     channelId,
     postParentId,
     post,
     participants
   }) {
-    const postThreadData = {
-      post: postParentId,
-      channel: channelId,
-      replyCount: 0,
-      lastReplyAt: post.createdAt,
-      participants
-    };
-    const postThread = await this.broker.call(`${MoleculerTopics.PostThreadService}.create`, {
-      data: postThreadData
-    });
-    await this.broker.emit('onCreatePostThread', {
-      post,
-      postThread
-    });
-    return postThread;
+    try {
+      logger.debug('Creating new post thread', {
+        channelId,
+        postParentId,
+        postId: post?.id,
+        participantCount: participants?.length
+      });
+      const postThreadData = {
+        post: postParentId,
+        channel: channelId,
+        replyCount: 0,
+        lastReplyAt: post.createdAt,
+        participants
+      };
+      const postThread = await this.broker.call(`${MoleculerTopics.PostThreadService}.create`, {
+        data: postThreadData
+      });
+      await this.broker.emit('onCreatePostThread', {
+        post,
+        postThread
+      });
+      logger.debug('Post thread created successfully', {
+        threadId: postThread?.id,
+        channelId,
+        postParentId
+      });
+      return postThread;
+    } catch (error) {
+      logger.error('Error creating post thread: %o', error);
+      throw error;
+    }
   }
 }export{PostMoleculerService};//# sourceMappingURL=post-moleculer-service.js.map