http-request-manager 18.7.1 → 18.7.3

package/fesm2022/http-request-manager.mjs

@@ -789,7 +789,9 @@ class WebsocketService {
         })();
     }
     sendSubscribe(channelName, user) {
-        if (this.socket?.readyState === WebSocket.OPEN && !this.isSubscribed) {
+        // 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,
@@ -799,11 +801,15 @@ class WebsocketService {
                 }
             };
             this.socket.send(JSON.stringify(message));
-            this.isSubscribed = true; // Set the flag immediately after sending
+            // 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}, Subscribed: ${this.isSubscribed}`);
+            console.warn(`[CLIENT] Subscription prevented. Open: ${this.socket?.readyState === WebSocket.OPEN}, Already subscribed to ${channelName}: ${alreadySubscribed}`);
         }
     }
     connect(options, jwtToken) {
@@ -823,6 +829,8 @@ class WebsocketService {
             }
         }
         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);
@@ -2992,6 +3000,27 @@ class ChannelMessage {
 }
 
 const API_OPTS = new InjectionToken('API_OPTS');
+/**
+ * Channel type enum for different communication purposes
+ * - STATE: Private channels for state synchronization
+ * - MESSAGE: Messaging/communication channels
+ * - NOTIFICATION: Notification/broadcast channels
+ */
+var ChannelType;
+(function (ChannelType) {
+    ChannelType["STATE"] = "SYS";
+    ChannelType["MESSAGE"] = "MES";
+    ChannelType["NOTIFICATION"] = "PUB";
+})(ChannelType || (ChannelType = {}));
+/**
+ * Utility function to create prefixed channel name
+ * @param channelType - The type of channel
+ * @param channelName - The base channel name
+ * @returns Prefixed channel name (e.g., 'SYS-USERS123')
+ */
+function createChannelName(channelType, channelName) {
+    return `${channelType}-${channelName}`;
+}
 const defaultState = {
     data: [],
     dataObject: null,
@@ -3105,11 +3134,16 @@ class HTTPManagerStateService extends ComponentStore {
                     // Compare sender's session ID with current user's ID
                     // message.data.sessionId is an object with 'id' property from server
                     const stateManagerSenderId = message.data.sessionId?.id || message.data.sessionId;
+                    console.log('🔍 State Manager: Sender ID:', stateManagerSenderId, 'Current User ID:', this.user.value?.id);
                     if (stateManagerSenderId !== this.user.value?.id) {
                         console.log('💬 State Manager Message:', message.data);
+                        console.log('📥 Fetching record with path:', message.data.content.path, 'method:', message.data.content.method);
                         this.userAction.next(message.data);
                         this.fetchRecord(RequestOptions.adapt({ path: message.data.content.path }), message.data.content.method);
                     }
+                    else {
+                        console.log('⏭️ Skipping own message');
+                    }
                     break;
                 case 'channelMessage':
                     // Handle channel-based messages (from sendChannelMessage)
@@ -3339,19 +3373,27 @@ class HTTPManagerStateService extends ComponentStore {
             return fetchFromAPI();
         })));
         // FETCH RECORD
-        this.fetchRecord = (options, method) => this.effect(() => of(RequestOptions.adapt(options)).pipe(switchMap((options) => {
+        this.fetchRecord = (options, method) => this.effect(() => of(RequestOptions.adapt(options)).pipe(tap(() => console.log('🔄 fetchRecord effect triggered with path:', options?.path, 'method:', method)), switchMap((options) => {
             this.streamedResponse = [];
             const requestOptions = this.updateRequestOptions(options?.headers);
+            console.log('🌐 Making GET request to path:', options?.path);
             return this.httpManagerService.getRequest(requestOptions, options?.path)
                 .pipe(tap((data) => {
+                console.log('📦 fetchRecord received data:', data);
                 data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data;
                 const id = options.path?.length ? options.path[options.path.length - 1] : null;
-                if (method === 'DELETE')
+                if (method === 'DELETE') {
+                    console.log('🗑️ Deleting record with id:', id);
                     this.deleteData$({ id });
-                if (method === 'UPDATE')
+                }
+                if (method === 'UPDATE') {
+                    console.log('✏️ Updating record:', data);
                     this.updateData$(data);
-                if (method === 'CREATE')
+                }
+                if (method === 'CREATE') {
+                    console.log('➕ Adding record:', data);
                     this.addData$(data);
+                }
             }), concatMap((data) => {
                 if (this.hasDatabase && this.databaseOptions?.table) {
                     const id = options.path?.length ? options.path[options.path.length - 1] : null;
@@ -3480,6 +3522,36 @@ class HTTPManagerStateService extends ComponentStore {
             this.initDBStorage();
         }
     }
+    /**
+     * Add appropriate prefix to a channel name if not already present
+     */
+    prefixChannel(channel, type) {
+        const prefix = `${type}-`;
+        if (channel.startsWith(prefix)) {
+            return channel;
+        }
+        // Remove any other known prefix before adding the correct one
+        const cleanChannel = this.stripChannelPrefix(channel);
+        return `${type}-${cleanChannel}`;
+    }
+    /**
+     * Remove any known prefix from a channel name
+     */
+    stripChannelPrefix(channel) {
+        for (const type of Object.values(ChannelType)) {
+            const prefix = `${type}-`;
+            if (channel.startsWith(prefix)) {
+                return channel.slice(prefix.length);
+            }
+        }
+        return channel;
+    }
+    /**
+     * Get the base channel name without prefix (for display/user reference)
+     */
+    getBaseChannelName(channel) {
+        return this.stripChannelPrefix(channel);
+    }
     setApiRequestOptions(apiOptions, dataType, database) {
         this.apiOptions = ApiRequest.adapt(apiOptions);
         this.dataType = (dataType) ? dataType : DataType.ARRAY;
@@ -3489,6 +3561,10 @@ class HTTPManagerStateService extends ComponentStore {
             this.databaseOptions = (this.hasDatabase) ? DatabaseStorage.adapt(database) : undefined;
         }
         if (this.apiOptions.ws && this.apiOptions.ws.id !== '') {
+            // Auto-prefix channel ID for private state manager channels
+            // This ensures state manager channels are separate from user-defined channels
+            this.apiOptions.ws.id = this.prefixChannel(this.apiOptions.ws.id, ChannelType.STATE);
+            console.log(`🔒 Private state channel: ${this.apiOptions.ws.id}`);
             // Update WebSocket retry settings when options change
             if (this.apiOptions.ws?.retry) {
                 this.maxRetries = this.apiOptions.ws.retry.times || 3;
@@ -3638,6 +3714,12 @@ class HTTPManagerStateService extends ComponentStore {
             this.httpManagerService.sendMessageInChannel(wsServer, { method, path, user: this.apiOptions.ws.user });
         }
     }
+    /**
+     * Send a message to channel(s)
+     * @param message - The message content
+     * @param channels - Optional array of channel names (MES- prefix added automatically)
+     *                   Use 'allChannels' to broadcast to all
+     */
     wsMessaging(message, channels) {
         const user = this.user.value;
         const messageInfo = ChannelMessage.adapt({ ...message, fromUser: user });
@@ -3645,8 +3727,9 @@ class HTTPManagerStateService extends ComponentStore {
         if (this.wsConnection && this.apiOptions.ws) {
             // If specific channels provided, send to each channel
             if (channels && channels.length > 0) {
-                console.log(`📤 Sending to ${channels.length} channel(s):`, channels);
-                channels.forEach(channel => {
+                const prefixedChannels = channels.map(ch => ch === 'allChannels' ? ch : this.prefixChannel(ch, ChannelType.MESSAGE));
+                console.log(`📤 Sending to ${prefixedChannels.length} channel(s):`, prefixedChannels);
+                prefixedChannels.forEach(channel => {
                     if (channel === 'allChannels') {
                         this.httpManagerService.sendBroadcast(messageInfo);
                     }
@@ -3656,17 +3739,46 @@ class HTTPManagerStateService extends ComponentStore {
                 });
             }
             else {
-                // Fallback to the primary WS channel
+                // Fallback to the primary WS channel (already prefixed with SYS-)
                 const wsChannel = this.apiOptions.ws.id;
-                console.log(`📤 Sending to fallback channel:`, wsChannel);
+                console.log(`📤 Sending to state channel:`, wsChannel);
                 this.httpManagerService.sendChannelMessage(wsChannel, messageInfo);
             }
         }
     }
+    /**
+     * Subscribe to a messaging channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    subscribeToMessageChannel(channel) {
+        if (this.wsConnection) {
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.MESSAGE);
+            this.httpManagerService.subscribeToChannel(prefixedChannel);
+            console.log(`💬 Subscribed to message channel: ${prefixedChannel}`);
+        }
+        else {
+            console.warn('Cannot subscribe to message channel: WebSocket not connected.');
+        }
+    }
+    /**
+     * Unsubscribe from a messaging channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    unsubscribeFromMessageChannel(channel) {
+        if (this.wsConnection) {
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.MESSAGE);
+            this.httpManagerService.unsubscribeFromChannel(prefixedChannel);
+            console.log(`💬 Unsubscribed from message channel: ${prefixedChannel}`);
+        }
+        else {
+            console.warn('Cannot unsubscribe from message channel: WebSocket not connected.');
+        }
+    }
     // --------------------------------------------------------------------------------------------------
-    // CHANNEL MANAGEMENT
+    // CHANNEL MANAGEMENT (Raw channels - no automatic prefix)
     /**
-     * Subscribe to a single channel
+     * Subscribe to a single channel (no automatic prefix)
+     * Use subscribeToMessageChannel() for MES- prefixed channels
      */
     subscribeToChannel(channel) {
         if (this.wsConnection) {
@@ -3755,13 +3867,16 @@ class HTTPManagerStateService extends ComponentStore {
         }
     }
     // --------------------------------------------------------------------------------------------------
-    // NOTIFICATION CHANNELS (MES- prefix)
+    // NOTIFICATION CHANNELS (PUB- prefix - managed automatically)
     /**
      * Create a notification channel on the server
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     createNotificationChannel(channel) {
         if (this.wsConnection) {
-            this.httpManagerService.createNotificationChannel(channel);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.createNotificationChannel(prefixedChannel);
+            console.log(`📢 Creating notification channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot create notification channel: WebSocket not connected.');
@@ -3792,10 +3907,13 @@ class HTTPManagerStateService extends ComponentStore {
     }
     /**
      * Subscribe to a notification channel with optional date filters
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     subscribeToNotificationChannel(channel, options, user) {
         if (this.wsConnection) {
-            this.httpManagerService.subscribeToNotificationChannel(channel, options, user);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.subscribeToNotificationChannel(prefixedChannel, options, user);
+            console.log(`📢 Subscribing to notification channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot subscribe to notification channel: WebSocket not connected.');
@@ -3803,10 +3921,13 @@ class HTTPManagerStateService extends ComponentStore {
     }
     /**
      * Unsubscribe from a notification channel
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     unsubscribeFromNotificationChannel(channel) {
         if (this.wsConnection) {
-            this.httpManagerService.unsubscribeFromNotificationChannel(channel);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.unsubscribeFromNotificationChannel(prefixedChannel);
+            console.log(`📢 Unsubscribing from notification channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot unsubscribe from notification channel: WebSocket not connected.');
@@ -3814,10 +3935,13 @@ class HTTPManagerStateService extends ComponentStore {
     }
     /**
      * Send a notification to a channel
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     sendNotification(channel, content) {
         if (this.wsConnection) {
-            this.httpManagerService.sendNotification(channel, content);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.sendNotification(prefixedChannel, content);
+            console.log(`📢 Sending notification to channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot send notification: WebSocket not connected.');
@@ -4511,7 +4635,7 @@ class StateServiceDemo extends HTTPManagerStateService {
             }),
             adapter: OIDCClient.adapt,
             ws: {
-                id: 'SYS-USERS123',
+                id: 'USERS123',
                 wsServer,
                 jwtToken,
                 user,
@@ -6975,5 +7099,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomSignature, RandomStr, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, delayedRetry, requestPolling, requestStreaming };
+export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, ChannelType, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomSignature, RandomStr, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, createChannelName, delayedRetry, requestPolling, requestStreaming };
 //# sourceMappingURL=http-request-manager.mjs.map