http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,477 @@
+import { Injectable, OnDestroy } from '@angular/core';
+import { BehaviorSubject, interval, Observable, Subject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { WebSocketManagerService } from './websocket-service/websocket-manager.service';
+
+/**
+ * Message Tracker Service - Guaranteed Message Delivery
+ *
+ * Tracks message IDs, detects gaps, manages acknowledgments, and handles sync.
+ * Ensures frontend clients never miss messages even during disconnections.
+ *
+ * Features:
+ * - Per-channel message sequence tracking
+ * - Automatic gap detection and recovery
+ * - Batch acknowledgments (configurable interval)
+ * - Reconnection sync with last-seen tracking
+ * - Gap threshold alerting (10 messages before UI notification)
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class MessageTrackerService implements OnDestroy {
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CONFIGURATION
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /** Batch acknowledgment interval in milliseconds */
+  private readonly BATCH_ACK_INTERVAL_MS = 5000; // 5 seconds
+
+  /** Maximum gap before alerting UI */
+  private readonly GAP_THRESHOLD = 10;
+
+  /** Maximum messages to store in pending acks before forcing batch */
+  private readonly MAX_PENDING_ACKS = 100;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STATE TRACKING
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Track last seen message ID per channel
+   * Map<channelName, lastMessageId>
+   */
+  private lastSeen = new Map<string, number>();
+
+  /**
+   * Expected next message ID per channel (for gap detection)
+   * Map<channelName, nextExpectedId>
+   */
+  private expectedSequence = new Map<string, number>();
+
+  /**
+   * Pending acknowledgments per channel
+   * Map<channelName, Set<messageId>>
+   */
+  private pendingAcks = new Map<string, Set<number>>();
+
+  /**
+   * Gap count per channel (for threshold alerting)
+   * Map<channelName, gapCount>
+   */
+  private gapCounts = new Map<string, number>();
+
+  /**
+   * Replay mode tracking (per channel)
+   * Used to distinguish replay vs live messages
+   */
+  private inReplayMode = new Map<string, boolean>();
+
+  /**
+   * Gap retry count (for retry logic)
+   * Map<channel, retryCount>
+   */
+  private gapRetryCount = new Map<string, number>();
+
+  /** Subscription to WebSocket messages */
+  private messagesSubscription: Subscription | null = null;
+
+  /** Subject to signal destroy for takeUntil */
+  private destroy$ = new Subject<void>();
+
+  /**
+   * Track channels we want to be subscribed to (survives disconnect/reconnect)
+   * This is separate from WebSocketManagerService.subscribedChannels which tracks
+   * actual active subscriptions
+   */
+  private intendedChannels = new Set<string>();
+
+  /** Observable to emit processed messages to UI components */
+  private messagesSubject = new BehaviorSubject<any>(null);
+  public messages$: Observable<any> = this.messagesSubject.asObservable();
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // INITIALIZATION
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  constructor(private wsManager: WebSocketManagerService) {
+    // Restore state from sessionStorage (survives page reload)
+    this.restoreLastSeen();
+    this.restoreIntendedChannels();
+
+    // Start batch acknowledgment timer
+    interval(this.BATCH_ACK_INTERVAL_MS)
+      .pipe(takeUntil(this.destroy$))
+      .subscribe(() => this.sendAllBatchAcks());
+
+    // Subscribe to all incoming WebSocket messages
+    this.messagesSubscription = this.wsManager.messages$.subscribe(msg => {
+      if (msg) {
+        this.onMessage(msg);
+      }
+    });
+
+    // Listen for reconnect events - re-subscribe with lastSeenId for sync
+    this.wsManager.onReconnect$.subscribe(() => {
+      console.log('🔄 Reconnection detected, re-subscribing with lastSeenId...');
+      this.reSubscribeAllChannels();
+    });
+
+    console.log('✅ MessageTrackerService initialized');
+  }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+    this.persistLastSeen(); // This now also persists intendedChannels
+    this.messagesSubscription?.unsubscribe();
+    console.log('🛑 MessageTrackerService destroyed');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // MESSAGE HANDLING
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Process incoming message
+   * Tracks ID, detects gaps, queues acknowledgment
+   */
+  private onMessage(msg: any): void {
+    const { type, channel, messageId, isReplay } = msg;
+
+    // Only track messages with IDs (ignore legacy messages without messageId)
+    if (messageId === undefined || messageId === null) {
+      console.warn('⚠️ Received message without ID (legacy format):', msg);
+      // Still forward legacy messages to UI
+      this.messagesSubject.next(msg);
+      return;
+    }
+
+    // Handle replay mode transitions
+    if (isReplay && !this.inReplayMode.get(channel)) {
+      console.log(`🔄 Entering replay mode for channel: ${channel}`);
+      this.inReplayMode.set(channel, true);
+    } else if (!isReplay && this.inReplayMode.get(channel)) {
+      console.log(`✅ Exiting replay mode for channel: ${channel}`);
+      this.inReplayMode.set(channel, false);
+    }
+
+    // Track message and detect gaps
+    this.trackMessage(channel, messageId, isReplay);
+
+    // Forward message to UI components
+    this.messagesSubject.next(msg);
+  }
+
+  /**
+   * Track message ID and detect gaps
+   */
+  private trackMessage(channel: string, messageId: number, isReplay: boolean): void {
+    const expected = this.expectedSequence.get(channel) || 1;
+
+    // Gap detection
+    if (messageId !== expected) {
+      console.warn(`⚠️ Gap detected in channel "${channel}": expected ${expected}, got ${messageId}`);
+
+      // Increment gap count
+      const currentGapCount = this.gapCounts.get(channel) || 0;
+      const newGapCount = currentGapCount + 1;
+      this.gapCounts.set(channel, newGapCount);
+
+      // Check threshold
+      if (newGapCount >= this.GAP_THRESHOLD) {
+        console.error(`🚨 Gap threshold exceeded for channel "${channel}": ${newGapCount} gaps`);
+        this.onGapThresholdExceeded(channel, newGapCount);
+      }
+
+      // Request gap fill
+      this.requestGapFill(channel, expected, messageId - 1);
+    } else {
+      // Reset gap count and retry count on successful sequence
+      this.gapCounts.set(channel, 0);
+      this.gapRetryCount.set(channel, 0);
+    }
+
+    // Update tracking
+    this.lastSeen.set(channel, messageId);
+    this.expectedSequence.set(channel, messageId + 1);
+
+    // Persist to sessionStorage (debounced in production)
+    this.persistLastSeen();
+
+    // Queue for acknowledgment
+    this.queueAck(channel, messageId);
+
+    // Check if we should force batch ack due to volume
+    const pendingCount = this.pendingAcks.get(channel)?.size || 0;
+    if (pendingCount >= this.MAX_PENDING_ACKS) {
+      console.log(`📦 Forcing batch ack: ${pendingCount} pending messages`);
+      this.sendBatchAck(channel);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ACKNOWLEDGMENT MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Queue message for batch acknowledgment
+   */
+  private queueAck(channel: string, messageId: number): void {
+    if (!this.pendingAcks.has(channel)) {
+      this.pendingAcks.set(channel, new Set());
+    }
+    this.pendingAcks.get(channel)!.add(messageId);
+  }
+
+  /**
+   * Send batch acknowledgments for all channels with pending acks
+   */
+  private sendAllBatchAcks(): void {
+    this.pendingAcks.forEach((messageIds, channel) => {
+      if (messageIds.size > 0) {
+        this.sendBatchAck(channel);
+      }
+    });
+  }
+
+  /**
+   * Send batch acknowledgment for a specific channel
+   */
+  private sendBatchAck(channel: string): void {
+    const messageIds = this.pendingAcks.get(channel);
+
+    if (!messageIds || messageIds.size === 0) {
+      return;
+    }
+
+    // Convert Set to sorted array
+    const sortedIds = Array.from(messageIds).sort((a, b) => a - b);
+    const ackUpTo = sortedIds[sortedIds.length - 1];
+
+    console.log(`📦 Batch ack for channel "${channel}": ackUpTo=${ackUpTo} (${messageIds.size} messages)`);
+
+    this.wsManager.send({
+      type: 'messageAckBatch',
+      channel,
+      ackUpTo,
+      // Optional: include skippedIds if you want to report gaps
+      // skippedIds: this.getSkippedIds(channel, ackUpTo)
+    });
+
+    // Clear pending acks
+    messageIds.clear();
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // GAP RECOVERY
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Request missing messages from server
+   */
+  private requestGapFill(channel: string, fromId: number, toId: number): void {
+    const retries = this.gapRetryCount.get(channel) || 0;
+
+    if (retries >= 3) {
+      console.error(`🚨 Gap fill failed after 3 retries for channel "${channel}": ${fromId} to ${toId}`);
+      // Could emit to UI for manual intervention
+      return;
+    }
+
+    console.log(`🔍 Requesting gap fill for channel "${channel}": ${fromId} to ${toId} (attempt ${retries + 1})`);
+
+    this.wsManager.send({
+      type: 'gapRequest',
+      channel,
+      fromId,
+      toId
+    });
+
+    this.gapRetryCount.set(channel, retries + 1);
+  }
+
+  /**
+   * Handle gap threshold exceeded (optional: alert UI)
+   */
+  private onGapThresholdExceeded(channel: string, gapCount: number): void {
+    console.warn(`⚠️ High gap count for channel "${channel}": ${gapCount} missed messages`);
+    // Could emit to a separate observable for UI components to subscribe to
+    // this.gapAlerts.next({ channel, gapCount });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SUBSCRIPTION MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Subscribe to channel with sync support
+   * Automatically includes lastSeenId for replay
+   */
+  subscribeToChannel(channel: string, userData?: any): void {
+    const lastSeenId = this.lastSeen.get(channel) || 0;
+
+    console.log(`📥 Subscribing to channel "${channel}" with lastSeenId=${lastSeenId}`);
+    console.log(`📝 Adding to intendedChannels (now has ${this.intendedChannels.size + 1} channels)`);
+
+    // Track this channel as intended (survives disconnect/reconnect)
+    this.intendedChannels.add(channel);
+    this.persistIntendedChannels();
+
+    this.wsManager.sendSubscribeWithLastSeen(channel, userData, lastSeenId);
+  }
+
+  /**
+   * Re-subscribe to all previously subscribed channels after reconnect
+   * Includes lastSeenId for each channel to trigger message replay
+   */
+  private reSubscribeAllChannels(): void {
+    // Use intendedChannels which survives disconnect/reconnect
+    const channels = Array.from(this.intendedChannels);
+
+    console.log(`🔄 Re-subscribing to ${channels.length} channel(s) with lastSeenId...`);
+
+    channels.forEach((channel: string) => {
+      this.subscribeToChannel(channel);
+    });
+
+    console.log(`✅ Re-subscription complete for ${channels.length} channel(s)`);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STATE PERSISTENCE
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Persist lastSeen to sessionStorage (survives page reload)
+   */
+  private persistLastSeen(): void {
+    try {
+      const data = JSON.stringify(Array.from(this.lastSeen.entries()));
+      sessionStorage.setItem('messageLastSeen', data);
+
+      // Also persist intendedChannels
+      this.persistIntendedChannels();
+    } catch (err: any) {
+      console.warn('⚠️ Failed to persist lastSeen:', err.message);
+    }
+  }
+
+  /**
+   * Restore lastSeen from sessionStorage
+   */
+  private restoreLastSeen(): void {
+    try {
+      const data = sessionStorage.getItem('messageLastSeen');
+      if (data) {
+        const entries = JSON.parse(data);
+        this.lastSeen = new Map(entries);
+
+        // Rebuild expectedSequence from restored lastSeen
+        this.lastSeen.forEach((lastId, channel) => {
+          this.expectedSequence.set(channel, lastId + 1);
+        });
+
+        console.log('📥 Restored lastSeen from sessionStorage:', this.lastSeen.size, 'channels');
+      }
+    } catch (err: any) {
+      console.warn('⚠️ Failed to restore lastSeen:', err.message);
+    }
+  }
+
+  /**
+   * Persist intendedChannels to sessionStorage
+   */
+  private persistIntendedChannels(): void {
+    try {
+      const channels = Array.from(this.intendedChannels);
+      sessionStorage.setItem('intendedChannels', JSON.stringify(channels));
+    } catch (err: any) {
+      console.warn('⚠️ Failed to persist intendedChannels:', err.message);
+    }
+  }
+
+  /**
+   * Restore intendedChannels from sessionStorage
+   */
+  private restoreIntendedChannels(): void {
+    try {
+      const data = sessionStorage.getItem('intendedChannels');
+      if (data) {
+        const channels = JSON.parse(data);
+        this.intendedChannels = new Set(channels);
+        console.log('📥 Restored intendedChannels from sessionStorage:', this.intendedChannels.size, 'channels');
+      }
+    } catch (err: any) {
+      console.warn('⚠️ Failed to restore intendedChannels:', err.message);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PUBLIC ACCESSORS
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Get last seen message ID for a channel
+   */
+  getLastSeenId(channel: string): number {
+    return this.lastSeen.get(channel) || 0;
+  }
+
+  /**
+   * Get expected next message ID for a channel
+   */
+  getExpectedNextId(channel: string): number {
+    return this.expectedSequence.get(channel) || 1;
+  }
+
+  /**
+   * Check if currently in replay mode for a channel
+   */
+  isInReplayMode(channel: string): boolean {
+    return this.inReplayMode.get(channel) || false;
+  }
+
+  /**
+   * Get gap count for a channel
+   */
+  getGapCount(channel: string): number {
+    return this.gapCounts.get(channel) || 0;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // UTILITY METHODS
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Get skipped IDs between expected and received (for detailed gap reporting)
+   */
+  private getSkippedIds(channel: string, upToId: number): number[] {
+    const expected = this.expectedSequence.get(channel) || 1;
+    const skipped: number[] = [];
+
+    for (let i = expected; i < upToId; i++) {
+      const pending = this.pendingAcks.get(channel);
+      if (!pending?.has(i)) {
+        skipped.push(i);
+      }
+    }
+
+    return skipped;
+  }
+
+  /**
+   * Clear all tracking state (useful for debugging or manual reset)
+   */
+  clearState(): void {
+    this.lastSeen.clear();
+    this.expectedSequence.clear();
+    this.pendingAcks.clear();
+    this.gapCounts.clear();
+    this.inReplayMode.clear();
+    this.gapRetryCount.clear();
+    this.persistLastSeen();
+    console.log('🧹 MessageTracker state cleared');
+  }
+}

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

@@ -0,0 +1,29 @@
+export interface ChannelInfoInterface {
+  name: string
+  canSubscribe: boolean
+}
+
+export class ChannelInfo implements ChannelInfoInterface {
+
+  constructor(
+    public name = '',
+    public canSubscribe = false,
+  ) {}
+
+  static adapt(item?: any): ChannelInfo {
+    // Handle string input (backward compatibility with old server responses)
+    if (typeof item === 'string') {
+      return new ChannelInfo(item, true);  // Assume subscribable
+    }
+
+    // Handle object input (new server responses)
+    // Default canSubscribe to true if not specified (backward compat)
+    return new ChannelInfo(
+      item?.name,
+      item?.canSubscribe ?? true,
+    )
+  }
+
+}
+
+

package/src/lib/services/ws-manager-service/models/channel-message-data.model.ts

@@ -0,0 +1,24 @@
+import { UserMessage } from "./user-message.model"
+
+export interface ChannelMessageInterface {
+    channel: string,
+    users: UserMessage[],
+}
+
+export class ChannelMessage implements ChannelMessageInterface {
+
+  constructor(
+    public channel: string,
+    public users: UserMessage[] = [],
+  ) {}
+
+  static adapt(item?: any): ChannelMessage {
+
+    return new ChannelMessage(
+      item?.channel,
+      (item?.users) ? item?.users.map((userItem: any) => UserMessage.adapt(userItem)) : [],
+    )
+
+  }
+
+}

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

@@ -0,0 +1,36 @@
+import { WSUser } from "./ws-user.model";
+
+export interface ChannelMessageInterface {
+    messageId?: number,        // NEW: Sequential ID per channel
+    channel?: string,          // NEW: Channel name
+    isReplay?: boolean,        // NEW: Replay indicator
+    sessionId: any,
+    content: any,
+    timestamp?: string,
+}
+
+export class ChannelMessage implements ChannelMessageInterface {
+
+  constructor(
+    public messageId?: number,
+    public channel?: string,
+    public isReplay?: boolean,
+    public sessionId: any = null,
+    public content: any = null,
+    public timestamp?: string,
+  ) {}
+
+  static adapt(item?: any): ChannelMessage {
+
+    return new ChannelMessage(
+      item?.messageId,
+      item?.channel,
+      item?.isReplay,
+      item?.sessionId || item?.id,  // Support both for backward compatibility
+      item?.content,
+      item?.timestamp,
+    )
+
+  }
+
+}

package/src/lib/services/ws-manager-service/models/channel-type.enum.ts

@@ -0,0 +1,6 @@
+export enum ChannelType {
+  STATE = 'SYS',           // System/state channel (CRUD operations)
+  PUBLIC = 'PUB',          // Public messaging (chat/broadcast)
+  NOTIFICATION = 'MES',    // Notification channel (persistent messages)
+  CUSTOM = ''              // No prefix (raw channel name)
+}

package/src/lib/services/ws-manager-service/models/communication-type.enum.ts

@@ -0,0 +1,5 @@
+export enum CommunicationType {
+  MESSAGE,
+  ALERT,
+  OTHER
+}

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

@@ -0,0 +1,10 @@
+export * from "./channel-info.model";
+export * from "./ws-user.model";
+
+export * from "./communication-type.enum";
+export * from "./channel-type.enum";
+
+export * from "./state-message.model";
+export * from "./public-message.model";
+export * from "./notification-message.model";
+

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

@@ -0,0 +1,29 @@
+export interface NotificationMessageInterface {
+  sessionId: { id: string; ldap?: string; name?: string; email?: string; color?: string };
+  message: string;
+  [key: string]: any;
+}
+
+export class NotificationMessage implements NotificationMessageInterface {
+  sessionId: { id: string; ldap?: string; name?: string; email?: string; color?: string };
+  message: string;
+  [key: string]: any;
+
+  constructor(
+    sessionId: { id: string; ldap?: string; name?: string; email?: string; color?: string } = { id: '' },
+    message: string = '',
+    additionalProperties: any = {}
+  ) {
+    this.sessionId = sessionId;
+    this.message = message;
+    Object.assign(this, additionalProperties);
+  }
+
+  static adapt(item?: any): NotificationMessage {
+    return new NotificationMessage(
+      item?.sessionId,
+      item?.message,
+      item
+    );
+  }
+}

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

@@ -0,0 +1,18 @@
+export interface PublicMessageInterface {
+  sessionId: { id: string; ldap?: string; name?: string; email?: string };
+  content: { message: string; [key: string]: any };
+}
+
+export class PublicMessage implements PublicMessageInterface {
+  constructor(
+    public sessionId: { id: string; ldap?: string; name?: string; email?: string } = { id: '' },
+    public content: { message: string; [key: string]: any } = { message: '' }
+  ) {}
+
+  static adapt(item?: any): PublicMessage {
+    return new PublicMessage(
+      item?.sessionId,
+      item?.content
+    );
+  }
+}

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

@@ -0,0 +1,18 @@
+export interface StateMessageInterface {
+  sessionId: { id: string; ldap?: string; name?: string; email?: string };
+  content: any;
+}
+
+export class StateMessage implements StateMessageInterface {
+  constructor(
+    public sessionId: { id: string; ldap?: string; name?: string; email?: string } = { id: '' },
+    public content: any = {}
+  ) {}
+
+  static adapt(item?: any): StateMessage {
+    return new StateMessage(
+      item?.sessionId,
+      item?.content
+    );
+  }
+}