http-request-manager 18.7.20 → 18.7.21

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

@@ -0,0 +1,392 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { WSOptions } from '../../request-manager-state-service';
+import { UUID_STR } from '../../utils/encryption/random';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class WebsocketService {
+
+  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
+          console.log(`[CLIENT] Sent initial subscription to: ${channelName}`);
+      } else {
+          console.warn(`[CLIENT] Subscription prevented. Open: ${this.socket?.readyState === WebSocket.OPEN}, Already subscribed to ${channelName}: ${alreadySubscribed}`);
+      }
+  }
+
+  connect(options: WSOptions, jwtToken: string) {
+
+    if (this.socket) {
+
+      if (this.socket.readyState === WebSocket.OPEN) {
+        console.log('WebSocket connection is already OPEN.');
+        return;
+      }
+
+      if (this.socket.readyState === WebSocket.CONNECTING) {
+        console.log('WebSocket is already CONNECTING. Waiting for handshake.');
+        return;
+      }
+
+      if (this.socket.readyState === WebSocket.CLOSING || this.socket.readyState === WebSocket.CLOSED) {
+        console.log(`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 = () => {
+        console.log(`📡 Connected to WebSocket`);
+        this.connectionStatus.next(true);
+        this.lastOptions = options;
+
+        // Subscribe to primary channel
+        this.sendSubscribe(options.id, options.user);
+
+        // Auto-subscribe to additional channels from options.channels[]
+        if (options.channels && options.channels.length > 0) {
+          options.channels.forEach(channel => {
+            if (channel !== options.id) {
+              this.subscribeToChannel(channel);
+            }
+          });
+        }
+
+        // Re-subscribe to any previously subscribed channels (reconnection scenario)
+        const previousChannels = this.subscribedChannels.value;
+        if (previousChannels.size > 0) {
+          previousChannels.forEach(channel => {
+            if (channel !== options.id && (!options.channels || !options.channels.includes(channel))) {
+              this.subscribeToChannel(channel);
+            }
+          });
+        }
+    };
+
+    this.socket.onmessage = (event) => {
+
+      try {
+
+        const data = JSON.parse(event.data);
+
+        if (data.error && data.error === 'JWT_INVALID') {
+
+          console.error('JWT validation failed. Authentication error!');
+
+          this.messages.next(data);
+          this.connectionStatus.next(false);
+          this.socket?.close();
+
+          return;
+
+        }
+
+        this.messages.next(data);
+
+      } catch (error) {
+        console.error('Error parsing WebSocket message:', event.data);
+      }
+
+    };
+
+    this.socket.onclose = () => {
+
+      console.log('WebSocket connection closed');
+
+      this.connectionStatus.next(false);
+      this.socket = null;
+    };
+
+    this.socket.onerror = (error) => {
+      console.error('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) {
+
+          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);
+          console.log(`📝 Subscribed to channel: ${channelName}`);
+
+      } else {
+          console.warn('Cannot subscribe: WebSocket not yet open.');
+      }
+
+  }
+
+  subscribeToChannels(channelNames: string[]) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      channelNames.forEach(channel => this.subscribeToChannel(channel));
+    } else {
+      console.warn('Cannot subscribe: WebSocket not yet 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);
+      console.log(`💬 Unsubscribed from channel: ${channel}`);
+    } else {
+      console.error('WebSocket is not open. Cannot unsubscribe from channel.');
+    }
+  }
+
+  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 }));
+      console.log(`📢 Send broadcast: ${content}`);
+    } else {
+      console.error('WebSocket is not open. Cannot send broadcast.');
+    }
+  }
+
+  sendMessageInChannel(channel: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'stateMangerMessage', subscribedChannel: channel, content }));
+        console.log(`💬 Send message:`, content);
+    } else {
+      console.error('WebSocket is not open. Cannot send message.');
+    }
+  }
+
+  /**
+   * 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 }));
+      console.log(`💬 Send channel message to [${channel}]:`, content);
+    } else {
+      console.error('WebSocket is not open. Cannot send channel message.');
+    }
+  }
+
+  sendMessageToUser(user: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'userMessage', subscribedChannel: user, content }));
+        console.log(`💬 Send message:`, content);
+    } else {
+      console.error('WebSocket is not open. Cannot send message.');
+    }
+  }
+
+  getAllChannels() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getChannels' }));
+      console.log('🗂️ List of all channels');
+    } else {
+      console.error('WebSocket is not open. Cannot request channels.');
+    }
+  }
+
+  createChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'createChannel', content: channel }));
+      console.log('🗂️ Created channel:', channel);
+    } else {
+      console.error('WebSocket is not open. Cannot request channels.');
+    }
+  }
+
+  deleteChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'deleteChannel', content: channel }));
+      console.log('🗂️ Delete channel:', channel);
+    } else {
+      console.error('WebSocket is not open. Cannot request channels.');
+    }
+  }
+
+  getUsersInChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getUsers', subscribedChannel: channel }));
+      console.log(`👥 List all users in channel: ${channel}`);
+    } else {
+      console.error('WebSocket is not open. Cannot request users.');
+    }
+  }
+
+  // =====================
+  // 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' }));
+      console.log('📢 Requested notification channels list');
+    } else {
+      console.error('WebSocket is not open. Cannot request notification channels.');
+    }
+  }
+
+  /**
+   * Get today's notification channels from database
+   * Returns unique channels that have notifications posted today
+   */
+  getTodaysNotificationChannels() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ type: 'getTodaysNotificationChannels' }));
+      console.log('📢 Requested today\'s notification channels from DB');
+    } else {
+      console.error('WebSocket is not open. Cannot request today\'s notification channels.');
+    }
+  }
+
+  /**
+   * Subscribe to a notification channel with optional date filters
+   */
+  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
+        }
+      }));
+      console.log(`📢 Subscribed to notification channel: ${channel}`, options);
+    } else {
+      console.error('WebSocket is not open. Cannot subscribe to notification channel.');
+    }
+  }
+
+  /**
+   * Unsubscribe from a notification channel
+   */
+  unsubscribeFromNotificationChannel(channel: string) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({
+        type: 'unsubscribeNotifications',
+        subscribedChannel: channel
+      }));
+      console.log(`📢 Unsubscribed from notification channel: ${channel}`);
+    } else {
+      console.error('WebSocket is not open. Cannot unsubscribe from notification channel.');
+    }
+  }
+
+  /**
+   * Send a notification to a channel
+   */
+  sendNotification(channel: string, content: any) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({
+        type: 'notification',
+        subscribedChannel: channel,
+        content
+      }));
+      console.log(`📢 Sent notification to channel: ${channel}`, content);
+    } else {
+      console.error('WebSocket is not open. Cannot send notification.');
+    }
+  }
+
+}

package/src/public-api.ts

@@ -0,0 +1,14 @@
+/*
+ * Public API Surface of http-request-manager
+ */
+
+export * from './lib/index';
+export * from './lib/http-request-manager.module';
+
+export * from './lib/http-request-services-demo/http-request-services-demo.component';
+
+export * from './lib/http-request-services-demo/database-data-demo/database-data-demo.component';
+export * from './lib/http-request-services-demo/local-storage-demo/local-storage-demo.component';
+export * from './lib/http-request-services-demo/request-manager-demo/request-manager-demo.component';
+export * from './lib/http-request-services-demo/request-manager-state-demo/request-manager-state-demo.component';
+

package/tsconfig.lib.json

@@ -0,0 +1,32 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/http-request-manager",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": [],
+    "baseUrl": "./",
+    "paths": {
+      "@angular/*": ["node_modules/@angular/*"],
+      "http-request-manager": ["node_modules/http-request-manager"],
+    },
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "ES2022"
+    ]
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "enableResourceInlining": true,
+    "strictInjectionParameters": true,
+    "strictTemplates": true
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}