http-request-manager 18.15.32 → 18.15.34

package/src/lib/services/ws-manager-service/models/ws-user.model.ts

@@ -0,0 +1,38 @@
+export interface WSUserInterface {
+    id: string,
+    ldap?: string,
+    name?: string,
+    email?: string,
+    [key: string]: any,  // Allow additional properties
+}
+
+export class WSUser implements WSUserInterface {
+
+  constructor(
+    public id: string = '',
+    public ldap: string = '',
+    public name: string = '',
+    public email: string = '',
+  ) {}
+
+  static adapt(item?: any): WSUser {
+    const user = new WSUser(
+      item?.id || item?.sessionId,  // Support both for backward compatibility
+      item?.ldap,
+      item?.name,
+      item?.email,
+    );
+    // Copy any additional properties
+    if (item) {
+      Object.keys(item).forEach(key => {
+        if (!['id', 'sessionId', 'ldap', 'name', 'email'].includes(key)) {
+          (user as any)[key] = item[key];
+        }
+      });
+    }
+    return user;
+  }
+
+}
+
+

package/src/lib/services/ws-manager-service/services/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./websocket.service";
+export * from "./websocket-message.service";
+

package/src/lib/services/ws-manager-service/services/websocket-message.service.ts

@@ -0,0 +1,129 @@
+import { Injectable, inject } from '@angular/core';
+import { WebSocketManagerService } from '../websocket-service/websocket-manager.service';
+import { ChannelType } from '../models/channel-type.enum';
+import { StateMessage } from '../models/state-message.model';
+import { PublicMessage } from '../models/public-message.model';
+import { NotificationMessage } from '../models/notification-message.model';
+import { LoggerService } from '../../utils/logger.service';
+
+/**
+ * WebSocketMessageService - Unified service for sending WebSocket messages
+ *
+ * Provides type-safe methods for sending messages with automatic prefix management.
+ * Supports three message types: State (SYS-), Public (PUB-), and Notification (MES-).
+ *
+ * Features:
+ * - Type-safe message models
+ * - Automatic prefix management
+ * - Runtime validation
+ * - Boolean return values for success/failure
+ * - Silent failure with console errors
+ */
+@Injectable({ providedIn: 'root' })
+export class WebSocketMessageService {
+  private wsManagerService = inject(WebSocketManagerService);
+  private logger = new LoggerService();
+
+  /**
+   * Send state message (SYS- prefix)
+   * Used for CRUD operations and state synchronization
+   *
+   * @param path - Path array (e.g., ['ai', 'tests'])
+   * @param payload - StateMessage with sessionId and content
+   * @returns true if sent successfully, false otherwise
+   */
+  sendStateMessage(path: (string | number)[], payload: StateMessage): boolean {
+    // Validate payload
+    if (!payload?.sessionId?.id) {
+      this.logger.error('WebSocketMessageService', 'StateMessage must have sessionId.id');
+      return false;
+    }
+
+    if (!WebSocketManagerService.isConnected()) {
+      this.logger.error('WebSocketMessageService', 'Cannot send state message - not connected');
+      return false;
+    }
+
+    const channel = `${ChannelType.STATE}-${path.join('/')}`;
+    this.wsManagerService.sendMessageInChannel(channel, payload);
+    return true;
+  }
+
+  /**
+   * Send public message (PUB- prefix)
+   * Used for chat, broadcast, general messaging
+   *
+   * @param channel - Channel name (without prefix)
+   * @param payload - PublicMessage with sessionId and content.message
+   * @returns true if sent successfully, false otherwise
+   */
+  sendPublicMessage(channel: string, payload: PublicMessage): boolean {
+    // Validate payload
+    if (!payload?.sessionId?.id) {
+      this.logger.error('WebSocketMessageService', 'PublicMessage must have sessionId.id');
+      return false;
+    }
+
+    if (!payload?.content?.message) {
+      this.logger.error('WebSocketMessageService', 'PublicMessage must have content.message');
+      return false;
+    }
+
+    if (!WebSocketManagerService.isConnected()) {
+      this.logger.error('WebSocketMessageService', 'Cannot send public message - not connected');
+      return false;
+    }
+
+    const fullChannel = `${ChannelType.PUBLIC}-${channel}`;
+    this.wsManagerService.sendMessageInChannel(fullChannel, payload);
+    return true;
+  }
+
+  /**
+   * Send notification (MES- prefix)
+   * Used for persistent notifications with history
+   *
+   * @param channel - Channel name (without prefix)
+   * @param payload - NotificationMessage with sessionId and message
+   * @returns true if sent successfully, false otherwise
+   */
+  sendNotification(channel: string, payload: NotificationMessage): boolean {
+    // Validate payload
+    if (!payload?.sessionId?.id) {
+      this.logger.error('WebSocketMessageService', 'NotificationMessage must have sessionId.id');
+      return false;
+    }
+
+    if (!payload?.message) {
+      this.logger.error('WebSocketMessageService', 'NotificationMessage must have message');
+      return false;
+    }
+
+    if (!WebSocketManagerService.isConnected()) {
+      this.logger.error('WebSocketMessageService', 'Cannot send notification - not connected');
+      return false;
+    }
+
+    const fullChannel = `${ChannelType.NOTIFICATION}-${channel}`;
+    this.wsManagerService.sendMessageInChannel(fullChannel, payload);
+    return true;
+  }
+
+  /**
+   * Send to custom channel (no prefix)
+   * User provides full channel name
+   *
+   * @param channel - Full channel name
+   * @param payload - Any message payload
+   * @returns true if sent successfully, false otherwise
+   */
+  sendToCustomChannel(channel: string, payload: any): boolean {
+    if (!WebSocketManagerService.isConnected()) {
+      this.logger.error('WebSocketMessageService', 'Cannot send custom message - not connected');
+      return false;
+    }
+
+    this.wsManagerService.sendMessageInChannel(channel, payload);
+    return true;
+  }
+}

package/src/lib/services/ws-manager-service/services/websocket.service.ts

@@ -0,0 +1,434 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { WSOptions } from '../../request-manager-state-service';
+import { UUID_STR } from '../../utils/encryption/random';
+import { LoggerService } from '../../utils/logger.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class WebsocketService {
+  private logger = new LoggerService();
+
+  private socket: WebSocket | null = null;
+
+  private messages = new BehaviorSubject<any>(null);
+  public messages$: Observable<any> = this.messages.asObservable();
+
+  private connectionStatus = new BehaviorSubject<boolean>(false);
+  public connectionStatus$: Observable<boolean> = this.connectionStatus.asObservable();
+
+  private isSubscribed: boolean = false;
+
+  // Track currently subscribed channels
+  private subscribedChannels = new BehaviorSubject<Set<string>>(new Set());
+  public subscribedChannels$: Observable<Set<string>> = this.subscribedChannels.asObservable();
+
+  // Store last options for reconnection
+  private lastOptions: WSOptions | null = null;
+
+  private getSessionId(): string {
+    return sessionStorage.getItem('WSID') ?? (() => {
+      const uuid = UUID_STR()
+      sessionStorage.setItem('WSID', uuid)
+      return uuid
+    })()
+  }
+
+  private sendSubscribe(channelName: string, user: any) {
+
+      // Check if already subscribed to THIS specific channel (not just any channel)
+      const alreadySubscribed = this.subscribedChannels.value.has(channelName);
+
+      if (this.socket?.readyState === WebSocket.OPEN && !alreadySubscribed) {
+          const message = {
+              type: 'subscribe',
+              subscribedChannel: channelName,
+              content: {
+                id: this.getSessionId(),
+                ...user
+              }
+          };
+          this.socket.send(JSON.stringify(message));
+
+          // Track this channel as subscribed
+          const current = new Set(this.subscribedChannels.value);
+          current.add(channelName);
+          this.subscribedChannels.next(current);
+
+          this.isSubscribed = true; // Keep for backward compatibility
+          this.logger.debug('WebSocket', `Sent initial subscription to: ${channelName}`);
+      } else {
+          this.logger.warn('WebSocket', `Subscription prevented`, {
+            open: this.socket?.readyState === WebSocket.OPEN,
+            channel: channelName,
+            alreadySubscribed
+          });
+      }
+  }
+
+  connect(options: WSOptions, jwtToken: string) {
+
+    if (this.socket) {
+
+      if (this.socket.readyState === WebSocket.OPEN) {
+        this.logger.debug('WebSocket', 'Connection is already OPEN');
+        return;
+      }
+
+      if (this.socket.readyState === WebSocket.CONNECTING) {
+        this.logger.debug('WebSocket', 'Already CONNECTING. Waiting for handshake');
+        return;
+      }
+
+      if (this.socket.readyState === WebSocket.CLOSING || this.socket.readyState === WebSocket.CLOSED) {
+        this.logger.debug('WebSocket', `Cleaning up stale socket`, { state: this.socket.readyState });
+        this.socket.close();
+        this.socket = null;
+      }
+    }
+
+    this.isSubscribed = false;
+    // Clear tracked subscriptions for new connection
+    this.subscribedChannels.next(new Set());
+
+    const sessionId = this.getSessionId();
+    const URL = (jwtToken) ? `${options.wsServer}?token=${jwtToken}&sessionId=${sessionId}` : `${options.wsServer}?sessionId=${sessionId}`;
+
+    this.socket = new WebSocket(URL);
+
+    this.socket.onopen = () => {
+        this.logger.info('WebSocket', '📡 Connected to WebSocket');
+        this.connectionStatus.next(true);
+        this.lastOptions = options;
+
+        // Subscribe to primary channel
+        this.sendSubscribe(options.id, options.user);
+
+        // Build unified set of all channels to subscribe to (with deduplication)
+        const allChannels = new Set<string>();
+
+        // Add channels from options.channels[]
+        if (options.channels && options.channels.length > 0) {
+          options.channels.forEach(channel => allChannels.add(channel));
+        }
+
+        // Add channels from options.wsUpdateChannels[] with MES- prefix
+        if (options.wsUpdateChannels && options.wsUpdateChannels.length > 0) {
+          options.wsUpdateChannels.forEach(ch => {
+            const prefixed = ch.startsWith('MES-') ? ch : `MES-${ch}`;
+            allChannels.add(prefixed);
+          });
+        }
+
+        // Subscribe to all channels (excluding primary channel)
+        allChannels.forEach(channel => {
+          if (channel !== options.id) {
+            this.subscribeToChannel(channel);
+          }
+        });
+
+        // Re-subscribe to any previously subscribed channels not in current options
+        const previousChannels = this.subscribedChannels.value;
+        if (previousChannels.size > 0) {
+          previousChannels.forEach(channel => {
+            if (!allChannels.has(channel) && channel !== options.id) {
+              this.subscribeToChannel(channel);
+            }
+          });
+        }
+    };
+
+    this.socket.onmessage = (event) => {
+
+      try {
+
+        const data = JSON.parse(event.data);
+
+        if (data.error && data.error === 'JWT_INVALID') {
+
+          this.logger.error('WebSocket', 'JWT validation failed. Authentication error!');
+
+          this.messages.next(data);
+          this.connectionStatus.next(false);
+          this.socket?.close();
+
+          return;
+
+        }
+
+        this.messages.next(data);
+
+      } catch (error) {
+        this.logger.error('WebSocket', 'Error parsing WebSocket message', { data: event.data });
+      }
+
+    };
+
+    this.socket.onclose = () => {
+
+      this.logger.debug('WebSocket', 'Connection closed');
+
+      this.connectionStatus.next(false);
+      this.socket = null;
+    };
+
+    this.socket.onerror = (error) => {
+      this.logger.error('WebSocket', 'WebSocket error', error);
+      this.connectionStatus.next(false);
+    };
+
+  }
+
+  disconnect() {
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+  }
+
+  subscribeToChannel(channelName: string) {
+
+      if (this.socket?.readyState === WebSocket.OPEN) {
+        try {
+          const message = {
+              type: 'subscribe',
+              subscribedChannel: channelName,
+              content: {}
+          };
+
+          this.socket.send(JSON.stringify(message));
+
+          // Track locally - create new Set to trigger change detection
+          const current = new Set(this.subscribedChannels.value);
+          current.add(channelName);
+          this.subscribedChannels.next(current);
+          this.logger.debug('WebSocket', `📝 Subscribed to channel`, { channel: channelName });
+        } catch (error) {
+          this.logger.error('WebSocket', `Failed to subscribe to channel`, { channel: channelName, error });
+        }
+
+      } else {
+          this.logger.warn('WebSocket', `Cannot subscribe to channel - WebSocket not open`, { channel: channelName });
+      }
+
+  }
+
+  subscribeToChannels(channelNames: string[]) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      channelNames.forEach(channel => this.subscribeToChannel(channel));
+    } else {
+      this.logger.warn('WebSocket', 'Cannot subscribe to channels - WebSocket not open');
+    }
+  }
+
+  unsubscribeFromChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'unsubscribe', subscribedChannel: channel }));
+
+      // Remove from local tracking - create new Set to trigger change detection
+      const current = new Set(this.subscribedChannels.value);
+      current.delete(channel);
+      this.subscribedChannels.next(current);
+      this.logger.debug('WebSocket', `💬 Unsubscribed from channel`, { channel });
+    } else {
+      this.logger.error('WebSocket', 'Cannot unsubscribe - WebSocket not open');
+    }
+  }
+
+  unsubscribeToChannel(channel: string) {
+    // Deprecated: Use unsubscribeFromChannel instead
+    this.unsubscribeFromChannel(channel);
+  }
+
+  getSubscribedChannels(): Set<string> {
+    return this.subscribedChannels.value;
+  }
+
+  sendBroadcast(content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'broadcast', content }));
+      this.logger.debug('WebSocket', `📢 Send broadcast`, { content });
+    } else {
+      this.logger.error('WebSocket', 'Cannot send broadcast - WebSocket not open');
+    }
+  }
+
+  sendMessageInChannel(channel: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'statemanagerMessage', subscribedChannel: channel, content }));
+      this.logger.debug('WebSocket', `💬 Send message`, { channel, content });
+    } else {
+      this.logger.error('WebSocket', 'Cannot send message - WebSocket not open');
+    }
+  }
+
+  /**
+   * Send a message to a specific channel for channel-based messaging
+   * This uses the 'message' type which broadcasts to all subscribers in the channel
+   */
+  sendChannelMessage(channel: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'message', subscribedChannel: channel, content }));
+      this.logger.debug('WebSocket', `💬 Send channel message`, { channel, content });
+    } else {
+      this.logger.error('WebSocket', 'Cannot send channel message - WebSocket not open');
+    }
+  }
+
+  /**
+   * Send a message to multiple channels at once (batch)
+   * Sends the new batch format and falls back to legacy per-channel messages for compatibility
+   */
+  sendChannelMessageToChannels(channels: string[], content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      try {
+        // New batch format
+        this.socket.send(JSON.stringify({
+          type: 'channelMessage',
+          channels: channels,
+          data: content
+        }));
+        this.logger.debug('WebSocket', `💬 Send channel message to channels`, { channels, content });
+      } catch (error) {
+        this.logger.error('WebSocket', 'Failed to send channelMessage batch', error);
+      }
+
+      // Legacy fallback - send individual messages to each channel
+      try {
+        channels.forEach(channel => {
+          this.socket?.send(JSON.stringify({ type: 'message', subscribedChannel: channel, content }));
+        });
+      } catch (err) {
+        this.logger.warn('WebSocket', 'Legacy fallback failed sending individual messages', err);
+      }
+
+    } else {
+      this.logger.error('WebSocket', 'Cannot send message to channels - WebSocket not open');
+    }
+  }
+
+  sendMessageToUser(user: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'userMessage', subscribedChannel: user, content }));
+      this.logger.debug('WebSocket', `💬 Send message to user`, { user, content });
+    } else {
+      this.logger.error('WebSocket', 'Cannot send message to user - WebSocket not open');
+    }
+  }
+
+  getAllChannels() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getChannels' }));
+      this.logger.debug('WebSocket', '🗂️ Requested list of all channels');
+    } else {
+      this.logger.error('WebSocket', 'Cannot request channels - WebSocket not open');
+    }
+  }
+
+  createChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'createChannel', content: channel }));
+      this.logger.debug('WebSocket', '🗂️ Created channel', { channel });
+    } else {
+      this.logger.error('WebSocket', 'Cannot create channel - WebSocket not open');
+    }
+  }
+
+  deleteChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'deleteChannel', content: channel }));
+      this.logger.debug('WebSocket', '🗂️ Delete channel', { channel });
+    } else {
+      this.logger.error('WebSocket', 'Cannot delete channel - WebSocket not open');
+    }
+  }
+
+  getUsersInChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getUsers', subscribedChannel: channel }));
+      this.logger.debug('WebSocket', `👥 Requested users in channel`, { channel });
+    } else {
+      this.logger.error('WebSocket', 'Cannot request users - WebSocket not open');
+    }
+  }
+
+  // =====================
+  // Notification Channel Methods (MES- prefix)
+  // =====================
+
+  /**
+   * Create a notification channel
+   */
+  createNotificationChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'createNotificationChannel', content: channel }));
+      console.log('📢 Created notification channel:', channel);
+    } else {
+      console.error('WebSocket is not open. Cannot create notification channel.');
+    }
+  }
+
+  /**
+   * Get all notification channels (in-memory)
+   */
+  getNotificationChannels() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getNotificationChannels' }));
+      this.logger.debug('WebSocket', '📢 Requested notification channels list');
+    } else {
+      this.logger.error('WebSocket', 'Cannot request notification channels - WebSocket not open');
+    }
+  }
+
+  getTodaysNotificationChannels() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getTodaysNotificationChannels' }));
+      this.logger.debug('WebSocket', "📢 Requested today's notification channels from DB");
+    } else {
+      this.logger.error('WebSocket', "Cannot request today's notification channels - WebSocket not open");
+    }
+  }
+
+  subscribeToNotificationChannel(channel: string, options?: { startEpoch?: number; endEpoch?: number }, user?: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({
+        type: 'subscribeNotifications',
+        subscribedChannel: channel,
+        content: {
+          ...options,
+          ...user
+        }
+      }));
+      this.logger.debug('WebSocket', `📢 Subscribed to notification channel`, { channel, options });
+    } else {
+      this.logger.error('WebSocket', 'Cannot subscribe to notification channel - WebSocket not open');
+    }
+  }
+
+  unsubscribeFromNotificationChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({
+        type: 'unsubscribeNotifications',
+        subscribedChannel: channel
+      }));
+      this.logger.debug('WebSocket', `📢 Unsubscribed from notification channel`, { channel });
+    } else {
+      this.logger.error('WebSocket', 'Cannot unsubscribe from notification channel - WebSocket not open');
+    }
+  }
+
+  sendNotification(channel: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({
+        type: 'notification',
+        subscribedChannel: channel,
+        content
+      }));
+      this.logger.debug('WebSocket', `📢 Sent notification to channel`, { channel, content });
+    } else {
+      this.logger.error('WebSocket', 'Cannot send notification - WebSocket not open');
+    }
+  }
+
+}

package/src/lib/services/ws-manager-service/websocket-service/index.ts

@@ -0,0 +1 @@
+export * from './websocket-manager.service';