http-request-manager 18.15.34 → 18.16.1

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

@@ -1,477 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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

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

@@ -1,10 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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
-    );
-  }
-}