@futdevpro/nts-dynamo 1.14.7 → 1.14.9

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.',
+      });
+    }
+  }
+}