@futdevpro/nts-dynamo 1.14.8 → 1.14.9

package/src/_modules/messaging/_models/msg-global-settings.interface.ts

@@ -0,0 +1,49 @@
+/**
+ * Messaging Module Global Settings
+ */
+export interface DyNTS_Msg_Global_Settings {
+  /** Enable real-time socket events for messages */
+  enableRealtimeEvents?: boolean;
+  
+  /** Maximum messages per conversation to load */
+  maxMessagesPerLoad?: number;
+  
+  /** Enable conversation threading */
+  enableThreading?: boolean;
+  
+  /** Enable message reactions */
+  enableReactions?: boolean;
+  
+  /** Enable file attachments */
+  enableAttachments?: boolean;
+  
+  /** Maximum attachment size in bytes */
+  maxAttachmentSize?: number;
+  
+  /** Enable mentions */
+  enableMentions?: boolean;
+  
+  /** Enable read receipts */
+  enableReadReceipts?: boolean;
+  
+  /** Enable typing indicators */
+  enableTypingIndicators?: boolean;
+  
+  /** Integration settings */
+  integration?: {
+    /** Auto-sync bot messages to messaging system */
+    syncBotMessages?: boolean;
+    
+    /** Auto-sync assistant messages to messaging system */
+    syncAssistantMessages?: boolean;
+    
+    /** Enable agent process visualization */
+    enableAgentProcessViz?: boolean;
+  };
+  
+  /** Retry settings for failed messages */
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+  };
+}

package/src/_modules/messaging/_services/msg-conversation.data-service.ts

@@ -0,0 +1,146 @@
+import { DyFM_Error, DyFM_DBFilter } from '@futdevpro/fsm-dynamo';
+import {
+  DyFM_Msg_Conversation,
+  DyFM_msgConversation_dataParams,
+  DyFM_Msg_Participant,
+} from '@futdevpro/fsm-dynamo/messaging';
+
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+
+/**
+ * Conversation Data Service
+ * Handles CRUD operations for conversations
+ */
+export class DyNTS_Msg_Conversation_DataService extends DyNTS_DataService<DyFM_Msg_Conversation> {
+  
+  constructor(
+    set: {
+      conversation?: DyFM_Msg_Conversation;
+      issuer: string;
+    }
+  ) {
+    super(
+      new DyFM_Msg_Conversation(set?.conversation),
+      DyFM_msgConversation_dataParams,
+      set.issuer
+    );
+  }
+  
+  /**
+   * Get conversations for a user
+   */
+  async getUserConversations(userId: string): Promise<DyFM_Msg_Conversation[]> {
+    try {
+      await this.dataDBService
+        .find({
+          'participants.userId': userId,
+          __deleted: { $exists: false },
+        } as DyFM_DBFilter<DyFM_Msg_Conversation>)
+        .then((res: DyFM_Msg_Conversation[]) => {
+          this.dataList = res.sort((a, b) => (b.lastMessageAt?.getTime() || 0) - (a.lastMessageAt?.getTime() || 0));
+        });
+      
+      return this.dataList;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getUserConversations', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-GUC`,
+        userMessage: 'Failed to retrieve user conversations.',
+      });
+    }
+  }
+  
+  /**
+   * Add participant to conversation
+   */
+  async addParticipant(
+    conversationId: string,
+    participant: DyFM_Msg_Participant
+  ): Promise<void> {
+    try {
+      const conversation = await this.getDataById(conversationId);
+      
+      if (!conversation) {
+        throw new Error('Conversation not found');
+      }
+      
+      if (!conversation.participants) {
+        conversation.participants = [];
+      }
+      
+      // Check if participant already exists
+      const exists = conversation.participants.some(
+        p => p.userId === participant.userId
+      );
+      
+      if (!exists) {
+        conversation.participants.push(participant);
+        await this.saveData(conversation);
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('addParticipant', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-AP`,
+        userMessage: 'Failed to add participant to conversation.',
+      });
+    }
+  }
+  
+  /**
+   * Remove participant from conversation
+   */
+  async removeParticipant(
+    conversationId: string,
+    userId: string
+  ): Promise<void> {
+    try {
+      const conversation = await this.getDataById(conversationId);
+      
+      if (!conversation) {
+        throw new Error('Conversation not found');
+      }
+      
+      conversation.participants = conversation.participants?.filter(
+        p => p.userId !== userId
+      ) || [];
+      
+      await this.saveData(conversation);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('removeParticipant', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-RP`,
+        userMessage: 'Failed to remove participant from conversation.',
+      });
+    }
+  }
+  
+  /**
+   * Update last message info
+   */
+  async updateLastMessage(
+    conversationId: string,
+    messageId: string,
+    messagePreview: string
+  ): Promise<void> {
+    try {
+      const conversation = await this.getDataById(conversationId);
+      
+      if (!conversation) {
+        throw new Error('Conversation not found');
+      }
+      
+      conversation.lastMessageId = messageId;
+      conversation.lastMessageAt = new Date();
+      conversation.lastMessagePreview = messagePreview;
+      
+      await this.saveData(conversation);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('updateLastMessage', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-ULM`,
+        userMessage: 'Failed to update conversation last message.',
+      });
+    }
+  }
+}

package/src/_modules/messaging/_services/msg-events.service.ts

@@ -0,0 +1,267 @@
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Msg_EventKey } from '../_enums/msg-event-key.enum';
+
+/**
+ * Messaging Events Service
+ * Handles real-time socket events for messaging
+ */
+export class DyNTS_Msg_Events_Service extends DyNTS_SingletonService {
+  
+  static getInstance(): DyNTS_Msg_Events_Service {
+    return DyNTS_Msg_Events_Service.getSingletonInstance();
+  }
+  
+  /**
+   * Get socket server instance
+   * Override this in extended classes to provide custom socket server
+   */
+  protected getSocketServer(): any | null {
+    // Default: no socket server (messaging works without real-time events)
+    return null;
+  }
+  
+  /**
+   * Emit message sent event
+   */
+  emitMessageSent(message: any, conversationId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        // Emit to conversation room
+        socketServer.emitToRoom(
+          `conversation:${conversationId}`,
+          DyNTS_Msg_EventKey.messageSent,
+          message
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit message sent event', error);
+    }
+  }
+  
+  /**
+   * Emit message updated event
+   */
+  emitMessageUpdated(message: any, conversationId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(
+          `conversation:${conversationId}`,
+          DyNTS_Msg_EventKey.messageUpdated,
+          message
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit message updated event', error);
+    }
+  }
+  
+  /**
+   * Emit typing indicator
+   */
+  emitTypingIndicator(
+    userId: string,
+    conversationId: string,
+    isTyping: boolean
+  ): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        const eventKey = isTyping
+          ? DyNTS_Msg_EventKey.typingStart
+          : DyNTS_Msg_EventKey.typingStop;
+        
+        socketServer.emitToRoom(
+          `conversation:${conversationId}`,
+          eventKey,
+          { userId, conversationId }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit typing indicator', error);
+    }
+  }
+  
+  /**
+   * Emit conversation created event
+   */
+  emitConversationCreated(conversation: any, participantIds: string[]): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToUser) {
+        // Emit to each participant
+        participantIds.forEach(userId => {
+          socketServer.emitToUser(
+            userId,
+            DyNTS_Msg_EventKey.conversationCreated,
+            conversation
+          );
+        });
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit conversation created event', error);
+    }
+  }
+
+  /**
+   * Emit message deleted event
+   */
+  emitMessageDeleted(messageId: string, conversationId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(
+          `conversation:${conversationId}`,
+          DyNTS_Msg_EventKey.messageDeleted,
+          { messageId, conversationId }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit message deleted event', error);
+    }
+  }
+
+  /**
+   * Emit conversation updated event
+   */
+  emitConversationUpdated(conversation: any): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        const participantIds = conversation.participants?.map((p: any) => p.userId) || [];
+        participantIds.forEach(userId => {
+          socketServer.emitToUser(
+            userId,
+            DyNTS_Msg_EventKey.conversationUpdated,
+            conversation
+          );
+        });
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit conversation updated event', error);
+    }
+  }
+
+  /**
+   * Emit conversation deleted event
+   */
+  emitConversationDeleted(conversationId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(
+          `conversation:${conversationId}`,
+          DyNTS_Msg_EventKey.conversationDeleted,
+          { conversationId }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit conversation deleted event', error);
+    }
+  }
+
+  /**
+   * Emit participant added event
+   */
+  emitParticipantAdded(conversationId: string, userId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToUser) {
+        socketServer.emitToUser(
+          userId,
+          DyNTS_Msg_EventKey.participantAdded,
+          { conversationId, userId }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit participant added event', error);
+    }
+  }
+
+  /**
+   * Emit participant removed event
+   */
+  emitParticipantRemoved(conversationId: string, userId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToUser) {
+        socketServer.emitToUser(
+          userId,
+          DyNTS_Msg_EventKey.participantRemoved,
+          { conversationId, userId }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit participant removed event', error);
+    }
+  }
+
+  /**
+   * Emit message read event
+   */
+  emitMessageRead(messageId: string, userId: string, conversationId: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(
+          `conversation:${conversationId}`,
+          DyNTS_Msg_EventKey.messageRead,
+          { messageId, userId, conversationId }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit message read event', error);
+    }
+  }
+
+  /**
+   * Emit reaction added event
+   */
+  emitReactionAdded(messageId: string, reaction: any): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(
+          `conversation:${reaction.conversationId || 'unknown'}`,
+          DyNTS_Msg_EventKey.reactionAdded,
+          { messageId, reaction }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit reaction added event', error);
+    }
+  }
+
+  /**
+   * Emit reaction removed event
+   */
+  emitReactionRemoved(messageId: string, userId: string, emoji: string): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(
+          `conversation:${userId}`, // This should be conversationId, but we don't have it
+          DyNTS_Msg_EventKey.reactionRemoved,
+          { messageId, userId, emoji }
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('Failed to emit reaction removed event', error);
+    }
+  }
+}

package/src/_modules/messaging/_services/msg-integration.control-service.ts

@@ -0,0 +1,179 @@
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyFM_Error, DyFM_Log, DyFM_DBFilter } from '@futdevpro/fsm-dynamo';
+import { DyFM_Msg_Message, DyFM_Msg_Conversation } from '@futdevpro/fsm-dynamo/messaging';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Msg_Message_DataService } from './msg-message.data-service';
+import { DyNTS_Msg_Conversation_DataService } from './msg-conversation.data-service';
+import { DyNTS_Msg_Events_Service } from './msg-events.service';
+import { DyNTS_Msg_Util } from '../_collections/msg.util';
+import { DyNTS_Bot_Message } from '../../bot/_models/bot-message.interface';
+
+/**
+ * Messaging Integration Control Service
+ * Handles integration between messaging system and bot/assistant modules
+ */
+export class DyNTS_Msg_Integration_ControlService extends DyNTS_SingletonService {
+  
+  static getInstance(): DyNTS_Msg_Integration_ControlService {
+    return DyNTS_Msg_Integration_ControlService.getSingletonInstance();
+  }
+  
+  private eventsService = DyNTS_Msg_Events_Service.getInstance();
+  
+  /**
+   * Sync bot message to messaging system
+   * Called from bot IO when message is received
+   */
+  async syncBotMessage<T>(
+    botMessage: DyNTS_Bot_Message<T>,
+    conversationId: string,
+    issuer: string
+  ): Promise<DyFM_Msg_Message> {
+    try {
+      if (!DyNTS_global_settings.messaging_settings?.integration?.syncBotMessages) {
+        throw new Error('Bot message sync is disabled');
+      }
+      
+      // Convert bot message to messaging format
+      const msgMessage = DyNTS_Msg_Util.botMessageToMsgMessage(
+        botMessage,
+        conversationId,
+        issuer
+      );
+      
+      // Save to database
+      const messageService = new DyNTS_Msg_Message_DataService({
+        message: msgMessage,
+        issuer,
+      });
+      
+          await messageService.saveData(messageService.data, false, false);
+      
+      // Update conversation last message
+      const conversationService = new DyNTS_Msg_Conversation_DataService({
+        issuer,
+      });
+      
+      await conversationService.updateLastMessage(
+        conversationId,
+        messageService.data._id!,
+        msgMessage.content.substring(0, 100)
+      );
+      
+      // Emit real-time event
+      this.eventsService.emitMessageSent(messageService.data, conversationId);
+      
+      return messageService.data;
+    } catch (error) {
+      DyFM_Log.error('Failed to sync bot message', error);
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('syncBotMessage', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-SBM`,
+        userMessage: 'Failed to sync bot message to messaging system.',
+      });
+    }
+  }
+  
+  /**
+   * Sync assistant response to messaging system
+   * Called from assistant IO when AI responds
+   */
+  async syncAssistantMessage(
+    content: string,
+    conversationId: string,
+    aiProvider: string,
+    aiModel: string,
+    senderId: string,
+    issuer: string
+  ): Promise<DyFM_Msg_Message> {
+    try {
+      if (!DyNTS_global_settings.messaging_settings?.integration?.syncAssistantMessages) {
+        throw new Error('Assistant message sync is disabled');
+      }
+      
+      // Create AI message
+      const msgMessage = DyNTS_Msg_Util.createAIMessage(
+        conversationId,
+        content,
+        aiProvider,
+        aiModel,
+        senderId,
+        issuer
+      );
+      
+      // Save to database
+      const messageService = new DyNTS_Msg_Message_DataService({
+        message: msgMessage,
+        issuer,
+      });
+      
+          await messageService.saveData(messageService.data, false, false);
+      
+      // Update conversation last message
+      const conversationService = new DyNTS_Msg_Conversation_DataService({
+        issuer,
+      });
+      
+      await conversationService.updateLastMessage(
+        conversationId,
+        messageService.data._id!,
+        content.substring(0, 100)
+      );
+      
+      // Emit real-time event
+      this.eventsService.emitMessageSent(messageService.data, conversationId);
+      
+      return messageService.data;
+    } catch (error) {
+      DyFM_Log.error('Failed to sync assistant message', error);
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('syncAssistantMessage', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-SAM`,
+        userMessage: 'Failed to sync assistant message to messaging system.',
+      });
+    }
+  }
+  
+  /**
+   * Find or create conversation for bot channel
+   */
+  async findOrCreateBotConversation(
+    channelId: string,
+    platformSource: string,
+    issuer: string
+  ): Promise<DyFM_Msg_Conversation> {
+    try {
+      const conversationService = new DyNTS_Msg_Conversation_DataService({
+        issuer,
+      });
+      
+      // Try to find existing conversation
+      const existingConversation = await conversationService.dataDBService.findOne({
+        platformChannelId: channelId,
+        platformSource,
+        __deleted: { $exists: false },
+      } as DyFM_DBFilter<DyFM_Msg_Conversation>);
+      
+      if (existingConversation) {
+        conversationService.data = existingConversation;
+      }
+      
+      // Create new if not found
+      if (!conversationService.data._id) {
+        conversationService.data.platformChannelId = channelId;
+        conversationService.data.platformSource = platformSource;
+        conversationService.data.participants = [];
+        
+        await conversationService.saveData(conversationService.data, false, false);
+      }
+      
+      return conversationService.data;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('findOrCreateBotConversation', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-FCBC`,
+        userMessage: 'Failed to find or create bot conversation.',
+      });
+    }
+  }
+}